1
2
3 package ssa
4
5 import "internal/buildcfg"
6 import "math"
7 import "math/bits"
8 import "cmd/compile/internal/types"
9
10 func rewriteValueRISCV64(v *Value) bool {
11 switch v.Op {
12 case OpAbs:
13 v.Op = OpRISCV64FABSD
14 return true
15 case OpAdd16:
16 v.Op = OpRISCV64ADD
17 return true
18 case OpAdd32:
19 v.Op = OpRISCV64ADD
20 return true
21 case OpAdd32F:
22 v.Op = OpRISCV64FADDS
23 return true
24 case OpAdd64:
25 v.Op = OpRISCV64ADD
26 return true
27 case OpAdd64F:
28 v.Op = OpRISCV64FADDD
29 return true
30 case OpAdd8:
31 v.Op = OpRISCV64ADD
32 return true
33 case OpAddPtr:
34 v.Op = OpRISCV64ADD
35 return true
36 case OpAddr:
37 return rewriteValueRISCV64_OpAddr(v)
38 case OpAnd16:
39 v.Op = OpRISCV64AND
40 return true
41 case OpAnd32:
42 v.Op = OpRISCV64AND
43 return true
44 case OpAnd64:
45 v.Op = OpRISCV64AND
46 return true
47 case OpAnd8:
48 v.Op = OpRISCV64AND
49 return true
50 case OpAndB:
51 v.Op = OpRISCV64AND
52 return true
53 case OpAtomicAdd32:
54 v.Op = OpRISCV64LoweredAtomicAdd32
55 return true
56 case OpAtomicAdd64:
57 v.Op = OpRISCV64LoweredAtomicAdd64
58 return true
59 case OpAtomicAnd32:
60 v.Op = OpRISCV64LoweredAtomicAnd32
61 return true
62 case OpAtomicAnd8:
63 return rewriteValueRISCV64_OpAtomicAnd8(v)
64 case OpAtomicCompareAndSwap32:
65 return rewriteValueRISCV64_OpAtomicCompareAndSwap32(v)
66 case OpAtomicCompareAndSwap64:
67 v.Op = OpRISCV64LoweredAtomicCas64
68 return true
69 case OpAtomicExchange32:
70 v.Op = OpRISCV64LoweredAtomicExchange32
71 return true
72 case OpAtomicExchange64:
73 v.Op = OpRISCV64LoweredAtomicExchange64
74 return true
75 case OpAtomicLoad32:
76 v.Op = OpRISCV64LoweredAtomicLoad32
77 return true
78 case OpAtomicLoad64:
79 v.Op = OpRISCV64LoweredAtomicLoad64
80 return true
81 case OpAtomicLoad8:
82 v.Op = OpRISCV64LoweredAtomicLoad8
83 return true
84 case OpAtomicLoadPtr:
85 v.Op = OpRISCV64LoweredAtomicLoad64
86 return true
87 case OpAtomicOr32:
88 v.Op = OpRISCV64LoweredAtomicOr32
89 return true
90 case OpAtomicOr8:
91 return rewriteValueRISCV64_OpAtomicOr8(v)
92 case OpAtomicStore32:
93 v.Op = OpRISCV64LoweredAtomicStore32
94 return true
95 case OpAtomicStore64:
96 v.Op = OpRISCV64LoweredAtomicStore64
97 return true
98 case OpAtomicStore8:
99 v.Op = OpRISCV64LoweredAtomicStore8
100 return true
101 case OpAtomicStorePtrNoWB:
102 v.Op = OpRISCV64LoweredAtomicStore64
103 return true
104 case OpAvg64u:
105 return rewriteValueRISCV64_OpAvg64u(v)
106 case OpBitLen16:
107 return rewriteValueRISCV64_OpBitLen16(v)
108 case OpBitLen32:
109 return rewriteValueRISCV64_OpBitLen32(v)
110 case OpBitLen64:
111 return rewriteValueRISCV64_OpBitLen64(v)
112 case OpBitLen8:
113 return rewriteValueRISCV64_OpBitLen8(v)
114 case OpBswap16:
115 return rewriteValueRISCV64_OpBswap16(v)
116 case OpBswap32:
117 return rewriteValueRISCV64_OpBswap32(v)
118 case OpBswap64:
119 v.Op = OpRISCV64REV8
120 return true
121 case OpClosureCall:
122 v.Op = OpRISCV64CALLclosure
123 return true
124 case OpCom16:
125 v.Op = OpRISCV64NOT
126 return true
127 case OpCom32:
128 v.Op = OpRISCV64NOT
129 return true
130 case OpCom64:
131 v.Op = OpRISCV64NOT
132 return true
133 case OpCom8:
134 v.Op = OpRISCV64NOT
135 return true
136 case OpCondSelect:
137 return rewriteValueRISCV64_OpCondSelect(v)
138 case OpConst16:
139 return rewriteValueRISCV64_OpConst16(v)
140 case OpConst32:
141 return rewriteValueRISCV64_OpConst32(v)
142 case OpConst32F:
143 v.Op = OpRISCV64FMOVFconst
144 return true
145 case OpConst64:
146 return rewriteValueRISCV64_OpConst64(v)
147 case OpConst64F:
148 v.Op = OpRISCV64FMOVDconst
149 return true
150 case OpConst8:
151 return rewriteValueRISCV64_OpConst8(v)
152 case OpConstBool:
153 return rewriteValueRISCV64_OpConstBool(v)
154 case OpConstNil:
155 return rewriteValueRISCV64_OpConstNil(v)
156 case OpCopysign:
157 v.Op = OpRISCV64FSGNJD
158 return true
159 case OpCtz16:
160 return rewriteValueRISCV64_OpCtz16(v)
161 case OpCtz16NonZero:
162 v.Op = OpCtz64
163 return true
164 case OpCtz32:
165 v.Op = OpRISCV64CTZW
166 return true
167 case OpCtz32NonZero:
168 v.Op = OpCtz64
169 return true
170 case OpCtz64:
171 v.Op = OpRISCV64CTZ
172 return true
173 case OpCtz64NonZero:
174 v.Op = OpCtz64
175 return true
176 case OpCtz8:
177 return rewriteValueRISCV64_OpCtz8(v)
178 case OpCtz8NonZero:
179 v.Op = OpCtz64
180 return true
181 case OpCvt32Fto32:
182 v.Op = OpRISCV64FCVTWS
183 return true
184 case OpCvt32Fto64:
185 v.Op = OpRISCV64FCVTLS
186 return true
187 case OpCvt32Fto64F:
188 v.Op = OpRISCV64FCVTDS
189 return true
190 case OpCvt32to32F:
191 v.Op = OpRISCV64FCVTSW
192 return true
193 case OpCvt32to64F:
194 v.Op = OpRISCV64FCVTDW
195 return true
196 case OpCvt64Fto32:
197 v.Op = OpRISCV64FCVTWD
198 return true
199 case OpCvt64Fto32F:
200 v.Op = OpRISCV64FCVTSD
201 return true
202 case OpCvt64Fto64:
203 v.Op = OpRISCV64FCVTLD
204 return true
205 case OpCvt64to32F:
206 v.Op = OpRISCV64FCVTSL
207 return true
208 case OpCvt64to64F:
209 v.Op = OpRISCV64FCVTDL
210 return true
211 case OpCvtBoolToUint8:
212 v.Op = OpCopy
213 return true
214 case OpDiv16:
215 return rewriteValueRISCV64_OpDiv16(v)
216 case OpDiv16u:
217 return rewriteValueRISCV64_OpDiv16u(v)
218 case OpDiv32:
219 return rewriteValueRISCV64_OpDiv32(v)
220 case OpDiv32F:
221 v.Op = OpRISCV64FDIVS
222 return true
223 case OpDiv32u:
224 v.Op = OpRISCV64DIVUW
225 return true
226 case OpDiv64:
227 return rewriteValueRISCV64_OpDiv64(v)
228 case OpDiv64F:
229 v.Op = OpRISCV64FDIVD
230 return true
231 case OpDiv64u:
232 v.Op = OpRISCV64DIVU
233 return true
234 case OpDiv8:
235 return rewriteValueRISCV64_OpDiv8(v)
236 case OpDiv8u:
237 return rewriteValueRISCV64_OpDiv8u(v)
238 case OpEq16:
239 return rewriteValueRISCV64_OpEq16(v)
240 case OpEq32:
241 return rewriteValueRISCV64_OpEq32(v)
242 case OpEq32F:
243 v.Op = OpRISCV64FEQS
244 return true
245 case OpEq64:
246 return rewriteValueRISCV64_OpEq64(v)
247 case OpEq64F:
248 v.Op = OpRISCV64FEQD
249 return true
250 case OpEq8:
251 return rewriteValueRISCV64_OpEq8(v)
252 case OpEqB:
253 return rewriteValueRISCV64_OpEqB(v)
254 case OpEqPtr:
255 return rewriteValueRISCV64_OpEqPtr(v)
256 case OpFMA:
257 v.Op = OpRISCV64FMADDD
258 return true
259 case OpGetCallerPC:
260 v.Op = OpRISCV64LoweredGetCallerPC
261 return true
262 case OpGetCallerSP:
263 v.Op = OpRISCV64LoweredGetCallerSP
264 return true
265 case OpGetClosurePtr:
266 v.Op = OpRISCV64LoweredGetClosurePtr
267 return true
268 case OpHmul32:
269 return rewriteValueRISCV64_OpHmul32(v)
270 case OpHmul32u:
271 return rewriteValueRISCV64_OpHmul32u(v)
272 case OpHmul64:
273 v.Op = OpRISCV64MULH
274 return true
275 case OpHmul64u:
276 v.Op = OpRISCV64MULHU
277 return true
278 case OpInterCall:
279 v.Op = OpRISCV64CALLinter
280 return true
281 case OpIsInBounds:
282 v.Op = OpLess64U
283 return true
284 case OpIsNonNil:
285 v.Op = OpRISCV64SNEZ
286 return true
287 case OpIsSliceInBounds:
288 v.Op = OpLeq64U
289 return true
290 case OpLeq16:
291 return rewriteValueRISCV64_OpLeq16(v)
292 case OpLeq16U:
293 return rewriteValueRISCV64_OpLeq16U(v)
294 case OpLeq32:
295 return rewriteValueRISCV64_OpLeq32(v)
296 case OpLeq32F:
297 v.Op = OpRISCV64FLES
298 return true
299 case OpLeq32U:
300 return rewriteValueRISCV64_OpLeq32U(v)
301 case OpLeq64:
302 return rewriteValueRISCV64_OpLeq64(v)
303 case OpLeq64F:
304 v.Op = OpRISCV64FLED
305 return true
306 case OpLeq64U:
307 return rewriteValueRISCV64_OpLeq64U(v)
308 case OpLeq8:
309 return rewriteValueRISCV64_OpLeq8(v)
310 case OpLeq8U:
311 return rewriteValueRISCV64_OpLeq8U(v)
312 case OpLess16:
313 return rewriteValueRISCV64_OpLess16(v)
314 case OpLess16U:
315 return rewriteValueRISCV64_OpLess16U(v)
316 case OpLess32:
317 return rewriteValueRISCV64_OpLess32(v)
318 case OpLess32F:
319 v.Op = OpRISCV64FLTS
320 return true
321 case OpLess32U:
322 return rewriteValueRISCV64_OpLess32U(v)
323 case OpLess64:
324 v.Op = OpRISCV64SLT
325 return true
326 case OpLess64F:
327 v.Op = OpRISCV64FLTD
328 return true
329 case OpLess64U:
330 v.Op = OpRISCV64SLTU
331 return true
332 case OpLess8:
333 return rewriteValueRISCV64_OpLess8(v)
334 case OpLess8U:
335 return rewriteValueRISCV64_OpLess8U(v)
336 case OpLoad:
337 return rewriteValueRISCV64_OpLoad(v)
338 case OpLocalAddr:
339 return rewriteValueRISCV64_OpLocalAddr(v)
340 case OpLsh16x16:
341 return rewriteValueRISCV64_OpLsh16x16(v)
342 case OpLsh16x32:
343 return rewriteValueRISCV64_OpLsh16x32(v)
344 case OpLsh16x64:
345 return rewriteValueRISCV64_OpLsh16x64(v)
346 case OpLsh16x8:
347 return rewriteValueRISCV64_OpLsh16x8(v)
348 case OpLsh32x16:
349 return rewriteValueRISCV64_OpLsh32x16(v)
350 case OpLsh32x32:
351 return rewriteValueRISCV64_OpLsh32x32(v)
352 case OpLsh32x64:
353 return rewriteValueRISCV64_OpLsh32x64(v)
354 case OpLsh32x8:
355 return rewriteValueRISCV64_OpLsh32x8(v)
356 case OpLsh64x16:
357 return rewriteValueRISCV64_OpLsh64x16(v)
358 case OpLsh64x32:
359 return rewriteValueRISCV64_OpLsh64x32(v)
360 case OpLsh64x64:
361 return rewriteValueRISCV64_OpLsh64x64(v)
362 case OpLsh64x8:
363 return rewriteValueRISCV64_OpLsh64x8(v)
364 case OpLsh8x16:
365 return rewriteValueRISCV64_OpLsh8x16(v)
366 case OpLsh8x32:
367 return rewriteValueRISCV64_OpLsh8x32(v)
368 case OpLsh8x64:
369 return rewriteValueRISCV64_OpLsh8x64(v)
370 case OpLsh8x8:
371 return rewriteValueRISCV64_OpLsh8x8(v)
372 case OpMax32F:
373 v.Op = OpRISCV64LoweredFMAXS
374 return true
375 case OpMax64:
376 return rewriteValueRISCV64_OpMax64(v)
377 case OpMax64F:
378 v.Op = OpRISCV64LoweredFMAXD
379 return true
380 case OpMax64u:
381 return rewriteValueRISCV64_OpMax64u(v)
382 case OpMin32F:
383 v.Op = OpRISCV64LoweredFMINS
384 return true
385 case OpMin64:
386 return rewriteValueRISCV64_OpMin64(v)
387 case OpMin64F:
388 v.Op = OpRISCV64LoweredFMIND
389 return true
390 case OpMin64u:
391 return rewriteValueRISCV64_OpMin64u(v)
392 case OpMod16:
393 return rewriteValueRISCV64_OpMod16(v)
394 case OpMod16u:
395 return rewriteValueRISCV64_OpMod16u(v)
396 case OpMod32:
397 return rewriteValueRISCV64_OpMod32(v)
398 case OpMod32u:
399 v.Op = OpRISCV64REMUW
400 return true
401 case OpMod64:
402 return rewriteValueRISCV64_OpMod64(v)
403 case OpMod64u:
404 v.Op = OpRISCV64REMU
405 return true
406 case OpMod8:
407 return rewriteValueRISCV64_OpMod8(v)
408 case OpMod8u:
409 return rewriteValueRISCV64_OpMod8u(v)
410 case OpMove:
411 return rewriteValueRISCV64_OpMove(v)
412 case OpMul16:
413 v.Op = OpRISCV64MULW
414 return true
415 case OpMul32:
416 v.Op = OpRISCV64MULW
417 return true
418 case OpMul32F:
419 v.Op = OpRISCV64FMULS
420 return true
421 case OpMul64:
422 v.Op = OpRISCV64MUL
423 return true
424 case OpMul64F:
425 v.Op = OpRISCV64FMULD
426 return true
427 case OpMul64uhilo:
428 v.Op = OpRISCV64LoweredMuluhilo
429 return true
430 case OpMul64uover:
431 v.Op = OpRISCV64LoweredMuluover
432 return true
433 case OpMul8:
434 v.Op = OpRISCV64MULW
435 return true
436 case OpNeg16:
437 v.Op = OpRISCV64NEG
438 return true
439 case OpNeg32:
440 v.Op = OpRISCV64NEG
441 return true
442 case OpNeg32F:
443 v.Op = OpRISCV64FNEGS
444 return true
445 case OpNeg64:
446 v.Op = OpRISCV64NEG
447 return true
448 case OpNeg64F:
449 v.Op = OpRISCV64FNEGD
450 return true
451 case OpNeg8:
452 v.Op = OpRISCV64NEG
453 return true
454 case OpNeq16:
455 return rewriteValueRISCV64_OpNeq16(v)
456 case OpNeq32:
457 return rewriteValueRISCV64_OpNeq32(v)
458 case OpNeq32F:
459 v.Op = OpRISCV64FNES
460 return true
461 case OpNeq64:
462 return rewriteValueRISCV64_OpNeq64(v)
463 case OpNeq64F:
464 v.Op = OpRISCV64FNED
465 return true
466 case OpNeq8:
467 return rewriteValueRISCV64_OpNeq8(v)
468 case OpNeqB:
469 return rewriteValueRISCV64_OpNeqB(v)
470 case OpNeqPtr:
471 return rewriteValueRISCV64_OpNeqPtr(v)
472 case OpNilCheck:
473 v.Op = OpRISCV64LoweredNilCheck
474 return true
475 case OpNot:
476 v.Op = OpRISCV64SEQZ
477 return true
478 case OpOffPtr:
479 return rewriteValueRISCV64_OpOffPtr(v)
480 case OpOr16:
481 v.Op = OpRISCV64OR
482 return true
483 case OpOr32:
484 v.Op = OpRISCV64OR
485 return true
486 case OpOr64:
487 v.Op = OpRISCV64OR
488 return true
489 case OpOr8:
490 v.Op = OpRISCV64OR
491 return true
492 case OpOrB:
493 v.Op = OpRISCV64OR
494 return true
495 case OpPanicBounds:
496 v.Op = OpRISCV64LoweredPanicBoundsRR
497 return true
498 case OpPopCount16:
499 return rewriteValueRISCV64_OpPopCount16(v)
500 case OpPopCount32:
501 v.Op = OpRISCV64CPOPW
502 return true
503 case OpPopCount64:
504 v.Op = OpRISCV64CPOP
505 return true
506 case OpPopCount8:
507 return rewriteValueRISCV64_OpPopCount8(v)
508 case OpPubBarrier:
509 v.Op = OpRISCV64LoweredPubBarrier
510 return true
511 case OpRISCV64ADD:
512 return rewriteValueRISCV64_OpRISCV64ADD(v)
513 case OpRISCV64ADDI:
514 return rewriteValueRISCV64_OpRISCV64ADDI(v)
515 case OpRISCV64AND:
516 return rewriteValueRISCV64_OpRISCV64AND(v)
517 case OpRISCV64ANDI:
518 return rewriteValueRISCV64_OpRISCV64ANDI(v)
519 case OpRISCV64CZEROEQZ:
520 return rewriteValueRISCV64_OpRISCV64CZEROEQZ(v)
521 case OpRISCV64CZERONEZ:
522 return rewriteValueRISCV64_OpRISCV64CZERONEZ(v)
523 case OpRISCV64FADDD:
524 return rewriteValueRISCV64_OpRISCV64FADDD(v)
525 case OpRISCV64FADDS:
526 return rewriteValueRISCV64_OpRISCV64FADDS(v)
527 case OpRISCV64FCVTSD:
528 return rewriteValueRISCV64_OpRISCV64FCVTSD(v)
529 case OpRISCV64FEQD:
530 return rewriteValueRISCV64_OpRISCV64FEQD(v)
531 case OpRISCV64FLED:
532 return rewriteValueRISCV64_OpRISCV64FLED(v)
533 case OpRISCV64FLTD:
534 return rewriteValueRISCV64_OpRISCV64FLTD(v)
535 case OpRISCV64FMADDD:
536 return rewriteValueRISCV64_OpRISCV64FMADDD(v)
537 case OpRISCV64FMADDS:
538 return rewriteValueRISCV64_OpRISCV64FMADDS(v)
539 case OpRISCV64FMOVDload:
540 return rewriteValueRISCV64_OpRISCV64FMOVDload(v)
541 case OpRISCV64FMOVDstore:
542 return rewriteValueRISCV64_OpRISCV64FMOVDstore(v)
543 case OpRISCV64FMOVWload:
544 return rewriteValueRISCV64_OpRISCV64FMOVWload(v)
545 case OpRISCV64FMOVWstore:
546 return rewriteValueRISCV64_OpRISCV64FMOVWstore(v)
547 case OpRISCV64FMSUBD:
548 return rewriteValueRISCV64_OpRISCV64FMSUBD(v)
549 case OpRISCV64FMSUBS:
550 return rewriteValueRISCV64_OpRISCV64FMSUBS(v)
551 case OpRISCV64FNED:
552 return rewriteValueRISCV64_OpRISCV64FNED(v)
553 case OpRISCV64FNMADDD:
554 return rewriteValueRISCV64_OpRISCV64FNMADDD(v)
555 case OpRISCV64FNMADDS:
556 return rewriteValueRISCV64_OpRISCV64FNMADDS(v)
557 case OpRISCV64FNMSUBD:
558 return rewriteValueRISCV64_OpRISCV64FNMSUBD(v)
559 case OpRISCV64FNMSUBS:
560 return rewriteValueRISCV64_OpRISCV64FNMSUBS(v)
561 case OpRISCV64FSUBD:
562 return rewriteValueRISCV64_OpRISCV64FSUBD(v)
563 case OpRISCV64FSUBS:
564 return rewriteValueRISCV64_OpRISCV64FSUBS(v)
565 case OpRISCV64LoweredPanicBoundsCR:
566 return rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsCR(v)
567 case OpRISCV64LoweredPanicBoundsRC:
568 return rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRC(v)
569 case OpRISCV64LoweredPanicBoundsRR:
570 return rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRR(v)
571 case OpRISCV64MOVBUload:
572 return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
573 case OpRISCV64MOVBUreg:
574 return rewriteValueRISCV64_OpRISCV64MOVBUreg(v)
575 case OpRISCV64MOVBload:
576 return rewriteValueRISCV64_OpRISCV64MOVBload(v)
577 case OpRISCV64MOVBreg:
578 return rewriteValueRISCV64_OpRISCV64MOVBreg(v)
579 case OpRISCV64MOVBstore:
580 return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
581 case OpRISCV64MOVBstorezero:
582 return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
583 case OpRISCV64MOVDload:
584 return rewriteValueRISCV64_OpRISCV64MOVDload(v)
585 case OpRISCV64MOVDnop:
586 return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
587 case OpRISCV64MOVDreg:
588 return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
589 case OpRISCV64MOVDstore:
590 return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
591 case OpRISCV64MOVDstorezero:
592 return rewriteValueRISCV64_OpRISCV64MOVDstorezero(v)
593 case OpRISCV64MOVHUload:
594 return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
595 case OpRISCV64MOVHUreg:
596 return rewriteValueRISCV64_OpRISCV64MOVHUreg(v)
597 case OpRISCV64MOVHload:
598 return rewriteValueRISCV64_OpRISCV64MOVHload(v)
599 case OpRISCV64MOVHreg:
600 return rewriteValueRISCV64_OpRISCV64MOVHreg(v)
601 case OpRISCV64MOVHstore:
602 return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
603 case OpRISCV64MOVHstorezero:
604 return rewriteValueRISCV64_OpRISCV64MOVHstorezero(v)
605 case OpRISCV64MOVWUload:
606 return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
607 case OpRISCV64MOVWUreg:
608 return rewriteValueRISCV64_OpRISCV64MOVWUreg(v)
609 case OpRISCV64MOVWload:
610 return rewriteValueRISCV64_OpRISCV64MOVWload(v)
611 case OpRISCV64MOVWreg:
612 return rewriteValueRISCV64_OpRISCV64MOVWreg(v)
613 case OpRISCV64MOVWstore:
614 return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
615 case OpRISCV64MOVWstorezero:
616 return rewriteValueRISCV64_OpRISCV64MOVWstorezero(v)
617 case OpRISCV64NEG:
618 return rewriteValueRISCV64_OpRISCV64NEG(v)
619 case OpRISCV64NEGW:
620 return rewriteValueRISCV64_OpRISCV64NEGW(v)
621 case OpRISCV64OR:
622 return rewriteValueRISCV64_OpRISCV64OR(v)
623 case OpRISCV64ORI:
624 return rewriteValueRISCV64_OpRISCV64ORI(v)
625 case OpRISCV64ORN:
626 return rewriteValueRISCV64_OpRISCV64ORN(v)
627 case OpRISCV64ROL:
628 return rewriteValueRISCV64_OpRISCV64ROL(v)
629 case OpRISCV64ROLW:
630 return rewriteValueRISCV64_OpRISCV64ROLW(v)
631 case OpRISCV64ROR:
632 return rewriteValueRISCV64_OpRISCV64ROR(v)
633 case OpRISCV64RORW:
634 return rewriteValueRISCV64_OpRISCV64RORW(v)
635 case OpRISCV64SEQZ:
636 return rewriteValueRISCV64_OpRISCV64SEQZ(v)
637 case OpRISCV64SLL:
638 return rewriteValueRISCV64_OpRISCV64SLL(v)
639 case OpRISCV64SLLI:
640 return rewriteValueRISCV64_OpRISCV64SLLI(v)
641 case OpRISCV64SLLW:
642 return rewriteValueRISCV64_OpRISCV64SLLW(v)
643 case OpRISCV64SLT:
644 return rewriteValueRISCV64_OpRISCV64SLT(v)
645 case OpRISCV64SLTI:
646 return rewriteValueRISCV64_OpRISCV64SLTI(v)
647 case OpRISCV64SLTIU:
648 return rewriteValueRISCV64_OpRISCV64SLTIU(v)
649 case OpRISCV64SLTU:
650 return rewriteValueRISCV64_OpRISCV64SLTU(v)
651 case OpRISCV64SNEZ:
652 return rewriteValueRISCV64_OpRISCV64SNEZ(v)
653 case OpRISCV64SRA:
654 return rewriteValueRISCV64_OpRISCV64SRA(v)
655 case OpRISCV64SRAI:
656 return rewriteValueRISCV64_OpRISCV64SRAI(v)
657 case OpRISCV64SRAW:
658 return rewriteValueRISCV64_OpRISCV64SRAW(v)
659 case OpRISCV64SRL:
660 return rewriteValueRISCV64_OpRISCV64SRL(v)
661 case OpRISCV64SRLI:
662 return rewriteValueRISCV64_OpRISCV64SRLI(v)
663 case OpRISCV64SRLW:
664 return rewriteValueRISCV64_OpRISCV64SRLW(v)
665 case OpRISCV64SUB:
666 return rewriteValueRISCV64_OpRISCV64SUB(v)
667 case OpRISCV64SUBW:
668 return rewriteValueRISCV64_OpRISCV64SUBW(v)
669 case OpRISCV64XOR:
670 return rewriteValueRISCV64_OpRISCV64XOR(v)
671 case OpRotateLeft16:
672 return rewriteValueRISCV64_OpRotateLeft16(v)
673 case OpRotateLeft32:
674 v.Op = OpRISCV64ROLW
675 return true
676 case OpRotateLeft64:
677 v.Op = OpRISCV64ROL
678 return true
679 case OpRotateLeft8:
680 return rewriteValueRISCV64_OpRotateLeft8(v)
681 case OpRound32F:
682 v.Op = OpRISCV64LoweredRound32F
683 return true
684 case OpRound64F:
685 v.Op = OpRISCV64LoweredRound64F
686 return true
687 case OpRsh16Ux16:
688 return rewriteValueRISCV64_OpRsh16Ux16(v)
689 case OpRsh16Ux32:
690 return rewriteValueRISCV64_OpRsh16Ux32(v)
691 case OpRsh16Ux64:
692 return rewriteValueRISCV64_OpRsh16Ux64(v)
693 case OpRsh16Ux8:
694 return rewriteValueRISCV64_OpRsh16Ux8(v)
695 case OpRsh16x16:
696 return rewriteValueRISCV64_OpRsh16x16(v)
697 case OpRsh16x32:
698 return rewriteValueRISCV64_OpRsh16x32(v)
699 case OpRsh16x64:
700 return rewriteValueRISCV64_OpRsh16x64(v)
701 case OpRsh16x8:
702 return rewriteValueRISCV64_OpRsh16x8(v)
703 case OpRsh32Ux16:
704 return rewriteValueRISCV64_OpRsh32Ux16(v)
705 case OpRsh32Ux32:
706 return rewriteValueRISCV64_OpRsh32Ux32(v)
707 case OpRsh32Ux64:
708 return rewriteValueRISCV64_OpRsh32Ux64(v)
709 case OpRsh32Ux8:
710 return rewriteValueRISCV64_OpRsh32Ux8(v)
711 case OpRsh32x16:
712 return rewriteValueRISCV64_OpRsh32x16(v)
713 case OpRsh32x32:
714 return rewriteValueRISCV64_OpRsh32x32(v)
715 case OpRsh32x64:
716 return rewriteValueRISCV64_OpRsh32x64(v)
717 case OpRsh32x8:
718 return rewriteValueRISCV64_OpRsh32x8(v)
719 case OpRsh64Ux16:
720 return rewriteValueRISCV64_OpRsh64Ux16(v)
721 case OpRsh64Ux32:
722 return rewriteValueRISCV64_OpRsh64Ux32(v)
723 case OpRsh64Ux64:
724 return rewriteValueRISCV64_OpRsh64Ux64(v)
725 case OpRsh64Ux8:
726 return rewriteValueRISCV64_OpRsh64Ux8(v)
727 case OpRsh64x16:
728 return rewriteValueRISCV64_OpRsh64x16(v)
729 case OpRsh64x32:
730 return rewriteValueRISCV64_OpRsh64x32(v)
731 case OpRsh64x64:
732 return rewriteValueRISCV64_OpRsh64x64(v)
733 case OpRsh64x8:
734 return rewriteValueRISCV64_OpRsh64x8(v)
735 case OpRsh8Ux16:
736 return rewriteValueRISCV64_OpRsh8Ux16(v)
737 case OpRsh8Ux32:
738 return rewriteValueRISCV64_OpRsh8Ux32(v)
739 case OpRsh8Ux64:
740 return rewriteValueRISCV64_OpRsh8Ux64(v)
741 case OpRsh8Ux8:
742 return rewriteValueRISCV64_OpRsh8Ux8(v)
743 case OpRsh8x16:
744 return rewriteValueRISCV64_OpRsh8x16(v)
745 case OpRsh8x32:
746 return rewriteValueRISCV64_OpRsh8x32(v)
747 case OpRsh8x64:
748 return rewriteValueRISCV64_OpRsh8x64(v)
749 case OpRsh8x8:
750 return rewriteValueRISCV64_OpRsh8x8(v)
751 case OpSelect0:
752 return rewriteValueRISCV64_OpSelect0(v)
753 case OpSelect1:
754 return rewriteValueRISCV64_OpSelect1(v)
755 case OpSignExt16to32:
756 v.Op = OpRISCV64MOVHreg
757 return true
758 case OpSignExt16to64:
759 v.Op = OpRISCV64MOVHreg
760 return true
761 case OpSignExt32to64:
762 v.Op = OpRISCV64MOVWreg
763 return true
764 case OpSignExt8to16:
765 v.Op = OpRISCV64MOVBreg
766 return true
767 case OpSignExt8to32:
768 v.Op = OpRISCV64MOVBreg
769 return true
770 case OpSignExt8to64:
771 v.Op = OpRISCV64MOVBreg
772 return true
773 case OpSlicemask:
774 return rewriteValueRISCV64_OpSlicemask(v)
775 case OpSqrt:
776 v.Op = OpRISCV64FSQRTD
777 return true
778 case OpSqrt32:
779 v.Op = OpRISCV64FSQRTS
780 return true
781 case OpStaticCall:
782 v.Op = OpRISCV64CALLstatic
783 return true
784 case OpStore:
785 return rewriteValueRISCV64_OpStore(v)
786 case OpSub16:
787 v.Op = OpRISCV64SUB
788 return true
789 case OpSub32:
790 v.Op = OpRISCV64SUB
791 return true
792 case OpSub32F:
793 v.Op = OpRISCV64FSUBS
794 return true
795 case OpSub64:
796 v.Op = OpRISCV64SUB
797 return true
798 case OpSub64F:
799 v.Op = OpRISCV64FSUBD
800 return true
801 case OpSub8:
802 v.Op = OpRISCV64SUB
803 return true
804 case OpSubPtr:
805 v.Op = OpRISCV64SUB
806 return true
807 case OpTailCall:
808 v.Op = OpRISCV64CALLtail
809 return true
810 case OpTailCallInter:
811 v.Op = OpRISCV64CALLtailinter
812 return true
813 case OpTrunc16to8:
814 v.Op = OpCopy
815 return true
816 case OpTrunc32to16:
817 v.Op = OpCopy
818 return true
819 case OpTrunc32to8:
820 v.Op = OpCopy
821 return true
822 case OpTrunc64to16:
823 v.Op = OpCopy
824 return true
825 case OpTrunc64to32:
826 v.Op = OpCopy
827 return true
828 case OpTrunc64to8:
829 v.Op = OpCopy
830 return true
831 case OpWB:
832 v.Op = OpRISCV64LoweredWB
833 return true
834 case OpXor16:
835 v.Op = OpRISCV64XOR
836 return true
837 case OpXor32:
838 v.Op = OpRISCV64XOR
839 return true
840 case OpXor64:
841 v.Op = OpRISCV64XOR
842 return true
843 case OpXor8:
844 v.Op = OpRISCV64XOR
845 return true
846 case OpZero:
847 return rewriteValueRISCV64_OpZero(v)
848 case OpZeroExt16to32:
849 v.Op = OpRISCV64MOVHUreg
850 return true
851 case OpZeroExt16to64:
852 v.Op = OpRISCV64MOVHUreg
853 return true
854 case OpZeroExt32to64:
855 v.Op = OpRISCV64MOVWUreg
856 return true
857 case OpZeroExt8to16:
858 v.Op = OpRISCV64MOVBUreg
859 return true
860 case OpZeroExt8to32:
861 v.Op = OpRISCV64MOVBUreg
862 return true
863 case OpZeroExt8to64:
864 v.Op = OpRISCV64MOVBUreg
865 return true
866 }
867 return false
868 }
869 func rewriteValueRISCV64_OpAddr(v *Value) bool {
870 v_0 := v.Args[0]
871
872
873 for {
874 sym := auxToSym(v.Aux)
875 base := v_0
876 v.reset(OpRISCV64MOVaddr)
877 v.AuxInt = int32ToAuxInt(0)
878 v.Aux = symToAux(sym)
879 v.AddArg(base)
880 return true
881 }
882 }
883 func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool {
884 v_2 := v.Args[2]
885 v_1 := v.Args[1]
886 v_0 := v.Args[0]
887 b := v.Block
888 typ := &b.Func.Config.Types
889
890
891 for {
892 ptr := v_0
893 val := v_1
894 mem := v_2
895 v.reset(OpRISCV64LoweredAtomicAnd32)
896 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
897 v0.AuxInt = int64ToAuxInt(^3)
898 v0.AddArg(ptr)
899 v1 := b.NewValue0(v.Pos, OpRISCV64NOT, typ.UInt32)
900 v2 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
901 v3 := b.NewValue0(v.Pos, OpRISCV64XORI, typ.UInt32)
902 v3.AuxInt = int64ToAuxInt(0xff)
903 v4 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
904 v4.AddArg(val)
905 v3.AddArg(v4)
906 v5 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
907 v5.AuxInt = int64ToAuxInt(3)
908 v6 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
909 v6.AuxInt = int64ToAuxInt(3)
910 v6.AddArg(ptr)
911 v5.AddArg(v6)
912 v2.AddArg2(v3, v5)
913 v1.AddArg(v2)
914 v.AddArg3(v0, v1, mem)
915 return true
916 }
917 }
918 func rewriteValueRISCV64_OpAtomicCompareAndSwap32(v *Value) bool {
919 v_3 := v.Args[3]
920 v_2 := v.Args[2]
921 v_1 := v.Args[1]
922 v_0 := v.Args[0]
923 b := v.Block
924 typ := &b.Func.Config.Types
925
926
927 for {
928 ptr := v_0
929 old := v_1
930 new := v_2
931 mem := v_3
932 v.reset(OpRISCV64LoweredAtomicCas32)
933 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
934 v0.AddArg(old)
935 v.AddArg4(ptr, v0, new, mem)
936 return true
937 }
938 }
939 func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool {
940 v_2 := v.Args[2]
941 v_1 := v.Args[1]
942 v_0 := v.Args[0]
943 b := v.Block
944 typ := &b.Func.Config.Types
945
946
947 for {
948 ptr := v_0
949 val := v_1
950 mem := v_2
951 v.reset(OpRISCV64LoweredAtomicOr32)
952 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
953 v0.AuxInt = int64ToAuxInt(^3)
954 v0.AddArg(ptr)
955 v1 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
956 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
957 v2.AddArg(val)
958 v3 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
959 v3.AuxInt = int64ToAuxInt(3)
960 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
961 v4.AuxInt = int64ToAuxInt(3)
962 v4.AddArg(ptr)
963 v3.AddArg(v4)
964 v1.AddArg2(v2, v3)
965 v.AddArg3(v0, v1, mem)
966 return true
967 }
968 }
969 func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
970 v_1 := v.Args[1]
971 v_0 := v.Args[0]
972 b := v.Block
973
974
975 for {
976 t := v.Type
977 x := v_0
978 y := v_1
979 v.reset(OpRISCV64ADD)
980 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, t)
981 v1 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
982 v1.AuxInt = int64ToAuxInt(1)
983 v1.AddArg(x)
984 v2 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
985 v2.AuxInt = int64ToAuxInt(1)
986 v2.AddArg(y)
987 v0.AddArg2(v1, v2)
988 v3 := b.NewValue0(v.Pos, OpRISCV64ANDI, t)
989 v3.AuxInt = int64ToAuxInt(1)
990 v4 := b.NewValue0(v.Pos, OpRISCV64AND, t)
991 v4.AddArg2(x, y)
992 v3.AddArg(v4)
993 v.AddArg2(v0, v3)
994 return true
995 }
996 }
997 func rewriteValueRISCV64_OpBitLen16(v *Value) bool {
998 v_0 := v.Args[0]
999 b := v.Block
1000 typ := &b.Func.Config.Types
1001
1002
1003 for {
1004 x := v_0
1005 v.reset(OpBitLen64)
1006 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1007 v0.AddArg(x)
1008 v.AddArg(v0)
1009 return true
1010 }
1011 }
1012 func rewriteValueRISCV64_OpBitLen32(v *Value) bool {
1013 v_0 := v.Args[0]
1014 b := v.Block
1015 typ := &b.Func.Config.Types
1016
1017
1018 for {
1019 t := v.Type
1020 x := v_0
1021 v.reset(OpRISCV64SUB)
1022 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
1023 v0.AuxInt = int64ToAuxInt(32)
1024 v1 := b.NewValue0(v.Pos, OpRISCV64CLZW, t)
1025 v1.AddArg(x)
1026 v.AddArg2(v0, v1)
1027 return true
1028 }
1029 }
1030 func rewriteValueRISCV64_OpBitLen64(v *Value) bool {
1031 v_0 := v.Args[0]
1032 b := v.Block
1033 typ := &b.Func.Config.Types
1034
1035
1036 for {
1037 t := v.Type
1038 x := v_0
1039 v.reset(OpRISCV64SUB)
1040 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
1041 v0.AuxInt = int64ToAuxInt(64)
1042 v1 := b.NewValue0(v.Pos, OpRISCV64CLZ, t)
1043 v1.AddArg(x)
1044 v.AddArg2(v0, v1)
1045 return true
1046 }
1047 }
1048 func rewriteValueRISCV64_OpBitLen8(v *Value) bool {
1049 v_0 := v.Args[0]
1050 b := v.Block
1051 typ := &b.Func.Config.Types
1052
1053
1054 for {
1055 x := v_0
1056 v.reset(OpBitLen64)
1057 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1058 v0.AddArg(x)
1059 v.AddArg(v0)
1060 return true
1061 }
1062 }
1063 func rewriteValueRISCV64_OpBswap16(v *Value) bool {
1064 v_0 := v.Args[0]
1065 b := v.Block
1066
1067
1068 for {
1069 t := v.Type
1070 x := v_0
1071 v.reset(OpRISCV64SRLI)
1072 v.AuxInt = int64ToAuxInt(48)
1073 v0 := b.NewValue0(v.Pos, OpRISCV64REV8, t)
1074 v0.AddArg(x)
1075 v.AddArg(v0)
1076 return true
1077 }
1078 }
1079 func rewriteValueRISCV64_OpBswap32(v *Value) bool {
1080 v_0 := v.Args[0]
1081 b := v.Block
1082
1083
1084 for {
1085 t := v.Type
1086 x := v_0
1087 v.reset(OpRISCV64SRLI)
1088 v.AuxInt = int64ToAuxInt(32)
1089 v0 := b.NewValue0(v.Pos, OpRISCV64REV8, t)
1090 v0.AddArg(x)
1091 v.AddArg(v0)
1092 return true
1093 }
1094 }
1095 func rewriteValueRISCV64_OpCondSelect(v *Value) bool {
1096 v_2 := v.Args[2]
1097 v_1 := v.Args[1]
1098 v_0 := v.Args[0]
1099 b := v.Block
1100 typ := &b.Func.Config.Types
1101
1102
1103 for {
1104 t := v.Type
1105 x := v_0
1106 y := v_1
1107 cond := v_2
1108 v.reset(OpRISCV64OR)
1109 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
1110 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBUreg, typ.UInt64)
1111 v1.AddArg(cond)
1112 v0.AddArg2(x, v1)
1113 v2 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
1114 v2.AddArg2(y, v1)
1115 v.AddArg2(v0, v2)
1116 return true
1117 }
1118 }
1119 func rewriteValueRISCV64_OpConst16(v *Value) bool {
1120
1121
1122 for {
1123 val := auxIntToInt16(v.AuxInt)
1124 v.reset(OpRISCV64MOVDconst)
1125 v.AuxInt = int64ToAuxInt(int64(val))
1126 return true
1127 }
1128 }
1129 func rewriteValueRISCV64_OpConst32(v *Value) bool {
1130
1131
1132 for {
1133 val := auxIntToInt32(v.AuxInt)
1134 v.reset(OpRISCV64MOVDconst)
1135 v.AuxInt = int64ToAuxInt(int64(val))
1136 return true
1137 }
1138 }
1139 func rewriteValueRISCV64_OpConst64(v *Value) bool {
1140
1141
1142 for {
1143 val := auxIntToInt64(v.AuxInt)
1144 v.reset(OpRISCV64MOVDconst)
1145 v.AuxInt = int64ToAuxInt(int64(val))
1146 return true
1147 }
1148 }
1149 func rewriteValueRISCV64_OpConst8(v *Value) bool {
1150
1151
1152 for {
1153 val := auxIntToInt8(v.AuxInt)
1154 v.reset(OpRISCV64MOVDconst)
1155 v.AuxInt = int64ToAuxInt(int64(val))
1156 return true
1157 }
1158 }
1159 func rewriteValueRISCV64_OpConstBool(v *Value) bool {
1160
1161
1162 for {
1163 val := auxIntToBool(v.AuxInt)
1164 v.reset(OpRISCV64MOVDconst)
1165 v.AuxInt = int64ToAuxInt(int64(b2i(val)))
1166 return true
1167 }
1168 }
1169 func rewriteValueRISCV64_OpConstNil(v *Value) bool {
1170
1171
1172 for {
1173 v.reset(OpRISCV64MOVDconst)
1174 v.AuxInt = int64ToAuxInt(0)
1175 return true
1176 }
1177 }
1178 func rewriteValueRISCV64_OpCtz16(v *Value) bool {
1179 v_0 := v.Args[0]
1180 b := v.Block
1181 typ := &b.Func.Config.Types
1182
1183
1184 for {
1185 x := v_0
1186 v.reset(OpRISCV64CTZW)
1187 v0 := b.NewValue0(v.Pos, OpRISCV64ORI, typ.UInt32)
1188 v0.AuxInt = int64ToAuxInt(1 << 16)
1189 v0.AddArg(x)
1190 v.AddArg(v0)
1191 return true
1192 }
1193 }
1194 func rewriteValueRISCV64_OpCtz8(v *Value) bool {
1195 v_0 := v.Args[0]
1196 b := v.Block
1197 typ := &b.Func.Config.Types
1198
1199
1200 for {
1201 x := v_0
1202 v.reset(OpRISCV64CTZW)
1203 v0 := b.NewValue0(v.Pos, OpRISCV64ORI, typ.UInt32)
1204 v0.AuxInt = int64ToAuxInt(1 << 8)
1205 v0.AddArg(x)
1206 v.AddArg(v0)
1207 return true
1208 }
1209 }
1210 func rewriteValueRISCV64_OpDiv16(v *Value) bool {
1211 v_1 := v.Args[1]
1212 v_0 := v.Args[0]
1213 b := v.Block
1214 typ := &b.Func.Config.Types
1215
1216
1217 for {
1218 if auxIntToBool(v.AuxInt) != false {
1219 break
1220 }
1221 x := v_0
1222 y := v_1
1223 v.reset(OpRISCV64DIVW)
1224 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
1225 v0.AddArg(x)
1226 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
1227 v1.AddArg(y)
1228 v.AddArg2(v0, v1)
1229 return true
1230 }
1231 return false
1232 }
1233 func rewriteValueRISCV64_OpDiv16u(v *Value) bool {
1234 v_1 := v.Args[1]
1235 v_0 := v.Args[0]
1236 b := v.Block
1237 typ := &b.Func.Config.Types
1238
1239
1240 for {
1241 x := v_0
1242 y := v_1
1243 v.reset(OpRISCV64DIVUW)
1244 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
1245 v0.AddArg(x)
1246 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
1247 v1.AddArg(y)
1248 v.AddArg2(v0, v1)
1249 return true
1250 }
1251 }
1252 func rewriteValueRISCV64_OpDiv32(v *Value) bool {
1253 v_1 := v.Args[1]
1254 v_0 := v.Args[0]
1255
1256
1257 for {
1258 if auxIntToBool(v.AuxInt) != false {
1259 break
1260 }
1261 x := v_0
1262 y := v_1
1263 v.reset(OpRISCV64DIVW)
1264 v.AddArg2(x, y)
1265 return true
1266 }
1267 return false
1268 }
1269 func rewriteValueRISCV64_OpDiv64(v *Value) bool {
1270 v_1 := v.Args[1]
1271 v_0 := v.Args[0]
1272
1273
1274 for {
1275 if auxIntToBool(v.AuxInt) != false {
1276 break
1277 }
1278 x := v_0
1279 y := v_1
1280 v.reset(OpRISCV64DIV)
1281 v.AddArg2(x, y)
1282 return true
1283 }
1284 return false
1285 }
1286 func rewriteValueRISCV64_OpDiv8(v *Value) bool {
1287 v_1 := v.Args[1]
1288 v_0 := v.Args[0]
1289 b := v.Block
1290 typ := &b.Func.Config.Types
1291
1292
1293 for {
1294 x := v_0
1295 y := v_1
1296 v.reset(OpRISCV64DIVW)
1297 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
1298 v0.AddArg(x)
1299 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
1300 v1.AddArg(y)
1301 v.AddArg2(v0, v1)
1302 return true
1303 }
1304 }
1305 func rewriteValueRISCV64_OpDiv8u(v *Value) bool {
1306 v_1 := v.Args[1]
1307 v_0 := v.Args[0]
1308 b := v.Block
1309 typ := &b.Func.Config.Types
1310
1311
1312 for {
1313 x := v_0
1314 y := v_1
1315 v.reset(OpRISCV64DIVUW)
1316 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
1317 v0.AddArg(x)
1318 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
1319 v1.AddArg(y)
1320 v.AddArg2(v0, v1)
1321 return true
1322 }
1323 }
1324 func rewriteValueRISCV64_OpEq16(v *Value) bool {
1325 v_1 := v.Args[1]
1326 v_0 := v.Args[0]
1327 b := v.Block
1328 typ := &b.Func.Config.Types
1329
1330
1331 for {
1332 x := v_0
1333 y := v_1
1334 v.reset(OpRISCV64SEQZ)
1335 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1336 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1337 v1.AddArg(x)
1338 v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1339 v2.AddArg(y)
1340 v0.AddArg2(v1, v2)
1341 v.AddArg(v0)
1342 return true
1343 }
1344 }
1345 func rewriteValueRISCV64_OpEq32(v *Value) bool {
1346 v_1 := v.Args[1]
1347 v_0 := v.Args[0]
1348 b := v.Block
1349 typ := &b.Func.Config.Types
1350
1351
1352
1353 for {
1354 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
1355 x := v_0
1356 y := v_1
1357 if !(x.Type.IsSigned()) {
1358 continue
1359 }
1360 v.reset(OpRISCV64SEQZ)
1361 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1362 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1363 v1.AddArg(x)
1364 v2 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1365 v2.AddArg(y)
1366 v0.AddArg2(v1, v2)
1367 v.AddArg(v0)
1368 return true
1369 }
1370 break
1371 }
1372
1373
1374
1375 for {
1376 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
1377 x := v_0
1378 y := v_1
1379 if !(!x.Type.IsSigned()) {
1380 continue
1381 }
1382 v.reset(OpRISCV64SEQZ)
1383 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1384 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1385 v1.AddArg(x)
1386 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1387 v2.AddArg(y)
1388 v0.AddArg2(v1, v2)
1389 v.AddArg(v0)
1390 return true
1391 }
1392 break
1393 }
1394 return false
1395 }
1396 func rewriteValueRISCV64_OpEq64(v *Value) bool {
1397 v_1 := v.Args[1]
1398 v_0 := v.Args[0]
1399 b := v.Block
1400
1401
1402 for {
1403 x := v_0
1404 y := v_1
1405 v.reset(OpRISCV64SEQZ)
1406 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1407 v0.AddArg2(x, y)
1408 v.AddArg(v0)
1409 return true
1410 }
1411 }
1412 func rewriteValueRISCV64_OpEq8(v *Value) bool {
1413 v_1 := v.Args[1]
1414 v_0 := v.Args[0]
1415 b := v.Block
1416 typ := &b.Func.Config.Types
1417
1418
1419 for {
1420 x := v_0
1421 y := v_1
1422 v.reset(OpRISCV64SEQZ)
1423 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1424 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1425 v1.AddArg(x)
1426 v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1427 v2.AddArg(y)
1428 v0.AddArg2(v1, v2)
1429 v.AddArg(v0)
1430 return true
1431 }
1432 }
1433 func rewriteValueRISCV64_OpEqB(v *Value) bool {
1434 v_1 := v.Args[1]
1435 v_0 := v.Args[0]
1436 b := v.Block
1437 typ := &b.Func.Config.Types
1438
1439
1440 for {
1441 x := v_0
1442 y := v_1
1443 v.reset(OpRISCV64SEQZ)
1444 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
1445 v0.AddArg2(x, y)
1446 v.AddArg(v0)
1447 return true
1448 }
1449 }
1450 func rewriteValueRISCV64_OpEqPtr(v *Value) bool {
1451 v_1 := v.Args[1]
1452 v_0 := v.Args[0]
1453 b := v.Block
1454 typ := &b.Func.Config.Types
1455
1456
1457 for {
1458 x := v_0
1459 y := v_1
1460 v.reset(OpRISCV64SEQZ)
1461 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Uintptr)
1462 v0.AddArg2(x, y)
1463 v.AddArg(v0)
1464 return true
1465 }
1466 }
1467 func rewriteValueRISCV64_OpHmul32(v *Value) bool {
1468 v_1 := v.Args[1]
1469 v_0 := v.Args[0]
1470 b := v.Block
1471 typ := &b.Func.Config.Types
1472
1473
1474 for {
1475 x := v_0
1476 y := v_1
1477 v.reset(OpRISCV64SRAI)
1478 v.AuxInt = int64ToAuxInt(32)
1479 v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
1480 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1481 v1.AddArg(x)
1482 v2 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1483 v2.AddArg(y)
1484 v0.AddArg2(v1, v2)
1485 v.AddArg(v0)
1486 return true
1487 }
1488 }
1489 func rewriteValueRISCV64_OpHmul32u(v *Value) bool {
1490 v_1 := v.Args[1]
1491 v_0 := v.Args[0]
1492 b := v.Block
1493 typ := &b.Func.Config.Types
1494
1495
1496 for {
1497 x := v_0
1498 y := v_1
1499 v.reset(OpRISCV64SRLI)
1500 v.AuxInt = int64ToAuxInt(32)
1501 v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
1502 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1503 v1.AddArg(x)
1504 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1505 v2.AddArg(y)
1506 v0.AddArg2(v1, v2)
1507 v.AddArg(v0)
1508 return true
1509 }
1510 }
1511 func rewriteValueRISCV64_OpLeq16(v *Value) bool {
1512 v_1 := v.Args[1]
1513 v_0 := v.Args[0]
1514 b := v.Block
1515 typ := &b.Func.Config.Types
1516
1517
1518 for {
1519 x := v_0
1520 y := v_1
1521 v.reset(OpNot)
1522 v0 := b.NewValue0(v.Pos, OpLess16, typ.Bool)
1523 v0.AddArg2(y, x)
1524 v.AddArg(v0)
1525 return true
1526 }
1527 }
1528 func rewriteValueRISCV64_OpLeq16U(v *Value) bool {
1529 v_1 := v.Args[1]
1530 v_0 := v.Args[0]
1531 b := v.Block
1532 typ := &b.Func.Config.Types
1533
1534
1535 for {
1536 x := v_0
1537 y := v_1
1538 v.reset(OpNot)
1539 v0 := b.NewValue0(v.Pos, OpLess16U, typ.Bool)
1540 v0.AddArg2(y, x)
1541 v.AddArg(v0)
1542 return true
1543 }
1544 }
1545 func rewriteValueRISCV64_OpLeq32(v *Value) bool {
1546 v_1 := v.Args[1]
1547 v_0 := v.Args[0]
1548 b := v.Block
1549 typ := &b.Func.Config.Types
1550
1551
1552 for {
1553 x := v_0
1554 y := v_1
1555 v.reset(OpNot)
1556 v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
1557 v0.AddArg2(y, x)
1558 v.AddArg(v0)
1559 return true
1560 }
1561 }
1562 func rewriteValueRISCV64_OpLeq32U(v *Value) bool {
1563 v_1 := v.Args[1]
1564 v_0 := v.Args[0]
1565 b := v.Block
1566 typ := &b.Func.Config.Types
1567
1568
1569 for {
1570 x := v_0
1571 y := v_1
1572 v.reset(OpNot)
1573 v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
1574 v0.AddArg2(y, x)
1575 v.AddArg(v0)
1576 return true
1577 }
1578 }
1579 func rewriteValueRISCV64_OpLeq64(v *Value) bool {
1580 v_1 := v.Args[1]
1581 v_0 := v.Args[0]
1582 b := v.Block
1583 typ := &b.Func.Config.Types
1584
1585
1586 for {
1587 x := v_0
1588 y := v_1
1589 v.reset(OpNot)
1590 v0 := b.NewValue0(v.Pos, OpLess64, typ.Bool)
1591 v0.AddArg2(y, x)
1592 v.AddArg(v0)
1593 return true
1594 }
1595 }
1596 func rewriteValueRISCV64_OpLeq64U(v *Value) bool {
1597 v_1 := v.Args[1]
1598 v_0 := v.Args[0]
1599 b := v.Block
1600 typ := &b.Func.Config.Types
1601
1602
1603 for {
1604 x := v_0
1605 y := v_1
1606 v.reset(OpNot)
1607 v0 := b.NewValue0(v.Pos, OpLess64U, typ.Bool)
1608 v0.AddArg2(y, x)
1609 v.AddArg(v0)
1610 return true
1611 }
1612 }
1613 func rewriteValueRISCV64_OpLeq8(v *Value) bool {
1614 v_1 := v.Args[1]
1615 v_0 := v.Args[0]
1616 b := v.Block
1617 typ := &b.Func.Config.Types
1618
1619
1620 for {
1621 x := v_0
1622 y := v_1
1623 v.reset(OpNot)
1624 v0 := b.NewValue0(v.Pos, OpLess8, typ.Bool)
1625 v0.AddArg2(y, x)
1626 v.AddArg(v0)
1627 return true
1628 }
1629 }
1630 func rewriteValueRISCV64_OpLeq8U(v *Value) bool {
1631 v_1 := v.Args[1]
1632 v_0 := v.Args[0]
1633 b := v.Block
1634 typ := &b.Func.Config.Types
1635
1636
1637 for {
1638 x := v_0
1639 y := v_1
1640 v.reset(OpNot)
1641 v0 := b.NewValue0(v.Pos, OpLess8U, typ.Bool)
1642 v0.AddArg2(y, x)
1643 v.AddArg(v0)
1644 return true
1645 }
1646 }
1647 func rewriteValueRISCV64_OpLess16(v *Value) bool {
1648 v_1 := v.Args[1]
1649 v_0 := v.Args[0]
1650 b := v.Block
1651 typ := &b.Func.Config.Types
1652
1653
1654 for {
1655 x := v_0
1656 y := v_1
1657 v.reset(OpRISCV64SLT)
1658 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1659 v0.AddArg(x)
1660 v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1661 v1.AddArg(y)
1662 v.AddArg2(v0, v1)
1663 return true
1664 }
1665 }
1666 func rewriteValueRISCV64_OpLess16U(v *Value) bool {
1667 v_1 := v.Args[1]
1668 v_0 := v.Args[0]
1669 b := v.Block
1670 typ := &b.Func.Config.Types
1671
1672
1673 for {
1674 x := v_0
1675 y := v_1
1676 v.reset(OpRISCV64SLTU)
1677 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1678 v0.AddArg(x)
1679 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1680 v1.AddArg(y)
1681 v.AddArg2(v0, v1)
1682 return true
1683 }
1684 }
1685 func rewriteValueRISCV64_OpLess32(v *Value) bool {
1686 v_1 := v.Args[1]
1687 v_0 := v.Args[0]
1688 b := v.Block
1689 typ := &b.Func.Config.Types
1690
1691
1692 for {
1693 x := v_0
1694 y := v_1
1695 v.reset(OpRISCV64SLT)
1696 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1697 v0.AddArg(x)
1698 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1699 v1.AddArg(y)
1700 v.AddArg2(v0, v1)
1701 return true
1702 }
1703 }
1704 func rewriteValueRISCV64_OpLess32U(v *Value) bool {
1705 v_1 := v.Args[1]
1706 v_0 := v.Args[0]
1707 b := v.Block
1708 typ := &b.Func.Config.Types
1709
1710
1711 for {
1712 x := v_0
1713 y := v_1
1714 v.reset(OpRISCV64SLTU)
1715 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1716 v0.AddArg(x)
1717 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1718 v1.AddArg(y)
1719 v.AddArg2(v0, v1)
1720 return true
1721 }
1722 }
1723 func rewriteValueRISCV64_OpLess8(v *Value) bool {
1724 v_1 := v.Args[1]
1725 v_0 := v.Args[0]
1726 b := v.Block
1727 typ := &b.Func.Config.Types
1728
1729
1730 for {
1731 x := v_0
1732 y := v_1
1733 v.reset(OpRISCV64SLT)
1734 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1735 v0.AddArg(x)
1736 v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1737 v1.AddArg(y)
1738 v.AddArg2(v0, v1)
1739 return true
1740 }
1741 }
1742 func rewriteValueRISCV64_OpLess8U(v *Value) bool {
1743 v_1 := v.Args[1]
1744 v_0 := v.Args[0]
1745 b := v.Block
1746 typ := &b.Func.Config.Types
1747
1748
1749 for {
1750 x := v_0
1751 y := v_1
1752 v.reset(OpRISCV64SLTU)
1753 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1754 v0.AddArg(x)
1755 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1756 v1.AddArg(y)
1757 v.AddArg2(v0, v1)
1758 return true
1759 }
1760 }
1761 func rewriteValueRISCV64_OpLoad(v *Value) bool {
1762 v_1 := v.Args[1]
1763 v_0 := v.Args[0]
1764
1765
1766
1767 for {
1768 t := v.Type
1769 ptr := v_0
1770 mem := v_1
1771 if !(t.IsBoolean()) {
1772 break
1773 }
1774 v.reset(OpRISCV64MOVBUload)
1775 v.AddArg2(ptr, mem)
1776 return true
1777 }
1778
1779
1780
1781 for {
1782 t := v.Type
1783 ptr := v_0
1784 mem := v_1
1785 if !(is8BitInt(t) && t.IsSigned()) {
1786 break
1787 }
1788 v.reset(OpRISCV64MOVBload)
1789 v.AddArg2(ptr, mem)
1790 return true
1791 }
1792
1793
1794
1795 for {
1796 t := v.Type
1797 ptr := v_0
1798 mem := v_1
1799 if !(is8BitInt(t) && !t.IsSigned()) {
1800 break
1801 }
1802 v.reset(OpRISCV64MOVBUload)
1803 v.AddArg2(ptr, mem)
1804 return true
1805 }
1806
1807
1808
1809 for {
1810 t := v.Type
1811 ptr := v_0
1812 mem := v_1
1813 if !(is16BitInt(t) && t.IsSigned()) {
1814 break
1815 }
1816 v.reset(OpRISCV64MOVHload)
1817 v.AddArg2(ptr, mem)
1818 return true
1819 }
1820
1821
1822
1823 for {
1824 t := v.Type
1825 ptr := v_0
1826 mem := v_1
1827 if !(is16BitInt(t) && !t.IsSigned()) {
1828 break
1829 }
1830 v.reset(OpRISCV64MOVHUload)
1831 v.AddArg2(ptr, mem)
1832 return true
1833 }
1834
1835
1836
1837 for {
1838 t := v.Type
1839 ptr := v_0
1840 mem := v_1
1841 if !(is32BitInt(t) && t.IsSigned()) {
1842 break
1843 }
1844 v.reset(OpRISCV64MOVWload)
1845 v.AddArg2(ptr, mem)
1846 return true
1847 }
1848
1849
1850
1851 for {
1852 t := v.Type
1853 ptr := v_0
1854 mem := v_1
1855 if !(is32BitInt(t) && !t.IsSigned()) {
1856 break
1857 }
1858 v.reset(OpRISCV64MOVWUload)
1859 v.AddArg2(ptr, mem)
1860 return true
1861 }
1862
1863
1864
1865 for {
1866 t := v.Type
1867 ptr := v_0
1868 mem := v_1
1869 if !(is64BitInt(t) || isPtr(t)) {
1870 break
1871 }
1872 v.reset(OpRISCV64MOVDload)
1873 v.AddArg2(ptr, mem)
1874 return true
1875 }
1876
1877
1878
1879 for {
1880 t := v.Type
1881 ptr := v_0
1882 mem := v_1
1883 if !(is32BitFloat(t)) {
1884 break
1885 }
1886 v.reset(OpRISCV64FMOVWload)
1887 v.AddArg2(ptr, mem)
1888 return true
1889 }
1890
1891
1892
1893 for {
1894 t := v.Type
1895 ptr := v_0
1896 mem := v_1
1897 if !(is64BitFloat(t)) {
1898 break
1899 }
1900 v.reset(OpRISCV64FMOVDload)
1901 v.AddArg2(ptr, mem)
1902 return true
1903 }
1904 return false
1905 }
1906 func rewriteValueRISCV64_OpLocalAddr(v *Value) bool {
1907 v_1 := v.Args[1]
1908 v_0 := v.Args[0]
1909 b := v.Block
1910 typ := &b.Func.Config.Types
1911
1912
1913
1914 for {
1915 t := v.Type
1916 sym := auxToSym(v.Aux)
1917 base := v_0
1918 mem := v_1
1919 if !(t.Elem().HasPointers()) {
1920 break
1921 }
1922 v.reset(OpRISCV64MOVaddr)
1923 v.Aux = symToAux(sym)
1924 v0 := b.NewValue0(v.Pos, OpSPanchored, typ.Uintptr)
1925 v0.AddArg2(base, mem)
1926 v.AddArg(v0)
1927 return true
1928 }
1929
1930
1931
1932 for {
1933 t := v.Type
1934 sym := auxToSym(v.Aux)
1935 base := v_0
1936 if !(!t.Elem().HasPointers()) {
1937 break
1938 }
1939 v.reset(OpRISCV64MOVaddr)
1940 v.Aux = symToAux(sym)
1941 v.AddArg(base)
1942 return true
1943 }
1944 return false
1945 }
1946 func rewriteValueRISCV64_OpLsh16x16(v *Value) bool {
1947 v_1 := v.Args[1]
1948 v_0 := v.Args[0]
1949 b := v.Block
1950 typ := &b.Func.Config.Types
1951
1952
1953
1954 for {
1955 t := v.Type
1956 x := v_0
1957 y := v_1
1958 if !(!shiftIsBounded(v)) {
1959 break
1960 }
1961 v.reset(OpRISCV64AND)
1962 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1963 v0.AddArg2(x, y)
1964 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1965 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1966 v2.AuxInt = int64ToAuxInt(64)
1967 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1968 v3.AddArg(y)
1969 v2.AddArg(v3)
1970 v1.AddArg(v2)
1971 v.AddArg2(v0, v1)
1972 return true
1973 }
1974
1975
1976
1977 for {
1978 x := v_0
1979 y := v_1
1980 if !(shiftIsBounded(v)) {
1981 break
1982 }
1983 v.reset(OpRISCV64SLL)
1984 v.AddArg2(x, y)
1985 return true
1986 }
1987 return false
1988 }
1989 func rewriteValueRISCV64_OpLsh16x32(v *Value) bool {
1990 v_1 := v.Args[1]
1991 v_0 := v.Args[0]
1992 b := v.Block
1993 typ := &b.Func.Config.Types
1994
1995
1996
1997 for {
1998 t := v.Type
1999 x := v_0
2000 y := v_1
2001 if !(!shiftIsBounded(v)) {
2002 break
2003 }
2004 v.reset(OpRISCV64AND)
2005 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2006 v0.AddArg2(x, y)
2007 v1 := b.NewValue0(v.Pos, OpNeg16, t)
2008 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2009 v2.AuxInt = int64ToAuxInt(64)
2010 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2011 v3.AddArg(y)
2012 v2.AddArg(v3)
2013 v1.AddArg(v2)
2014 v.AddArg2(v0, v1)
2015 return true
2016 }
2017
2018
2019
2020 for {
2021 x := v_0
2022 y := v_1
2023 if !(shiftIsBounded(v)) {
2024 break
2025 }
2026 v.reset(OpRISCV64SLL)
2027 v.AddArg2(x, y)
2028 return true
2029 }
2030 return false
2031 }
2032 func rewriteValueRISCV64_OpLsh16x64(v *Value) bool {
2033 v_1 := v.Args[1]
2034 v_0 := v.Args[0]
2035 b := v.Block
2036
2037
2038
2039 for {
2040 t := v.Type
2041 x := v_0
2042 y := v_1
2043 if !(!shiftIsBounded(v)) {
2044 break
2045 }
2046 v.reset(OpRISCV64AND)
2047 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2048 v0.AddArg2(x, y)
2049 v1 := b.NewValue0(v.Pos, OpNeg16, t)
2050 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2051 v2.AuxInt = int64ToAuxInt(64)
2052 v2.AddArg(y)
2053 v1.AddArg(v2)
2054 v.AddArg2(v0, v1)
2055 return true
2056 }
2057
2058
2059
2060 for {
2061 x := v_0
2062 y := v_1
2063 if !(shiftIsBounded(v)) {
2064 break
2065 }
2066 v.reset(OpRISCV64SLL)
2067 v.AddArg2(x, y)
2068 return true
2069 }
2070 return false
2071 }
2072 func rewriteValueRISCV64_OpLsh16x8(v *Value) bool {
2073 v_1 := v.Args[1]
2074 v_0 := v.Args[0]
2075 b := v.Block
2076 typ := &b.Func.Config.Types
2077
2078
2079
2080 for {
2081 t := v.Type
2082 x := v_0
2083 y := v_1
2084 if !(!shiftIsBounded(v)) {
2085 break
2086 }
2087 v.reset(OpRISCV64AND)
2088 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2089 v0.AddArg2(x, y)
2090 v1 := b.NewValue0(v.Pos, OpNeg16, t)
2091 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2092 v2.AuxInt = int64ToAuxInt(64)
2093 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2094 v3.AddArg(y)
2095 v2.AddArg(v3)
2096 v1.AddArg(v2)
2097 v.AddArg2(v0, v1)
2098 return true
2099 }
2100
2101
2102
2103 for {
2104 x := v_0
2105 y := v_1
2106 if !(shiftIsBounded(v)) {
2107 break
2108 }
2109 v.reset(OpRISCV64SLL)
2110 v.AddArg2(x, y)
2111 return true
2112 }
2113 return false
2114 }
2115 func rewriteValueRISCV64_OpLsh32x16(v *Value) bool {
2116 v_1 := v.Args[1]
2117 v_0 := v.Args[0]
2118 b := v.Block
2119 typ := &b.Func.Config.Types
2120
2121
2122
2123 for {
2124 t := v.Type
2125 x := v_0
2126 y := v_1
2127 if !(!shiftIsBounded(v)) {
2128 break
2129 }
2130 v.reset(OpRISCV64AND)
2131 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2132 v0.AddArg2(x, y)
2133 v1 := b.NewValue0(v.Pos, OpNeg32, t)
2134 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2135 v2.AuxInt = int64ToAuxInt(64)
2136 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2137 v3.AddArg(y)
2138 v2.AddArg(v3)
2139 v1.AddArg(v2)
2140 v.AddArg2(v0, v1)
2141 return true
2142 }
2143
2144
2145
2146 for {
2147 x := v_0
2148 y := v_1
2149 if !(shiftIsBounded(v)) {
2150 break
2151 }
2152 v.reset(OpRISCV64SLL)
2153 v.AddArg2(x, y)
2154 return true
2155 }
2156 return false
2157 }
2158 func rewriteValueRISCV64_OpLsh32x32(v *Value) bool {
2159 v_1 := v.Args[1]
2160 v_0 := v.Args[0]
2161 b := v.Block
2162 typ := &b.Func.Config.Types
2163
2164
2165
2166 for {
2167 t := v.Type
2168 x := v_0
2169 y := v_1
2170 if !(!shiftIsBounded(v)) {
2171 break
2172 }
2173 v.reset(OpRISCV64AND)
2174 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2175 v0.AddArg2(x, y)
2176 v1 := b.NewValue0(v.Pos, OpNeg32, t)
2177 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2178 v2.AuxInt = int64ToAuxInt(64)
2179 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2180 v3.AddArg(y)
2181 v2.AddArg(v3)
2182 v1.AddArg(v2)
2183 v.AddArg2(v0, v1)
2184 return true
2185 }
2186
2187
2188
2189 for {
2190 x := v_0
2191 y := v_1
2192 if !(shiftIsBounded(v)) {
2193 break
2194 }
2195 v.reset(OpRISCV64SLL)
2196 v.AddArg2(x, y)
2197 return true
2198 }
2199 return false
2200 }
2201 func rewriteValueRISCV64_OpLsh32x64(v *Value) bool {
2202 v_1 := v.Args[1]
2203 v_0 := v.Args[0]
2204 b := v.Block
2205
2206
2207
2208 for {
2209 t := v.Type
2210 x := v_0
2211 y := v_1
2212 if !(!shiftIsBounded(v)) {
2213 break
2214 }
2215 v.reset(OpRISCV64AND)
2216 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2217 v0.AddArg2(x, y)
2218 v1 := b.NewValue0(v.Pos, OpNeg32, t)
2219 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2220 v2.AuxInt = int64ToAuxInt(64)
2221 v2.AddArg(y)
2222 v1.AddArg(v2)
2223 v.AddArg2(v0, v1)
2224 return true
2225 }
2226
2227
2228
2229 for {
2230 x := v_0
2231 y := v_1
2232 if !(shiftIsBounded(v)) {
2233 break
2234 }
2235 v.reset(OpRISCV64SLL)
2236 v.AddArg2(x, y)
2237 return true
2238 }
2239 return false
2240 }
2241 func rewriteValueRISCV64_OpLsh32x8(v *Value) bool {
2242 v_1 := v.Args[1]
2243 v_0 := v.Args[0]
2244 b := v.Block
2245 typ := &b.Func.Config.Types
2246
2247
2248
2249 for {
2250 t := v.Type
2251 x := v_0
2252 y := v_1
2253 if !(!shiftIsBounded(v)) {
2254 break
2255 }
2256 v.reset(OpRISCV64AND)
2257 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2258 v0.AddArg2(x, y)
2259 v1 := b.NewValue0(v.Pos, OpNeg32, t)
2260 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2261 v2.AuxInt = int64ToAuxInt(64)
2262 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2263 v3.AddArg(y)
2264 v2.AddArg(v3)
2265 v1.AddArg(v2)
2266 v.AddArg2(v0, v1)
2267 return true
2268 }
2269
2270
2271
2272 for {
2273 x := v_0
2274 y := v_1
2275 if !(shiftIsBounded(v)) {
2276 break
2277 }
2278 v.reset(OpRISCV64SLL)
2279 v.AddArg2(x, y)
2280 return true
2281 }
2282 return false
2283 }
2284 func rewriteValueRISCV64_OpLsh64x16(v *Value) bool {
2285 v_1 := v.Args[1]
2286 v_0 := v.Args[0]
2287 b := v.Block
2288 typ := &b.Func.Config.Types
2289
2290
2291
2292 for {
2293 t := v.Type
2294 x := v_0
2295 y := v_1
2296 if !(!shiftIsBounded(v)) {
2297 break
2298 }
2299 v.reset(OpRISCV64AND)
2300 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2301 v0.AddArg2(x, y)
2302 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2303 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2304 v2.AuxInt = int64ToAuxInt(64)
2305 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2306 v3.AddArg(y)
2307 v2.AddArg(v3)
2308 v1.AddArg(v2)
2309 v.AddArg2(v0, v1)
2310 return true
2311 }
2312
2313
2314
2315 for {
2316 x := v_0
2317 y := v_1
2318 if !(shiftIsBounded(v)) {
2319 break
2320 }
2321 v.reset(OpRISCV64SLL)
2322 v.AddArg2(x, y)
2323 return true
2324 }
2325 return false
2326 }
2327 func rewriteValueRISCV64_OpLsh64x32(v *Value) bool {
2328 v_1 := v.Args[1]
2329 v_0 := v.Args[0]
2330 b := v.Block
2331 typ := &b.Func.Config.Types
2332
2333
2334
2335 for {
2336 t := v.Type
2337 x := v_0
2338 y := v_1
2339 if !(!shiftIsBounded(v)) {
2340 break
2341 }
2342 v.reset(OpRISCV64AND)
2343 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2344 v0.AddArg2(x, y)
2345 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2346 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2347 v2.AuxInt = int64ToAuxInt(64)
2348 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2349 v3.AddArg(y)
2350 v2.AddArg(v3)
2351 v1.AddArg(v2)
2352 v.AddArg2(v0, v1)
2353 return true
2354 }
2355
2356
2357
2358 for {
2359 x := v_0
2360 y := v_1
2361 if !(shiftIsBounded(v)) {
2362 break
2363 }
2364 v.reset(OpRISCV64SLL)
2365 v.AddArg2(x, y)
2366 return true
2367 }
2368 return false
2369 }
2370 func rewriteValueRISCV64_OpLsh64x64(v *Value) bool {
2371 v_1 := v.Args[1]
2372 v_0 := v.Args[0]
2373 b := v.Block
2374
2375
2376
2377 for {
2378 t := v.Type
2379 x := v_0
2380 y := v_1
2381 if !(!shiftIsBounded(v)) {
2382 break
2383 }
2384 v.reset(OpRISCV64AND)
2385 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2386 v0.AddArg2(x, y)
2387 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2388 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2389 v2.AuxInt = int64ToAuxInt(64)
2390 v2.AddArg(y)
2391 v1.AddArg(v2)
2392 v.AddArg2(v0, v1)
2393 return true
2394 }
2395
2396
2397
2398 for {
2399 x := v_0
2400 y := v_1
2401 if !(shiftIsBounded(v)) {
2402 break
2403 }
2404 v.reset(OpRISCV64SLL)
2405 v.AddArg2(x, y)
2406 return true
2407 }
2408 return false
2409 }
2410 func rewriteValueRISCV64_OpLsh64x8(v *Value) bool {
2411 v_1 := v.Args[1]
2412 v_0 := v.Args[0]
2413 b := v.Block
2414 typ := &b.Func.Config.Types
2415
2416
2417
2418 for {
2419 t := v.Type
2420 x := v_0
2421 y := v_1
2422 if !(!shiftIsBounded(v)) {
2423 break
2424 }
2425 v.reset(OpRISCV64AND)
2426 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2427 v0.AddArg2(x, y)
2428 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2429 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2430 v2.AuxInt = int64ToAuxInt(64)
2431 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2432 v3.AddArg(y)
2433 v2.AddArg(v3)
2434 v1.AddArg(v2)
2435 v.AddArg2(v0, v1)
2436 return true
2437 }
2438
2439
2440
2441 for {
2442 x := v_0
2443 y := v_1
2444 if !(shiftIsBounded(v)) {
2445 break
2446 }
2447 v.reset(OpRISCV64SLL)
2448 v.AddArg2(x, y)
2449 return true
2450 }
2451 return false
2452 }
2453 func rewriteValueRISCV64_OpLsh8x16(v *Value) bool {
2454 v_1 := v.Args[1]
2455 v_0 := v.Args[0]
2456 b := v.Block
2457 typ := &b.Func.Config.Types
2458
2459
2460
2461 for {
2462 t := v.Type
2463 x := v_0
2464 y := v_1
2465 if !(!shiftIsBounded(v)) {
2466 break
2467 }
2468 v.reset(OpRISCV64AND)
2469 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2470 v0.AddArg2(x, y)
2471 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2472 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2473 v2.AuxInt = int64ToAuxInt(64)
2474 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2475 v3.AddArg(y)
2476 v2.AddArg(v3)
2477 v1.AddArg(v2)
2478 v.AddArg2(v0, v1)
2479 return true
2480 }
2481
2482
2483
2484 for {
2485 x := v_0
2486 y := v_1
2487 if !(shiftIsBounded(v)) {
2488 break
2489 }
2490 v.reset(OpRISCV64SLL)
2491 v.AddArg2(x, y)
2492 return true
2493 }
2494 return false
2495 }
2496 func rewriteValueRISCV64_OpLsh8x32(v *Value) bool {
2497 v_1 := v.Args[1]
2498 v_0 := v.Args[0]
2499 b := v.Block
2500 typ := &b.Func.Config.Types
2501
2502
2503
2504 for {
2505 t := v.Type
2506 x := v_0
2507 y := v_1
2508 if !(!shiftIsBounded(v)) {
2509 break
2510 }
2511 v.reset(OpRISCV64AND)
2512 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2513 v0.AddArg2(x, y)
2514 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2515 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2516 v2.AuxInt = int64ToAuxInt(64)
2517 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2518 v3.AddArg(y)
2519 v2.AddArg(v3)
2520 v1.AddArg(v2)
2521 v.AddArg2(v0, v1)
2522 return true
2523 }
2524
2525
2526
2527 for {
2528 x := v_0
2529 y := v_1
2530 if !(shiftIsBounded(v)) {
2531 break
2532 }
2533 v.reset(OpRISCV64SLL)
2534 v.AddArg2(x, y)
2535 return true
2536 }
2537 return false
2538 }
2539 func rewriteValueRISCV64_OpLsh8x64(v *Value) bool {
2540 v_1 := v.Args[1]
2541 v_0 := v.Args[0]
2542 b := v.Block
2543
2544
2545
2546 for {
2547 t := v.Type
2548 x := v_0
2549 y := v_1
2550 if !(!shiftIsBounded(v)) {
2551 break
2552 }
2553 v.reset(OpRISCV64AND)
2554 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2555 v0.AddArg2(x, y)
2556 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2557 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2558 v2.AuxInt = int64ToAuxInt(64)
2559 v2.AddArg(y)
2560 v1.AddArg(v2)
2561 v.AddArg2(v0, v1)
2562 return true
2563 }
2564
2565
2566
2567 for {
2568 x := v_0
2569 y := v_1
2570 if !(shiftIsBounded(v)) {
2571 break
2572 }
2573 v.reset(OpRISCV64SLL)
2574 v.AddArg2(x, y)
2575 return true
2576 }
2577 return false
2578 }
2579 func rewriteValueRISCV64_OpLsh8x8(v *Value) bool {
2580 v_1 := v.Args[1]
2581 v_0 := v.Args[0]
2582 b := v.Block
2583 typ := &b.Func.Config.Types
2584
2585
2586
2587 for {
2588 t := v.Type
2589 x := v_0
2590 y := v_1
2591 if !(!shiftIsBounded(v)) {
2592 break
2593 }
2594 v.reset(OpRISCV64AND)
2595 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2596 v0.AddArg2(x, y)
2597 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2598 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2599 v2.AuxInt = int64ToAuxInt(64)
2600 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2601 v3.AddArg(y)
2602 v2.AddArg(v3)
2603 v1.AddArg(v2)
2604 v.AddArg2(v0, v1)
2605 return true
2606 }
2607
2608
2609
2610 for {
2611 x := v_0
2612 y := v_1
2613 if !(shiftIsBounded(v)) {
2614 break
2615 }
2616 v.reset(OpRISCV64SLL)
2617 v.AddArg2(x, y)
2618 return true
2619 }
2620 return false
2621 }
2622 func rewriteValueRISCV64_OpMax64(v *Value) bool {
2623 v_1 := v.Args[1]
2624 v_0 := v.Args[0]
2625
2626
2627
2628 for {
2629 x := v_0
2630 y := v_1
2631 if !(buildcfg.GORISCV64 >= 22) {
2632 break
2633 }
2634 v.reset(OpRISCV64MAX)
2635 v.AddArg2(x, y)
2636 return true
2637 }
2638 return false
2639 }
2640 func rewriteValueRISCV64_OpMax64u(v *Value) bool {
2641 v_1 := v.Args[1]
2642 v_0 := v.Args[0]
2643
2644
2645
2646 for {
2647 x := v_0
2648 y := v_1
2649 if !(buildcfg.GORISCV64 >= 22) {
2650 break
2651 }
2652 v.reset(OpRISCV64MAXU)
2653 v.AddArg2(x, y)
2654 return true
2655 }
2656 return false
2657 }
2658 func rewriteValueRISCV64_OpMin64(v *Value) bool {
2659 v_1 := v.Args[1]
2660 v_0 := v.Args[0]
2661
2662
2663
2664 for {
2665 x := v_0
2666 y := v_1
2667 if !(buildcfg.GORISCV64 >= 22) {
2668 break
2669 }
2670 v.reset(OpRISCV64MIN)
2671 v.AddArg2(x, y)
2672 return true
2673 }
2674 return false
2675 }
2676 func rewriteValueRISCV64_OpMin64u(v *Value) bool {
2677 v_1 := v.Args[1]
2678 v_0 := v.Args[0]
2679
2680
2681
2682 for {
2683 x := v_0
2684 y := v_1
2685 if !(buildcfg.GORISCV64 >= 22) {
2686 break
2687 }
2688 v.reset(OpRISCV64MINU)
2689 v.AddArg2(x, y)
2690 return true
2691 }
2692 return false
2693 }
2694 func rewriteValueRISCV64_OpMod16(v *Value) bool {
2695 v_1 := v.Args[1]
2696 v_0 := v.Args[0]
2697 b := v.Block
2698 typ := &b.Func.Config.Types
2699
2700
2701 for {
2702 if auxIntToBool(v.AuxInt) != false {
2703 break
2704 }
2705 x := v_0
2706 y := v_1
2707 v.reset(OpRISCV64REMW)
2708 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2709 v0.AddArg(x)
2710 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2711 v1.AddArg(y)
2712 v.AddArg2(v0, v1)
2713 return true
2714 }
2715 return false
2716 }
2717 func rewriteValueRISCV64_OpMod16u(v *Value) bool {
2718 v_1 := v.Args[1]
2719 v_0 := v.Args[0]
2720 b := v.Block
2721 typ := &b.Func.Config.Types
2722
2723
2724 for {
2725 x := v_0
2726 y := v_1
2727 v.reset(OpRISCV64REMUW)
2728 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
2729 v0.AddArg(x)
2730 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
2731 v1.AddArg(y)
2732 v.AddArg2(v0, v1)
2733 return true
2734 }
2735 }
2736 func rewriteValueRISCV64_OpMod32(v *Value) bool {
2737 v_1 := v.Args[1]
2738 v_0 := v.Args[0]
2739
2740
2741 for {
2742 if auxIntToBool(v.AuxInt) != false {
2743 break
2744 }
2745 x := v_0
2746 y := v_1
2747 v.reset(OpRISCV64REMW)
2748 v.AddArg2(x, y)
2749 return true
2750 }
2751 return false
2752 }
2753 func rewriteValueRISCV64_OpMod64(v *Value) bool {
2754 v_1 := v.Args[1]
2755 v_0 := v.Args[0]
2756
2757
2758 for {
2759 if auxIntToBool(v.AuxInt) != false {
2760 break
2761 }
2762 x := v_0
2763 y := v_1
2764 v.reset(OpRISCV64REM)
2765 v.AddArg2(x, y)
2766 return true
2767 }
2768 return false
2769 }
2770 func rewriteValueRISCV64_OpMod8(v *Value) bool {
2771 v_1 := v.Args[1]
2772 v_0 := v.Args[0]
2773 b := v.Block
2774 typ := &b.Func.Config.Types
2775
2776
2777 for {
2778 x := v_0
2779 y := v_1
2780 v.reset(OpRISCV64REMW)
2781 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2782 v0.AddArg(x)
2783 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2784 v1.AddArg(y)
2785 v.AddArg2(v0, v1)
2786 return true
2787 }
2788 }
2789 func rewriteValueRISCV64_OpMod8u(v *Value) bool {
2790 v_1 := v.Args[1]
2791 v_0 := v.Args[0]
2792 b := v.Block
2793 typ := &b.Func.Config.Types
2794
2795
2796 for {
2797 x := v_0
2798 y := v_1
2799 v.reset(OpRISCV64REMUW)
2800 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
2801 v0.AddArg(x)
2802 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
2803 v1.AddArg(y)
2804 v.AddArg2(v0, v1)
2805 return true
2806 }
2807 }
2808 func rewriteValueRISCV64_OpMove(v *Value) bool {
2809 v_2 := v.Args[2]
2810 v_1 := v.Args[1]
2811 v_0 := v.Args[0]
2812 b := v.Block
2813 config := b.Func.Config
2814 typ := &b.Func.Config.Types
2815
2816
2817 for {
2818 if auxIntToInt64(v.AuxInt) != 0 {
2819 break
2820 }
2821 mem := v_2
2822 v.copyOf(mem)
2823 return true
2824 }
2825
2826
2827 for {
2828 if auxIntToInt64(v.AuxInt) != 1 {
2829 break
2830 }
2831 dst := v_0
2832 src := v_1
2833 mem := v_2
2834 v.reset(OpRISCV64MOVBstore)
2835 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2836 v0.AddArg2(src, mem)
2837 v.AddArg3(dst, v0, mem)
2838 return true
2839 }
2840
2841
2842
2843 for {
2844 if auxIntToInt64(v.AuxInt) != 2 {
2845 break
2846 }
2847 t := auxToType(v.Aux)
2848 dst := v_0
2849 src := v_1
2850 mem := v_2
2851 if !(t.Alignment()%2 == 0) {
2852 break
2853 }
2854 v.reset(OpRISCV64MOVHstore)
2855 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2856 v0.AddArg2(src, mem)
2857 v.AddArg3(dst, v0, mem)
2858 return true
2859 }
2860
2861
2862 for {
2863 if auxIntToInt64(v.AuxInt) != 2 {
2864 break
2865 }
2866 dst := v_0
2867 src := v_1
2868 mem := v_2
2869 v.reset(OpRISCV64MOVBstore)
2870 v.AuxInt = int32ToAuxInt(1)
2871 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2872 v0.AuxInt = int32ToAuxInt(1)
2873 v0.AddArg2(src, mem)
2874 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2875 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2876 v2.AddArg2(src, mem)
2877 v1.AddArg3(dst, v2, mem)
2878 v.AddArg3(dst, v0, v1)
2879 return true
2880 }
2881
2882
2883
2884 for {
2885 if auxIntToInt64(v.AuxInt) != 4 {
2886 break
2887 }
2888 t := auxToType(v.Aux)
2889 dst := v_0
2890 src := v_1
2891 mem := v_2
2892 if !(t.Alignment()%4 == 0) {
2893 break
2894 }
2895 v.reset(OpRISCV64MOVWstore)
2896 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2897 v0.AddArg2(src, mem)
2898 v.AddArg3(dst, v0, mem)
2899 return true
2900 }
2901
2902
2903
2904 for {
2905 if auxIntToInt64(v.AuxInt) != 4 {
2906 break
2907 }
2908 t := auxToType(v.Aux)
2909 dst := v_0
2910 src := v_1
2911 mem := v_2
2912 if !(t.Alignment()%2 == 0) {
2913 break
2914 }
2915 v.reset(OpRISCV64MOVHstore)
2916 v.AuxInt = int32ToAuxInt(2)
2917 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2918 v0.AuxInt = int32ToAuxInt(2)
2919 v0.AddArg2(src, mem)
2920 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2921 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2922 v2.AddArg2(src, mem)
2923 v1.AddArg3(dst, v2, mem)
2924 v.AddArg3(dst, v0, v1)
2925 return true
2926 }
2927
2928
2929 for {
2930 if auxIntToInt64(v.AuxInt) != 4 {
2931 break
2932 }
2933 dst := v_0
2934 src := v_1
2935 mem := v_2
2936 v.reset(OpRISCV64MOVBstore)
2937 v.AuxInt = int32ToAuxInt(3)
2938 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2939 v0.AuxInt = int32ToAuxInt(3)
2940 v0.AddArg2(src, mem)
2941 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2942 v1.AuxInt = int32ToAuxInt(2)
2943 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2944 v2.AuxInt = int32ToAuxInt(2)
2945 v2.AddArg2(src, mem)
2946 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2947 v3.AuxInt = int32ToAuxInt(1)
2948 v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2949 v4.AuxInt = int32ToAuxInt(1)
2950 v4.AddArg2(src, mem)
2951 v5 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2952 v6 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2953 v6.AddArg2(src, mem)
2954 v5.AddArg3(dst, v6, mem)
2955 v3.AddArg3(dst, v4, v5)
2956 v1.AddArg3(dst, v2, v3)
2957 v.AddArg3(dst, v0, v1)
2958 return true
2959 }
2960
2961
2962
2963 for {
2964 if auxIntToInt64(v.AuxInt) != 8 {
2965 break
2966 }
2967 t := auxToType(v.Aux)
2968 dst := v_0
2969 src := v_1
2970 mem := v_2
2971 if !(t.Alignment()%8 == 0) {
2972 break
2973 }
2974 v.reset(OpRISCV64MOVDstore)
2975 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2976 v0.AddArg2(src, mem)
2977 v.AddArg3(dst, v0, mem)
2978 return true
2979 }
2980
2981
2982
2983 for {
2984 if auxIntToInt64(v.AuxInt) != 8 {
2985 break
2986 }
2987 t := auxToType(v.Aux)
2988 dst := v_0
2989 src := v_1
2990 mem := v_2
2991 if !(t.Alignment()%4 == 0) {
2992 break
2993 }
2994 v.reset(OpRISCV64MOVWstore)
2995 v.AuxInt = int32ToAuxInt(4)
2996 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2997 v0.AuxInt = int32ToAuxInt(4)
2998 v0.AddArg2(src, mem)
2999 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
3000 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
3001 v2.AddArg2(src, mem)
3002 v1.AddArg3(dst, v2, mem)
3003 v.AddArg3(dst, v0, v1)
3004 return true
3005 }
3006
3007
3008
3009 for {
3010 if auxIntToInt64(v.AuxInt) != 8 {
3011 break
3012 }
3013 t := auxToType(v.Aux)
3014 dst := v_0
3015 src := v_1
3016 mem := v_2
3017 if !(t.Alignment()%2 == 0) {
3018 break
3019 }
3020 v.reset(OpRISCV64MOVHstore)
3021 v.AuxInt = int32ToAuxInt(6)
3022 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3023 v0.AuxInt = int32ToAuxInt(6)
3024 v0.AddArg2(src, mem)
3025 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
3026 v1.AuxInt = int32ToAuxInt(4)
3027 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3028 v2.AuxInt = int32ToAuxInt(4)
3029 v2.AddArg2(src, mem)
3030 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
3031 v3.AuxInt = int32ToAuxInt(2)
3032 v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3033 v4.AuxInt = int32ToAuxInt(2)
3034 v4.AddArg2(src, mem)
3035 v5 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
3036 v6 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3037 v6.AddArg2(src, mem)
3038 v5.AddArg3(dst, v6, mem)
3039 v3.AddArg3(dst, v4, v5)
3040 v1.AddArg3(dst, v2, v3)
3041 v.AddArg3(dst, v0, v1)
3042 return true
3043 }
3044
3045
3046 for {
3047 if auxIntToInt64(v.AuxInt) != 3 {
3048 break
3049 }
3050 dst := v_0
3051 src := v_1
3052 mem := v_2
3053 v.reset(OpRISCV64MOVBstore)
3054 v.AuxInt = int32ToAuxInt(2)
3055 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
3056 v0.AuxInt = int32ToAuxInt(2)
3057 v0.AddArg2(src, mem)
3058 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
3059 v1.AuxInt = int32ToAuxInt(1)
3060 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
3061 v2.AuxInt = int32ToAuxInt(1)
3062 v2.AddArg2(src, mem)
3063 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
3064 v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
3065 v4.AddArg2(src, mem)
3066 v3.AddArg3(dst, v4, mem)
3067 v1.AddArg3(dst, v2, v3)
3068 v.AddArg3(dst, v0, v1)
3069 return true
3070 }
3071
3072
3073
3074 for {
3075 if auxIntToInt64(v.AuxInt) != 6 {
3076 break
3077 }
3078 t := auxToType(v.Aux)
3079 dst := v_0
3080 src := v_1
3081 mem := v_2
3082 if !(t.Alignment()%2 == 0) {
3083 break
3084 }
3085 v.reset(OpRISCV64MOVHstore)
3086 v.AuxInt = int32ToAuxInt(4)
3087 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3088 v0.AuxInt = int32ToAuxInt(4)
3089 v0.AddArg2(src, mem)
3090 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
3091 v1.AuxInt = int32ToAuxInt(2)
3092 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3093 v2.AuxInt = int32ToAuxInt(2)
3094 v2.AddArg2(src, mem)
3095 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
3096 v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
3097 v4.AddArg2(src, mem)
3098 v3.AddArg3(dst, v4, mem)
3099 v1.AddArg3(dst, v2, v3)
3100 v.AddArg3(dst, v0, v1)
3101 return true
3102 }
3103
3104
3105
3106 for {
3107 s := auxIntToInt64(v.AuxInt)
3108 t := auxToType(v.Aux)
3109 dst := v_0
3110 src := v_1
3111 mem := v_2
3112 if !(s > 0 && s <= 3*8*moveSize(t.Alignment(), config) && logLargeCopy(v, s)) {
3113 break
3114 }
3115 v.reset(OpRISCV64LoweredMove)
3116 v.AuxInt = int64ToAuxInt(s)
3117 v.Aux = int64ToAux(t.Alignment())
3118 v.AddArg3(dst, src, mem)
3119 return true
3120 }
3121
3122
3123
3124 for {
3125 s := auxIntToInt64(v.AuxInt)
3126 t := auxToType(v.Aux)
3127 dst := v_0
3128 src := v_1
3129 mem := v_2
3130 if !(s > 3*8*moveSize(t.Alignment(), config) && logLargeCopy(v, s)) {
3131 break
3132 }
3133 v.reset(OpRISCV64LoweredMoveLoop)
3134 v.AuxInt = int64ToAuxInt(s)
3135 v.Aux = int64ToAux(t.Alignment())
3136 v.AddArg3(dst, src, mem)
3137 return true
3138 }
3139 return false
3140 }
3141 func rewriteValueRISCV64_OpNeq16(v *Value) bool {
3142 v_1 := v.Args[1]
3143 v_0 := v.Args[0]
3144 b := v.Block
3145 typ := &b.Func.Config.Types
3146
3147
3148 for {
3149 x := v_0
3150 y := v_1
3151 v.reset(OpNot)
3152 v0 := b.NewValue0(v.Pos, OpEq16, typ.Bool)
3153 v0.AddArg2(x, y)
3154 v.AddArg(v0)
3155 return true
3156 }
3157 }
3158 func rewriteValueRISCV64_OpNeq32(v *Value) bool {
3159 v_1 := v.Args[1]
3160 v_0 := v.Args[0]
3161 b := v.Block
3162 typ := &b.Func.Config.Types
3163
3164
3165 for {
3166 x := v_0
3167 y := v_1
3168 v.reset(OpNot)
3169 v0 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
3170 v0.AddArg2(x, y)
3171 v.AddArg(v0)
3172 return true
3173 }
3174 }
3175 func rewriteValueRISCV64_OpNeq64(v *Value) bool {
3176 v_1 := v.Args[1]
3177 v_0 := v.Args[0]
3178 b := v.Block
3179 typ := &b.Func.Config.Types
3180
3181
3182 for {
3183 x := v_0
3184 y := v_1
3185 v.reset(OpNot)
3186 v0 := b.NewValue0(v.Pos, OpEq64, typ.Bool)
3187 v0.AddArg2(x, y)
3188 v.AddArg(v0)
3189 return true
3190 }
3191 }
3192 func rewriteValueRISCV64_OpNeq8(v *Value) bool {
3193 v_1 := v.Args[1]
3194 v_0 := v.Args[0]
3195 b := v.Block
3196 typ := &b.Func.Config.Types
3197
3198
3199 for {
3200 x := v_0
3201 y := v_1
3202 v.reset(OpNot)
3203 v0 := b.NewValue0(v.Pos, OpEq8, typ.Bool)
3204 v0.AddArg2(x, y)
3205 v.AddArg(v0)
3206 return true
3207 }
3208 }
3209 func rewriteValueRISCV64_OpNeqB(v *Value) bool {
3210 v_1 := v.Args[1]
3211 v_0 := v.Args[0]
3212 b := v.Block
3213 typ := &b.Func.Config.Types
3214
3215
3216 for {
3217 x := v_0
3218 y := v_1
3219 v.reset(OpRISCV64SNEZ)
3220 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
3221 v0.AddArg2(x, y)
3222 v.AddArg(v0)
3223 return true
3224 }
3225 }
3226 func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
3227 v_1 := v.Args[1]
3228 v_0 := v.Args[0]
3229 b := v.Block
3230 typ := &b.Func.Config.Types
3231
3232
3233 for {
3234 x := v_0
3235 y := v_1
3236 v.reset(OpNot)
3237 v0 := b.NewValue0(v.Pos, OpEqPtr, typ.Bool)
3238 v0.AddArg2(x, y)
3239 v.AddArg(v0)
3240 return true
3241 }
3242 }
3243 func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
3244 v_0 := v.Args[0]
3245 b := v.Block
3246 typ := &b.Func.Config.Types
3247
3248
3249
3250 for {
3251 off := auxIntToInt64(v.AuxInt)
3252 ptr := v_0
3253 if ptr.Op != OpSP || !(is32Bit(off)) {
3254 break
3255 }
3256 v.reset(OpRISCV64MOVaddr)
3257 v.AuxInt = int32ToAuxInt(int32(off))
3258 v.AddArg(ptr)
3259 return true
3260 }
3261
3262
3263
3264 for {
3265 off := auxIntToInt64(v.AuxInt)
3266 ptr := v_0
3267 if !(is32Bit(off)) {
3268 break
3269 }
3270 v.reset(OpRISCV64ADDI)
3271 v.AuxInt = int64ToAuxInt(off)
3272 v.AddArg(ptr)
3273 return true
3274 }
3275
3276
3277 for {
3278 off := auxIntToInt64(v.AuxInt)
3279 ptr := v_0
3280 v.reset(OpRISCV64ADD)
3281 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
3282 v0.AuxInt = int64ToAuxInt(off)
3283 v.AddArg2(v0, ptr)
3284 return true
3285 }
3286 }
3287 func rewriteValueRISCV64_OpPopCount16(v *Value) bool {
3288 v_0 := v.Args[0]
3289 b := v.Block
3290 typ := &b.Func.Config.Types
3291
3292
3293 for {
3294 x := v_0
3295 v.reset(OpRISCV64CPOP)
3296 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3297 v0.AddArg(x)
3298 v.AddArg(v0)
3299 return true
3300 }
3301 }
3302 func rewriteValueRISCV64_OpPopCount8(v *Value) bool {
3303 v_0 := v.Args[0]
3304 b := v.Block
3305 typ := &b.Func.Config.Types
3306
3307
3308 for {
3309 x := v_0
3310 v.reset(OpRISCV64CPOP)
3311 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3312 v0.AddArg(x)
3313 v.AddArg(v0)
3314 return true
3315 }
3316 }
3317 func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
3318 v_1 := v.Args[1]
3319 v_0 := v.Args[0]
3320
3321
3322
3323 for {
3324 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3325 if v_0.Op != OpRISCV64MOVDconst {
3326 continue
3327 }
3328 t := v_0.Type
3329 val := auxIntToInt64(v_0.AuxInt)
3330 x := v_1
3331 if !(is32Bit(val) && !t.IsPtr()) {
3332 continue
3333 }
3334 v.reset(OpRISCV64ADDI)
3335 v.AuxInt = int64ToAuxInt(val)
3336 v.AddArg(x)
3337 return true
3338 }
3339 break
3340 }
3341
3342
3343 for {
3344 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3345 x := v_0
3346 if v_1.Op != OpRISCV64NEG {
3347 continue
3348 }
3349 y := v_1.Args[0]
3350 v.reset(OpRISCV64SUB)
3351 v.AddArg2(x, y)
3352 return true
3353 }
3354 break
3355 }
3356
3357
3358
3359 for {
3360 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3361 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 1 {
3362 continue
3363 }
3364 x := v_0.Args[0]
3365 y := v_1
3366 if !(buildcfg.GORISCV64 >= 22) {
3367 continue
3368 }
3369 v.reset(OpRISCV64SH1ADD)
3370 v.AddArg2(x, y)
3371 return true
3372 }
3373 break
3374 }
3375
3376
3377
3378 for {
3379 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3380 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 2 {
3381 continue
3382 }
3383 x := v_0.Args[0]
3384 y := v_1
3385 if !(buildcfg.GORISCV64 >= 22) {
3386 continue
3387 }
3388 v.reset(OpRISCV64SH2ADD)
3389 v.AddArg2(x, y)
3390 return true
3391 }
3392 break
3393 }
3394
3395
3396
3397 for {
3398 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3399 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 3 {
3400 continue
3401 }
3402 x := v_0.Args[0]
3403 y := v_1
3404 if !(buildcfg.GORISCV64 >= 22) {
3405 continue
3406 }
3407 v.reset(OpRISCV64SH3ADD)
3408 v.AddArg2(x, y)
3409 return true
3410 }
3411 break
3412 }
3413 return false
3414 }
3415 func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
3416 v_0 := v.Args[0]
3417
3418
3419
3420 for {
3421 c := auxIntToInt64(v.AuxInt)
3422 if v_0.Op != OpRISCV64MOVaddr {
3423 break
3424 }
3425 d := auxIntToInt32(v_0.AuxInt)
3426 s := auxToSym(v_0.Aux)
3427 x := v_0.Args[0]
3428 if !(is32Bit(c + int64(d))) {
3429 break
3430 }
3431 v.reset(OpRISCV64MOVaddr)
3432 v.AuxInt = int32ToAuxInt(int32(c) + d)
3433 v.Aux = symToAux(s)
3434 v.AddArg(x)
3435 return true
3436 }
3437
3438
3439 for {
3440 if auxIntToInt64(v.AuxInt) != 0 {
3441 break
3442 }
3443 x := v_0
3444 v.copyOf(x)
3445 return true
3446 }
3447
3448
3449
3450 for {
3451 x := auxIntToInt64(v.AuxInt)
3452 if v_0.Op != OpRISCV64MOVDconst {
3453 break
3454 }
3455 y := auxIntToInt64(v_0.AuxInt)
3456 if !(is32Bit(x + y)) {
3457 break
3458 }
3459 v.reset(OpRISCV64MOVDconst)
3460 v.AuxInt = int64ToAuxInt(x + y)
3461 return true
3462 }
3463
3464
3465
3466 for {
3467 x := auxIntToInt64(v.AuxInt)
3468 if v_0.Op != OpRISCV64ADDI {
3469 break
3470 }
3471 y := auxIntToInt64(v_0.AuxInt)
3472 z := v_0.Args[0]
3473 if !(is32Bit(x + y)) {
3474 break
3475 }
3476 v.reset(OpRISCV64ADDI)
3477 v.AuxInt = int64ToAuxInt(x + y)
3478 v.AddArg(z)
3479 return true
3480 }
3481 return false
3482 }
3483 func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
3484 v_1 := v.Args[1]
3485 v_0 := v.Args[0]
3486
3487
3488
3489 for {
3490 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3491 if v_0.Op != OpRISCV64MOVDconst {
3492 continue
3493 }
3494 val := auxIntToInt64(v_0.AuxInt)
3495 x := v_1
3496 if !(is32Bit(val)) {
3497 continue
3498 }
3499 v.reset(OpRISCV64ANDI)
3500 v.AuxInt = int64ToAuxInt(val)
3501 v.AddArg(x)
3502 return true
3503 }
3504 break
3505 }
3506
3507
3508 for {
3509 x := v_0
3510 if x != v_1 {
3511 break
3512 }
3513 v.copyOf(x)
3514 return true
3515 }
3516 return false
3517 }
3518 func rewriteValueRISCV64_OpRISCV64ANDI(v *Value) bool {
3519 v_0 := v.Args[0]
3520
3521
3522 for {
3523 if auxIntToInt64(v.AuxInt) != 0 {
3524 break
3525 }
3526 v.reset(OpRISCV64MOVDconst)
3527 v.AuxInt = int64ToAuxInt(0)
3528 return true
3529 }
3530
3531
3532 for {
3533 if auxIntToInt64(v.AuxInt) != -1 {
3534 break
3535 }
3536 x := v_0
3537 v.copyOf(x)
3538 return true
3539 }
3540
3541
3542 for {
3543 x := auxIntToInt64(v.AuxInt)
3544 if v_0.Op != OpRISCV64MOVDconst {
3545 break
3546 }
3547 y := auxIntToInt64(v_0.AuxInt)
3548 v.reset(OpRISCV64MOVDconst)
3549 v.AuxInt = int64ToAuxInt(x & y)
3550 return true
3551 }
3552
3553
3554 for {
3555 x := auxIntToInt64(v.AuxInt)
3556 if v_0.Op != OpRISCV64ANDI {
3557 break
3558 }
3559 y := auxIntToInt64(v_0.AuxInt)
3560 z := v_0.Args[0]
3561 v.reset(OpRISCV64ANDI)
3562 v.AuxInt = int64ToAuxInt(x & y)
3563 v.AddArg(z)
3564 return true
3565 }
3566 return false
3567 }
3568 func rewriteValueRISCV64_OpRISCV64CZEROEQZ(v *Value) bool {
3569 v_1 := v.Args[1]
3570 v_0 := v.Args[0]
3571
3572
3573 for {
3574 x := v_0
3575 if v_1.Op != OpRISCV64SNEZ {
3576 break
3577 }
3578 y := v_1.Args[0]
3579 v.reset(OpRISCV64CZEROEQZ)
3580 v.AddArg2(x, y)
3581 return true
3582 }
3583
3584
3585 for {
3586 x := v_0
3587 if v_1.Op != OpRISCV64SEQZ {
3588 break
3589 }
3590 y := v_1.Args[0]
3591 v.reset(OpRISCV64CZERONEZ)
3592 v.AddArg2(x, y)
3593 return true
3594 }
3595
3596
3597 for {
3598 x := v_0
3599 if v_1.Op != OpRISCV64NEG {
3600 break
3601 }
3602 y := v_1.Args[0]
3603 v.reset(OpRISCV64CZEROEQZ)
3604 v.AddArg2(x, y)
3605 return true
3606 }
3607
3608
3609 for {
3610 x := v_0
3611 if x != v_1 {
3612 break
3613 }
3614 v.copyOf(x)
3615 return true
3616 }
3617
3618
3619 for {
3620 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
3621 break
3622 }
3623 v.reset(OpRISCV64MOVDconst)
3624 v.AuxInt = int64ToAuxInt(0)
3625 return true
3626 }
3627 return false
3628 }
3629 func rewriteValueRISCV64_OpRISCV64CZERONEZ(v *Value) bool {
3630 v_1 := v.Args[1]
3631 v_0 := v.Args[0]
3632
3633
3634 for {
3635 x := v_0
3636 if v_1.Op != OpRISCV64SNEZ {
3637 break
3638 }
3639 y := v_1.Args[0]
3640 v.reset(OpRISCV64CZERONEZ)
3641 v.AddArg2(x, y)
3642 return true
3643 }
3644
3645
3646 for {
3647 x := v_0
3648 if v_1.Op != OpRISCV64SEQZ {
3649 break
3650 }
3651 y := v_1.Args[0]
3652 v.reset(OpRISCV64CZEROEQZ)
3653 v.AddArg2(x, y)
3654 return true
3655 }
3656
3657
3658 for {
3659 x := v_0
3660 if v_1.Op != OpRISCV64NEG {
3661 break
3662 }
3663 y := v_1.Args[0]
3664 v.reset(OpRISCV64CZERONEZ)
3665 v.AddArg2(x, y)
3666 return true
3667 }
3668
3669
3670 for {
3671 x := v_0
3672 if x != v_1 {
3673 break
3674 }
3675 v.reset(OpRISCV64MOVDconst)
3676 v.AuxInt = int64ToAuxInt(0)
3677 return true
3678 }
3679
3680
3681 for {
3682 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
3683 break
3684 }
3685 v.reset(OpRISCV64MOVDconst)
3686 v.AuxInt = int64ToAuxInt(0)
3687 return true
3688 }
3689 return false
3690 }
3691 func rewriteValueRISCV64_OpRISCV64FADDD(v *Value) bool {
3692 v_1 := v.Args[1]
3693 v_0 := v.Args[0]
3694
3695
3696
3697 for {
3698 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3699 a := v_0
3700 if v_1.Op != OpRISCV64FMULD {
3701 continue
3702 }
3703 y := v_1.Args[1]
3704 x := v_1.Args[0]
3705 if !(a.Block.Func.useFMA(v)) {
3706 continue
3707 }
3708 v.reset(OpRISCV64FMADDD)
3709 v.AddArg3(x, y, a)
3710 return true
3711 }
3712 break
3713 }
3714 return false
3715 }
3716 func rewriteValueRISCV64_OpRISCV64FADDS(v *Value) bool {
3717 v_1 := v.Args[1]
3718 v_0 := v.Args[0]
3719
3720
3721
3722 for {
3723 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3724 a := v_0
3725 if v_1.Op != OpRISCV64FMULS {
3726 continue
3727 }
3728 y := v_1.Args[1]
3729 x := v_1.Args[0]
3730 if !(a.Block.Func.useFMA(v)) {
3731 continue
3732 }
3733 v.reset(OpRISCV64FMADDS)
3734 v.AddArg3(x, y, a)
3735 return true
3736 }
3737 break
3738 }
3739 return false
3740 }
3741 func rewriteValueRISCV64_OpRISCV64FCVTSD(v *Value) bool {
3742 v_0 := v.Args[0]
3743
3744
3745 for {
3746 if v_0.Op != OpRISCV64FABSD {
3747 break
3748 }
3749 v_0_0 := v_0.Args[0]
3750 if v_0_0.Op != OpRISCV64FCVTDS {
3751 break
3752 }
3753 X := v_0_0.Args[0]
3754 v.reset(OpRISCV64FABSS)
3755 v.AddArg(X)
3756 return true
3757 }
3758
3759
3760 for {
3761 if v_0.Op != OpRISCV64FSQRTD {
3762 break
3763 }
3764 v_0_0 := v_0.Args[0]
3765 if v_0_0.Op != OpRISCV64FCVTDS {
3766 break
3767 }
3768 X := v_0_0.Args[0]
3769 v.reset(OpRISCV64FSQRTS)
3770 v.AddArg(X)
3771 return true
3772 }
3773 return false
3774 }
3775 func rewriteValueRISCV64_OpRISCV64FEQD(v *Value) bool {
3776 v_1 := v.Args[1]
3777 v_0 := v.Args[0]
3778 b := v.Block
3779 typ := &b.Func.Config.Types
3780
3781
3782 for {
3783 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3784 x := v_0
3785 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(-1) {
3786 continue
3787 }
3788 v.reset(OpRISCV64ANDI)
3789 v.AuxInt = int64ToAuxInt(0b00_0000_0001)
3790 v0 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3791 v0.AddArg(x)
3792 v.AddArg(v0)
3793 return true
3794 }
3795 break
3796 }
3797
3798
3799 for {
3800 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3801 x := v_0
3802 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(1) {
3803 continue
3804 }
3805 v.reset(OpRISCV64SNEZ)
3806 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3807 v0.AuxInt = int64ToAuxInt(0b00_1000_0000)
3808 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3809 v1.AddArg(x)
3810 v0.AddArg(v1)
3811 v.AddArg(v0)
3812 return true
3813 }
3814 break
3815 }
3816 return false
3817 }
3818 func rewriteValueRISCV64_OpRISCV64FLED(v *Value) bool {
3819 v_1 := v.Args[1]
3820 v_0 := v.Args[0]
3821 b := v.Block
3822 typ := &b.Func.Config.Types
3823
3824
3825 for {
3826 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != -math.MaxFloat64 {
3827 break
3828 }
3829 x := v_1
3830 v.reset(OpRISCV64SNEZ)
3831 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3832 v0.AuxInt = int64ToAuxInt(0b00_1111_1110)
3833 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3834 v1.AddArg(x)
3835 v0.AddArg(v1)
3836 v.AddArg(v0)
3837 return true
3838 }
3839
3840
3841 for {
3842 x := v_0
3843 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.MaxFloat64 {
3844 break
3845 }
3846 v.reset(OpRISCV64SNEZ)
3847 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3848 v0.AuxInt = int64ToAuxInt(0b00_0111_1111)
3849 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3850 v1.AddArg(x)
3851 v0.AddArg(v1)
3852 v.AddArg(v0)
3853 return true
3854 }
3855
3856
3857 for {
3858 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != +0x1p-1022 {
3859 break
3860 }
3861 x := v_1
3862 v.reset(OpRISCV64SNEZ)
3863 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3864 v0.AuxInt = int64ToAuxInt(0b00_1100_0000)
3865 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3866 v1.AddArg(x)
3867 v0.AddArg(v1)
3868 v.AddArg(v0)
3869 return true
3870 }
3871
3872
3873 for {
3874 x := v_0
3875 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != -0x1p-1022 {
3876 break
3877 }
3878 v.reset(OpRISCV64SNEZ)
3879 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3880 v0.AuxInt = int64ToAuxInt(0b00_0000_0011)
3881 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3882 v1.AddArg(x)
3883 v0.AddArg(v1)
3884 v.AddArg(v0)
3885 return true
3886 }
3887 return false
3888 }
3889 func rewriteValueRISCV64_OpRISCV64FLTD(v *Value) bool {
3890 v_1 := v.Args[1]
3891 v_0 := v.Args[0]
3892 b := v.Block
3893 typ := &b.Func.Config.Types
3894
3895
3896 for {
3897 x := v_0
3898 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != -math.MaxFloat64 {
3899 break
3900 }
3901 v.reset(OpRISCV64ANDI)
3902 v.AuxInt = int64ToAuxInt(0b00_0000_0001)
3903 v0 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3904 v0.AddArg(x)
3905 v.AddArg(v0)
3906 return true
3907 }
3908
3909
3910 for {
3911 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != math.MaxFloat64 {
3912 break
3913 }
3914 x := v_1
3915 v.reset(OpRISCV64SNEZ)
3916 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3917 v0.AuxInt = int64ToAuxInt(0b00_1000_0000)
3918 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3919 v1.AddArg(x)
3920 v0.AddArg(v1)
3921 v.AddArg(v0)
3922 return true
3923 }
3924
3925
3926 for {
3927 x := v_0
3928 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != +0x1p-1022 {
3929 break
3930 }
3931 v.reset(OpRISCV64SNEZ)
3932 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3933 v0.AuxInt = int64ToAuxInt(0b00_0011_1111)
3934 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3935 v1.AddArg(x)
3936 v0.AddArg(v1)
3937 v.AddArg(v0)
3938 return true
3939 }
3940
3941
3942 for {
3943 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != -0x1p-1022 {
3944 break
3945 }
3946 x := v_1
3947 v.reset(OpRISCV64SNEZ)
3948 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3949 v0.AuxInt = int64ToAuxInt(0b00_1111_1100)
3950 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3951 v1.AddArg(x)
3952 v0.AddArg(v1)
3953 v.AddArg(v0)
3954 return true
3955 }
3956 return false
3957 }
3958 func rewriteValueRISCV64_OpRISCV64FMADDD(v *Value) bool {
3959 v_2 := v.Args[2]
3960 v_1 := v.Args[1]
3961 v_0 := v.Args[0]
3962
3963
3964
3965 for {
3966 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3967 neg := v_0
3968 if neg.Op != OpRISCV64FNEGD {
3969 continue
3970 }
3971 x := neg.Args[0]
3972 y := v_1
3973 z := v_2
3974 if !(neg.Uses == 1) {
3975 continue
3976 }
3977 v.reset(OpRISCV64FNMSUBD)
3978 v.AddArg3(x, y, z)
3979 return true
3980 }
3981 break
3982 }
3983
3984
3985
3986 for {
3987 x := v_0
3988 y := v_1
3989 neg := v_2
3990 if neg.Op != OpRISCV64FNEGD {
3991 break
3992 }
3993 z := neg.Args[0]
3994 if !(neg.Uses == 1) {
3995 break
3996 }
3997 v.reset(OpRISCV64FMSUBD)
3998 v.AddArg3(x, y, z)
3999 return true
4000 }
4001 return false
4002 }
4003 func rewriteValueRISCV64_OpRISCV64FMADDS(v *Value) bool {
4004 v_2 := v.Args[2]
4005 v_1 := v.Args[1]
4006 v_0 := v.Args[0]
4007
4008
4009
4010 for {
4011 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4012 neg := v_0
4013 if neg.Op != OpRISCV64FNEGS {
4014 continue
4015 }
4016 x := neg.Args[0]
4017 y := v_1
4018 z := v_2
4019 if !(neg.Uses == 1) {
4020 continue
4021 }
4022 v.reset(OpRISCV64FNMSUBS)
4023 v.AddArg3(x, y, z)
4024 return true
4025 }
4026 break
4027 }
4028
4029
4030
4031 for {
4032 x := v_0
4033 y := v_1
4034 neg := v_2
4035 if neg.Op != OpRISCV64FNEGS {
4036 break
4037 }
4038 z := neg.Args[0]
4039 if !(neg.Uses == 1) {
4040 break
4041 }
4042 v.reset(OpRISCV64FMSUBS)
4043 v.AddArg3(x, y, z)
4044 return true
4045 }
4046 return false
4047 }
4048 func rewriteValueRISCV64_OpRISCV64FMOVDload(v *Value) bool {
4049 v_1 := v.Args[1]
4050 v_0 := v.Args[0]
4051 b := v.Block
4052 config := b.Func.Config
4053
4054
4055
4056 for {
4057 off1 := auxIntToInt32(v.AuxInt)
4058 sym1 := auxToSym(v.Aux)
4059 if v_0.Op != OpRISCV64MOVaddr {
4060 break
4061 }
4062 off2 := auxIntToInt32(v_0.AuxInt)
4063 sym2 := auxToSym(v_0.Aux)
4064 base := v_0.Args[0]
4065 mem := v_1
4066 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4067 break
4068 }
4069 v.reset(OpRISCV64FMOVDload)
4070 v.AuxInt = int32ToAuxInt(off1 + off2)
4071 v.Aux = symToAux(mergeSym(sym1, sym2))
4072 v.AddArg2(base, mem)
4073 return true
4074 }
4075
4076
4077
4078 for {
4079 off1 := auxIntToInt32(v.AuxInt)
4080 sym := auxToSym(v.Aux)
4081 if v_0.Op != OpRISCV64ADDI {
4082 break
4083 }
4084 off2 := auxIntToInt64(v_0.AuxInt)
4085 base := v_0.Args[0]
4086 mem := v_1
4087 if !(is32Bit(int64(off1) + off2)) {
4088 break
4089 }
4090 v.reset(OpRISCV64FMOVDload)
4091 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4092 v.Aux = symToAux(sym)
4093 v.AddArg2(base, mem)
4094 return true
4095 }
4096
4097
4098
4099 for {
4100 off := auxIntToInt32(v.AuxInt)
4101 sym := auxToSym(v.Aux)
4102 ptr1 := v_0
4103 if v_1.Op != OpRISCV64MOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
4104 break
4105 }
4106 x := v_1.Args[1]
4107 ptr2 := v_1.Args[0]
4108 if !(isSamePtr(ptr1, ptr2)) {
4109 break
4110 }
4111 v.reset(OpRISCV64FMVDX)
4112 v.AddArg(x)
4113 return true
4114 }
4115 return false
4116 }
4117 func rewriteValueRISCV64_OpRISCV64FMOVDstore(v *Value) bool {
4118 v_2 := v.Args[2]
4119 v_1 := v.Args[1]
4120 v_0 := v.Args[0]
4121 b := v.Block
4122 config := b.Func.Config
4123
4124
4125
4126 for {
4127 off1 := auxIntToInt32(v.AuxInt)
4128 sym1 := auxToSym(v.Aux)
4129 if v_0.Op != OpRISCV64MOVaddr {
4130 break
4131 }
4132 off2 := auxIntToInt32(v_0.AuxInt)
4133 sym2 := auxToSym(v_0.Aux)
4134 base := v_0.Args[0]
4135 val := v_1
4136 mem := v_2
4137 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4138 break
4139 }
4140 v.reset(OpRISCV64FMOVDstore)
4141 v.AuxInt = int32ToAuxInt(off1 + off2)
4142 v.Aux = symToAux(mergeSym(sym1, sym2))
4143 v.AddArg3(base, val, mem)
4144 return true
4145 }
4146
4147
4148
4149 for {
4150 off1 := auxIntToInt32(v.AuxInt)
4151 sym := auxToSym(v.Aux)
4152 if v_0.Op != OpRISCV64ADDI {
4153 break
4154 }
4155 off2 := auxIntToInt64(v_0.AuxInt)
4156 base := v_0.Args[0]
4157 val := v_1
4158 mem := v_2
4159 if !(is32Bit(int64(off1) + off2)) {
4160 break
4161 }
4162 v.reset(OpRISCV64FMOVDstore)
4163 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4164 v.Aux = symToAux(sym)
4165 v.AddArg3(base, val, mem)
4166 return true
4167 }
4168 return false
4169 }
4170 func rewriteValueRISCV64_OpRISCV64FMOVWload(v *Value) bool {
4171 v_1 := v.Args[1]
4172 v_0 := v.Args[0]
4173 b := v.Block
4174 config := b.Func.Config
4175
4176
4177
4178 for {
4179 off1 := auxIntToInt32(v.AuxInt)
4180 sym1 := auxToSym(v.Aux)
4181 if v_0.Op != OpRISCV64MOVaddr {
4182 break
4183 }
4184 off2 := auxIntToInt32(v_0.AuxInt)
4185 sym2 := auxToSym(v_0.Aux)
4186 base := v_0.Args[0]
4187 mem := v_1
4188 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4189 break
4190 }
4191 v.reset(OpRISCV64FMOVWload)
4192 v.AuxInt = int32ToAuxInt(off1 + off2)
4193 v.Aux = symToAux(mergeSym(sym1, sym2))
4194 v.AddArg2(base, mem)
4195 return true
4196 }
4197
4198
4199
4200 for {
4201 off1 := auxIntToInt32(v.AuxInt)
4202 sym := auxToSym(v.Aux)
4203 if v_0.Op != OpRISCV64ADDI {
4204 break
4205 }
4206 off2 := auxIntToInt64(v_0.AuxInt)
4207 base := v_0.Args[0]
4208 mem := v_1
4209 if !(is32Bit(int64(off1) + off2)) {
4210 break
4211 }
4212 v.reset(OpRISCV64FMOVWload)
4213 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4214 v.Aux = symToAux(sym)
4215 v.AddArg2(base, mem)
4216 return true
4217 }
4218
4219
4220
4221 for {
4222 off := auxIntToInt32(v.AuxInt)
4223 sym := auxToSym(v.Aux)
4224 ptr1 := v_0
4225 if v_1.Op != OpRISCV64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
4226 break
4227 }
4228 x := v_1.Args[1]
4229 ptr2 := v_1.Args[0]
4230 if !(isSamePtr(ptr1, ptr2)) {
4231 break
4232 }
4233 v.reset(OpRISCV64FMVSX)
4234 v.AddArg(x)
4235 return true
4236 }
4237 return false
4238 }
4239 func rewriteValueRISCV64_OpRISCV64FMOVWstore(v *Value) bool {
4240 v_2 := v.Args[2]
4241 v_1 := v.Args[1]
4242 v_0 := v.Args[0]
4243 b := v.Block
4244 config := b.Func.Config
4245
4246
4247
4248 for {
4249 off1 := auxIntToInt32(v.AuxInt)
4250 sym1 := auxToSym(v.Aux)
4251 if v_0.Op != OpRISCV64MOVaddr {
4252 break
4253 }
4254 off2 := auxIntToInt32(v_0.AuxInt)
4255 sym2 := auxToSym(v_0.Aux)
4256 base := v_0.Args[0]
4257 val := v_1
4258 mem := v_2
4259 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4260 break
4261 }
4262 v.reset(OpRISCV64FMOVWstore)
4263 v.AuxInt = int32ToAuxInt(off1 + off2)
4264 v.Aux = symToAux(mergeSym(sym1, sym2))
4265 v.AddArg3(base, val, mem)
4266 return true
4267 }
4268
4269
4270
4271 for {
4272 off1 := auxIntToInt32(v.AuxInt)
4273 sym := auxToSym(v.Aux)
4274 if v_0.Op != OpRISCV64ADDI {
4275 break
4276 }
4277 off2 := auxIntToInt64(v_0.AuxInt)
4278 base := v_0.Args[0]
4279 val := v_1
4280 mem := v_2
4281 if !(is32Bit(int64(off1) + off2)) {
4282 break
4283 }
4284 v.reset(OpRISCV64FMOVWstore)
4285 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4286 v.Aux = symToAux(sym)
4287 v.AddArg3(base, val, mem)
4288 return true
4289 }
4290 return false
4291 }
4292 func rewriteValueRISCV64_OpRISCV64FMSUBD(v *Value) bool {
4293 v_2 := v.Args[2]
4294 v_1 := v.Args[1]
4295 v_0 := v.Args[0]
4296
4297
4298
4299 for {
4300 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4301 neg := v_0
4302 if neg.Op != OpRISCV64FNEGD {
4303 continue
4304 }
4305 x := neg.Args[0]
4306 y := v_1
4307 z := v_2
4308 if !(neg.Uses == 1) {
4309 continue
4310 }
4311 v.reset(OpRISCV64FNMADDD)
4312 v.AddArg3(x, y, z)
4313 return true
4314 }
4315 break
4316 }
4317
4318
4319
4320 for {
4321 x := v_0
4322 y := v_1
4323 neg := v_2
4324 if neg.Op != OpRISCV64FNEGD {
4325 break
4326 }
4327 z := neg.Args[0]
4328 if !(neg.Uses == 1) {
4329 break
4330 }
4331 v.reset(OpRISCV64FMADDD)
4332 v.AddArg3(x, y, z)
4333 return true
4334 }
4335 return false
4336 }
4337 func rewriteValueRISCV64_OpRISCV64FMSUBS(v *Value) bool {
4338 v_2 := v.Args[2]
4339 v_1 := v.Args[1]
4340 v_0 := v.Args[0]
4341
4342
4343
4344 for {
4345 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4346 neg := v_0
4347 if neg.Op != OpRISCV64FNEGS {
4348 continue
4349 }
4350 x := neg.Args[0]
4351 y := v_1
4352 z := v_2
4353 if !(neg.Uses == 1) {
4354 continue
4355 }
4356 v.reset(OpRISCV64FNMADDS)
4357 v.AddArg3(x, y, z)
4358 return true
4359 }
4360 break
4361 }
4362
4363
4364
4365 for {
4366 x := v_0
4367 y := v_1
4368 neg := v_2
4369 if neg.Op != OpRISCV64FNEGS {
4370 break
4371 }
4372 z := neg.Args[0]
4373 if !(neg.Uses == 1) {
4374 break
4375 }
4376 v.reset(OpRISCV64FMADDS)
4377 v.AddArg3(x, y, z)
4378 return true
4379 }
4380 return false
4381 }
4382 func rewriteValueRISCV64_OpRISCV64FNED(v *Value) bool {
4383 v_1 := v.Args[1]
4384 v_0 := v.Args[0]
4385 b := v.Block
4386 typ := &b.Func.Config.Types
4387
4388
4389 for {
4390 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4391 x := v_0
4392 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(-1) {
4393 continue
4394 }
4395 v.reset(OpRISCV64SEQZ)
4396 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
4397 v0.AuxInt = int64ToAuxInt(0b00_0000_0001)
4398 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
4399 v1.AddArg(x)
4400 v0.AddArg(v1)
4401 v.AddArg(v0)
4402 return true
4403 }
4404 break
4405 }
4406
4407
4408 for {
4409 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4410 x := v_0
4411 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(1) {
4412 continue
4413 }
4414 v.reset(OpRISCV64SEQZ)
4415 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
4416 v0.AuxInt = int64ToAuxInt(0b00_1000_0000)
4417 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
4418 v1.AddArg(x)
4419 v0.AddArg(v1)
4420 v.AddArg(v0)
4421 return true
4422 }
4423 break
4424 }
4425 return false
4426 }
4427 func rewriteValueRISCV64_OpRISCV64FNMADDD(v *Value) bool {
4428 v_2 := v.Args[2]
4429 v_1 := v.Args[1]
4430 v_0 := v.Args[0]
4431
4432
4433
4434 for {
4435 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4436 neg := v_0
4437 if neg.Op != OpRISCV64FNEGD {
4438 continue
4439 }
4440 x := neg.Args[0]
4441 y := v_1
4442 z := v_2
4443 if !(neg.Uses == 1) {
4444 continue
4445 }
4446 v.reset(OpRISCV64FMSUBD)
4447 v.AddArg3(x, y, z)
4448 return true
4449 }
4450 break
4451 }
4452
4453
4454
4455 for {
4456 x := v_0
4457 y := v_1
4458 neg := v_2
4459 if neg.Op != OpRISCV64FNEGD {
4460 break
4461 }
4462 z := neg.Args[0]
4463 if !(neg.Uses == 1) {
4464 break
4465 }
4466 v.reset(OpRISCV64FNMSUBD)
4467 v.AddArg3(x, y, z)
4468 return true
4469 }
4470 return false
4471 }
4472 func rewriteValueRISCV64_OpRISCV64FNMADDS(v *Value) bool {
4473 v_2 := v.Args[2]
4474 v_1 := v.Args[1]
4475 v_0 := v.Args[0]
4476
4477
4478
4479 for {
4480 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4481 neg := v_0
4482 if neg.Op != OpRISCV64FNEGS {
4483 continue
4484 }
4485 x := neg.Args[0]
4486 y := v_1
4487 z := v_2
4488 if !(neg.Uses == 1) {
4489 continue
4490 }
4491 v.reset(OpRISCV64FMSUBS)
4492 v.AddArg3(x, y, z)
4493 return true
4494 }
4495 break
4496 }
4497
4498
4499
4500 for {
4501 x := v_0
4502 y := v_1
4503 neg := v_2
4504 if neg.Op != OpRISCV64FNEGS {
4505 break
4506 }
4507 z := neg.Args[0]
4508 if !(neg.Uses == 1) {
4509 break
4510 }
4511 v.reset(OpRISCV64FNMSUBS)
4512 v.AddArg3(x, y, z)
4513 return true
4514 }
4515 return false
4516 }
4517 func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *Value) bool {
4518 v_2 := v.Args[2]
4519 v_1 := v.Args[1]
4520 v_0 := v.Args[0]
4521
4522
4523
4524 for {
4525 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4526 neg := v_0
4527 if neg.Op != OpRISCV64FNEGD {
4528 continue
4529 }
4530 x := neg.Args[0]
4531 y := v_1
4532 z := v_2
4533 if !(neg.Uses == 1) {
4534 continue
4535 }
4536 v.reset(OpRISCV64FMADDD)
4537 v.AddArg3(x, y, z)
4538 return true
4539 }
4540 break
4541 }
4542
4543
4544
4545 for {
4546 x := v_0
4547 y := v_1
4548 neg := v_2
4549 if neg.Op != OpRISCV64FNEGD {
4550 break
4551 }
4552 z := neg.Args[0]
4553 if !(neg.Uses == 1) {
4554 break
4555 }
4556 v.reset(OpRISCV64FNMADDD)
4557 v.AddArg3(x, y, z)
4558 return true
4559 }
4560 return false
4561 }
4562 func rewriteValueRISCV64_OpRISCV64FNMSUBS(v *Value) bool {
4563 v_2 := v.Args[2]
4564 v_1 := v.Args[1]
4565 v_0 := v.Args[0]
4566
4567
4568
4569 for {
4570 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4571 neg := v_0
4572 if neg.Op != OpRISCV64FNEGS {
4573 continue
4574 }
4575 x := neg.Args[0]
4576 y := v_1
4577 z := v_2
4578 if !(neg.Uses == 1) {
4579 continue
4580 }
4581 v.reset(OpRISCV64FMADDS)
4582 v.AddArg3(x, y, z)
4583 return true
4584 }
4585 break
4586 }
4587
4588
4589
4590 for {
4591 x := v_0
4592 y := v_1
4593 neg := v_2
4594 if neg.Op != OpRISCV64FNEGS {
4595 break
4596 }
4597 z := neg.Args[0]
4598 if !(neg.Uses == 1) {
4599 break
4600 }
4601 v.reset(OpRISCV64FNMADDS)
4602 v.AddArg3(x, y, z)
4603 return true
4604 }
4605 return false
4606 }
4607 func rewriteValueRISCV64_OpRISCV64FSUBD(v *Value) bool {
4608 v_1 := v.Args[1]
4609 v_0 := v.Args[0]
4610
4611
4612
4613 for {
4614 a := v_0
4615 if v_1.Op != OpRISCV64FMULD {
4616 break
4617 }
4618 y := v_1.Args[1]
4619 x := v_1.Args[0]
4620 if !(a.Block.Func.useFMA(v)) {
4621 break
4622 }
4623 v.reset(OpRISCV64FNMSUBD)
4624 v.AddArg3(x, y, a)
4625 return true
4626 }
4627
4628
4629
4630 for {
4631 if v_0.Op != OpRISCV64FMULD {
4632 break
4633 }
4634 y := v_0.Args[1]
4635 x := v_0.Args[0]
4636 a := v_1
4637 if !(a.Block.Func.useFMA(v)) {
4638 break
4639 }
4640 v.reset(OpRISCV64FMSUBD)
4641 v.AddArg3(x, y, a)
4642 return true
4643 }
4644 return false
4645 }
4646 func rewriteValueRISCV64_OpRISCV64FSUBS(v *Value) bool {
4647 v_1 := v.Args[1]
4648 v_0 := v.Args[0]
4649
4650
4651
4652 for {
4653 a := v_0
4654 if v_1.Op != OpRISCV64FMULS {
4655 break
4656 }
4657 y := v_1.Args[1]
4658 x := v_1.Args[0]
4659 if !(a.Block.Func.useFMA(v)) {
4660 break
4661 }
4662 v.reset(OpRISCV64FNMSUBS)
4663 v.AddArg3(x, y, a)
4664 return true
4665 }
4666
4667
4668
4669 for {
4670 if v_0.Op != OpRISCV64FMULS {
4671 break
4672 }
4673 y := v_0.Args[1]
4674 x := v_0.Args[0]
4675 a := v_1
4676 if !(a.Block.Func.useFMA(v)) {
4677 break
4678 }
4679 v.reset(OpRISCV64FMSUBS)
4680 v.AddArg3(x, y, a)
4681 return true
4682 }
4683 return false
4684 }
4685 func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsCR(v *Value) bool {
4686 v_1 := v.Args[1]
4687 v_0 := v.Args[0]
4688
4689
4690 for {
4691 kind := auxIntToInt64(v.AuxInt)
4692 p := auxToPanicBoundsC(v.Aux)
4693 if v_0.Op != OpRISCV64MOVDconst {
4694 break
4695 }
4696 c := auxIntToInt64(v_0.AuxInt)
4697 mem := v_1
4698 v.reset(OpRISCV64LoweredPanicBoundsCC)
4699 v.AuxInt = int64ToAuxInt(kind)
4700 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: p.C, Cy: c})
4701 v.AddArg(mem)
4702 return true
4703 }
4704 return false
4705 }
4706 func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRC(v *Value) bool {
4707 v_1 := v.Args[1]
4708 v_0 := v.Args[0]
4709
4710
4711 for {
4712 kind := auxIntToInt64(v.AuxInt)
4713 p := auxToPanicBoundsC(v.Aux)
4714 if v_0.Op != OpRISCV64MOVDconst {
4715 break
4716 }
4717 c := auxIntToInt64(v_0.AuxInt)
4718 mem := v_1
4719 v.reset(OpRISCV64LoweredPanicBoundsCC)
4720 v.AuxInt = int64ToAuxInt(kind)
4721 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: c, Cy: p.C})
4722 v.AddArg(mem)
4723 return true
4724 }
4725 return false
4726 }
4727 func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRR(v *Value) bool {
4728 v_2 := v.Args[2]
4729 v_1 := v.Args[1]
4730 v_0 := v.Args[0]
4731
4732
4733 for {
4734 kind := auxIntToInt64(v.AuxInt)
4735 x := v_0
4736 if v_1.Op != OpRISCV64MOVDconst {
4737 break
4738 }
4739 c := auxIntToInt64(v_1.AuxInt)
4740 mem := v_2
4741 v.reset(OpRISCV64LoweredPanicBoundsRC)
4742 v.AuxInt = int64ToAuxInt(kind)
4743 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
4744 v.AddArg2(x, mem)
4745 return true
4746 }
4747
4748
4749 for {
4750 kind := auxIntToInt64(v.AuxInt)
4751 if v_0.Op != OpRISCV64MOVDconst {
4752 break
4753 }
4754 c := auxIntToInt64(v_0.AuxInt)
4755 y := v_1
4756 mem := v_2
4757 v.reset(OpRISCV64LoweredPanicBoundsCR)
4758 v.AuxInt = int64ToAuxInt(kind)
4759 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
4760 v.AddArg2(y, mem)
4761 return true
4762 }
4763 return false
4764 }
4765 func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
4766 v_1 := v.Args[1]
4767 v_0 := v.Args[0]
4768 b := v.Block
4769 config := b.Func.Config
4770
4771
4772
4773 for {
4774 off1 := auxIntToInt32(v.AuxInt)
4775 sym1 := auxToSym(v.Aux)
4776 if v_0.Op != OpRISCV64MOVaddr {
4777 break
4778 }
4779 off2 := auxIntToInt32(v_0.AuxInt)
4780 sym2 := auxToSym(v_0.Aux)
4781 base := v_0.Args[0]
4782 mem := v_1
4783 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4784 break
4785 }
4786 v.reset(OpRISCV64MOVBUload)
4787 v.AuxInt = int32ToAuxInt(off1 + off2)
4788 v.Aux = symToAux(mergeSym(sym1, sym2))
4789 v.AddArg2(base, mem)
4790 return true
4791 }
4792
4793
4794
4795 for {
4796 off1 := auxIntToInt32(v.AuxInt)
4797 sym := auxToSym(v.Aux)
4798 if v_0.Op != OpRISCV64ADDI {
4799 break
4800 }
4801 off2 := auxIntToInt64(v_0.AuxInt)
4802 base := v_0.Args[0]
4803 mem := v_1
4804 if !(is32Bit(int64(off1) + off2)) {
4805 break
4806 }
4807 v.reset(OpRISCV64MOVBUload)
4808 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4809 v.Aux = symToAux(sym)
4810 v.AddArg2(base, mem)
4811 return true
4812 }
4813
4814
4815
4816 for {
4817 off := auxIntToInt32(v.AuxInt)
4818 sym := auxToSym(v.Aux)
4819 ptr1 := v_0
4820 if v_1.Op != OpRISCV64MOVBstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
4821 break
4822 }
4823 x := v_1.Args[1]
4824 ptr2 := v_1.Args[0]
4825 if !(isSamePtr(ptr1, ptr2)) {
4826 break
4827 }
4828 v.reset(OpRISCV64MOVBUreg)
4829 v.AddArg(x)
4830 return true
4831 }
4832 return false
4833 }
4834 func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
4835 v_0 := v.Args[0]
4836 b := v.Block
4837
4838
4839 for {
4840 x := v_0
4841 if x.Op != OpRISCV64FLES {
4842 break
4843 }
4844 v.copyOf(x)
4845 return true
4846 }
4847
4848
4849 for {
4850 x := v_0
4851 if x.Op != OpRISCV64FLTS {
4852 break
4853 }
4854 v.copyOf(x)
4855 return true
4856 }
4857
4858
4859 for {
4860 x := v_0
4861 if x.Op != OpRISCV64FEQS {
4862 break
4863 }
4864 v.copyOf(x)
4865 return true
4866 }
4867
4868
4869 for {
4870 x := v_0
4871 if x.Op != OpRISCV64FNES {
4872 break
4873 }
4874 v.copyOf(x)
4875 return true
4876 }
4877
4878
4879 for {
4880 x := v_0
4881 if x.Op != OpRISCV64FLED {
4882 break
4883 }
4884 v.copyOf(x)
4885 return true
4886 }
4887
4888
4889 for {
4890 x := v_0
4891 if x.Op != OpRISCV64FLTD {
4892 break
4893 }
4894 v.copyOf(x)
4895 return true
4896 }
4897
4898
4899 for {
4900 x := v_0
4901 if x.Op != OpRISCV64FEQD {
4902 break
4903 }
4904 v.copyOf(x)
4905 return true
4906 }
4907
4908
4909 for {
4910 x := v_0
4911 if x.Op != OpRISCV64FNED {
4912 break
4913 }
4914 v.copyOf(x)
4915 return true
4916 }
4917
4918
4919 for {
4920 x := v_0
4921 if x.Op != OpRISCV64SEQZ {
4922 break
4923 }
4924 v.copyOf(x)
4925 return true
4926 }
4927
4928
4929 for {
4930 x := v_0
4931 if x.Op != OpRISCV64SNEZ {
4932 break
4933 }
4934 v.copyOf(x)
4935 return true
4936 }
4937
4938
4939 for {
4940 x := v_0
4941 if x.Op != OpRISCV64SLT {
4942 break
4943 }
4944 v.copyOf(x)
4945 return true
4946 }
4947
4948
4949 for {
4950 x := v_0
4951 if x.Op != OpRISCV64SLTU {
4952 break
4953 }
4954 v.copyOf(x)
4955 return true
4956 }
4957
4958
4959
4960 for {
4961 x := v_0
4962 if x.Op != OpRISCV64ANDI {
4963 break
4964 }
4965 c := auxIntToInt64(x.AuxInt)
4966 if !(c >= 0 && int64(uint8(c)) == c) {
4967 break
4968 }
4969 v.copyOf(x)
4970 return true
4971 }
4972
4973
4974
4975 for {
4976 if v_0.Op != OpRISCV64ANDI {
4977 break
4978 }
4979 c := auxIntToInt64(v_0.AuxInt)
4980 x := v_0.Args[0]
4981 if !(c < 0) {
4982 break
4983 }
4984 v.reset(OpRISCV64ANDI)
4985 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
4986 v.AddArg(x)
4987 return true
4988 }
4989
4990
4991 for {
4992 if v_0.Op != OpRISCV64MOVDconst {
4993 break
4994 }
4995 c := auxIntToInt64(v_0.AuxInt)
4996 v.reset(OpRISCV64MOVDconst)
4997 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
4998 return true
4999 }
5000
5001
5002 for {
5003 x := v_0
5004 if x.Op != OpRISCV64MOVBUload {
5005 break
5006 }
5007 v.reset(OpRISCV64MOVDreg)
5008 v.AddArg(x)
5009 return true
5010 }
5011
5012
5013 for {
5014 x := v_0
5015 if x.Op != OpSelect0 {
5016 break
5017 }
5018 x_0 := x.Args[0]
5019 if x_0.Op != OpRISCV64LoweredAtomicLoad8 {
5020 break
5021 }
5022 v.reset(OpRISCV64MOVDreg)
5023 v.AddArg(x)
5024 return true
5025 }
5026
5027
5028 for {
5029 x := v_0
5030 if x.Op != OpSelect0 {
5031 break
5032 }
5033 x_0 := x.Args[0]
5034 if x_0.Op != OpRISCV64LoweredAtomicCas32 {
5035 break
5036 }
5037 v.reset(OpRISCV64MOVDreg)
5038 v.AddArg(x)
5039 return true
5040 }
5041
5042
5043 for {
5044 x := v_0
5045 if x.Op != OpSelect0 {
5046 break
5047 }
5048 x_0 := x.Args[0]
5049 if x_0.Op != OpRISCV64LoweredAtomicCas64 {
5050 break
5051 }
5052 v.reset(OpRISCV64MOVDreg)
5053 v.AddArg(x)
5054 return true
5055 }
5056
5057
5058 for {
5059 x := v_0
5060 if x.Op != OpRISCV64MOVBUreg {
5061 break
5062 }
5063 v.reset(OpRISCV64MOVDreg)
5064 v.AddArg(x)
5065 return true
5066 }
5067
5068
5069
5070 for {
5071 t := v.Type
5072 x := v_0
5073 if x.Op != OpRISCV64MOVBload {
5074 break
5075 }
5076 off := auxIntToInt32(x.AuxInt)
5077 sym := auxToSym(x.Aux)
5078 mem := x.Args[1]
5079 ptr := x.Args[0]
5080 if !(x.Uses == 1 && clobber(x)) {
5081 break
5082 }
5083 b = x.Block
5084 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBUload, t)
5085 v.copyOf(v0)
5086 v0.AuxInt = int32ToAuxInt(off)
5087 v0.Aux = symToAux(sym)
5088 v0.AddArg2(ptr, mem)
5089 return true
5090 }
5091 return false
5092 }
5093 func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
5094 v_1 := v.Args[1]
5095 v_0 := v.Args[0]
5096 b := v.Block
5097 config := b.Func.Config
5098
5099
5100
5101 for {
5102 off1 := auxIntToInt32(v.AuxInt)
5103 sym1 := auxToSym(v.Aux)
5104 if v_0.Op != OpRISCV64MOVaddr {
5105 break
5106 }
5107 off2 := auxIntToInt32(v_0.AuxInt)
5108 sym2 := auxToSym(v_0.Aux)
5109 base := v_0.Args[0]
5110 mem := v_1
5111 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5112 break
5113 }
5114 v.reset(OpRISCV64MOVBload)
5115 v.AuxInt = int32ToAuxInt(off1 + off2)
5116 v.Aux = symToAux(mergeSym(sym1, sym2))
5117 v.AddArg2(base, mem)
5118 return true
5119 }
5120
5121
5122
5123 for {
5124 off1 := auxIntToInt32(v.AuxInt)
5125 sym := auxToSym(v.Aux)
5126 if v_0.Op != OpRISCV64ADDI {
5127 break
5128 }
5129 off2 := auxIntToInt64(v_0.AuxInt)
5130 base := v_0.Args[0]
5131 mem := v_1
5132 if !(is32Bit(int64(off1) + off2)) {
5133 break
5134 }
5135 v.reset(OpRISCV64MOVBload)
5136 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5137 v.Aux = symToAux(sym)
5138 v.AddArg2(base, mem)
5139 return true
5140 }
5141
5142
5143
5144 for {
5145 off := auxIntToInt32(v.AuxInt)
5146 sym := auxToSym(v.Aux)
5147 ptr1 := v_0
5148 if v_1.Op != OpRISCV64MOVBstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5149 break
5150 }
5151 x := v_1.Args[1]
5152 ptr2 := v_1.Args[0]
5153 if !(isSamePtr(ptr1, ptr2)) {
5154 break
5155 }
5156 v.reset(OpRISCV64MOVBreg)
5157 v.AddArg(x)
5158 return true
5159 }
5160 return false
5161 }
5162 func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
5163 v_0 := v.Args[0]
5164 b := v.Block
5165
5166
5167
5168 for {
5169 x := v_0
5170 if x.Op != OpRISCV64ANDI {
5171 break
5172 }
5173 c := auxIntToInt64(x.AuxInt)
5174 if !(c >= 0 && int64(int8(c)) == c) {
5175 break
5176 }
5177 v.copyOf(x)
5178 return true
5179 }
5180
5181
5182 for {
5183 if v_0.Op != OpRISCV64MOVDconst {
5184 break
5185 }
5186 c := auxIntToInt64(v_0.AuxInt)
5187 v.reset(OpRISCV64MOVDconst)
5188 v.AuxInt = int64ToAuxInt(int64(int8(c)))
5189 return true
5190 }
5191
5192
5193 for {
5194 x := v_0
5195 if x.Op != OpRISCV64MOVBload {
5196 break
5197 }
5198 v.reset(OpRISCV64MOVDreg)
5199 v.AddArg(x)
5200 return true
5201 }
5202
5203
5204 for {
5205 x := v_0
5206 if x.Op != OpRISCV64MOVBreg {
5207 break
5208 }
5209 v.reset(OpRISCV64MOVDreg)
5210 v.AddArg(x)
5211 return true
5212 }
5213
5214
5215
5216 for {
5217 t := v.Type
5218 x := v_0
5219 if x.Op != OpRISCV64MOVBUload {
5220 break
5221 }
5222 off := auxIntToInt32(x.AuxInt)
5223 sym := auxToSym(x.Aux)
5224 mem := x.Args[1]
5225 ptr := x.Args[0]
5226 if !(x.Uses == 1 && clobber(x)) {
5227 break
5228 }
5229 b = x.Block
5230 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBload, t)
5231 v.copyOf(v0)
5232 v0.AuxInt = int32ToAuxInt(off)
5233 v0.Aux = symToAux(sym)
5234 v0.AddArg2(ptr, mem)
5235 return true
5236 }
5237 return false
5238 }
5239 func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
5240 v_2 := v.Args[2]
5241 v_1 := v.Args[1]
5242 v_0 := v.Args[0]
5243 b := v.Block
5244 config := b.Func.Config
5245
5246
5247
5248 for {
5249 off1 := auxIntToInt32(v.AuxInt)
5250 sym1 := auxToSym(v.Aux)
5251 if v_0.Op != OpRISCV64MOVaddr {
5252 break
5253 }
5254 off2 := auxIntToInt32(v_0.AuxInt)
5255 sym2 := auxToSym(v_0.Aux)
5256 base := v_0.Args[0]
5257 val := v_1
5258 mem := v_2
5259 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5260 break
5261 }
5262 v.reset(OpRISCV64MOVBstore)
5263 v.AuxInt = int32ToAuxInt(off1 + off2)
5264 v.Aux = symToAux(mergeSym(sym1, sym2))
5265 v.AddArg3(base, val, mem)
5266 return true
5267 }
5268
5269
5270
5271 for {
5272 off1 := auxIntToInt32(v.AuxInt)
5273 sym := auxToSym(v.Aux)
5274 if v_0.Op != OpRISCV64ADDI {
5275 break
5276 }
5277 off2 := auxIntToInt64(v_0.AuxInt)
5278 base := v_0.Args[0]
5279 val := v_1
5280 mem := v_2
5281 if !(is32Bit(int64(off1) + off2)) {
5282 break
5283 }
5284 v.reset(OpRISCV64MOVBstore)
5285 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5286 v.Aux = symToAux(sym)
5287 v.AddArg3(base, val, mem)
5288 return true
5289 }
5290
5291
5292 for {
5293 off := auxIntToInt32(v.AuxInt)
5294 sym := auxToSym(v.Aux)
5295 ptr := v_0
5296 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5297 break
5298 }
5299 mem := v_2
5300 v.reset(OpRISCV64MOVBstorezero)
5301 v.AuxInt = int32ToAuxInt(off)
5302 v.Aux = symToAux(sym)
5303 v.AddArg2(ptr, mem)
5304 return true
5305 }
5306
5307
5308 for {
5309 off := auxIntToInt32(v.AuxInt)
5310 sym := auxToSym(v.Aux)
5311 ptr := v_0
5312 if v_1.Op != OpRISCV64MOVBreg {
5313 break
5314 }
5315 x := v_1.Args[0]
5316 mem := v_2
5317 v.reset(OpRISCV64MOVBstore)
5318 v.AuxInt = int32ToAuxInt(off)
5319 v.Aux = symToAux(sym)
5320 v.AddArg3(ptr, x, mem)
5321 return true
5322 }
5323
5324
5325 for {
5326 off := auxIntToInt32(v.AuxInt)
5327 sym := auxToSym(v.Aux)
5328 ptr := v_0
5329 if v_1.Op != OpRISCV64MOVHreg {
5330 break
5331 }
5332 x := v_1.Args[0]
5333 mem := v_2
5334 v.reset(OpRISCV64MOVBstore)
5335 v.AuxInt = int32ToAuxInt(off)
5336 v.Aux = symToAux(sym)
5337 v.AddArg3(ptr, x, mem)
5338 return true
5339 }
5340
5341
5342 for {
5343 off := auxIntToInt32(v.AuxInt)
5344 sym := auxToSym(v.Aux)
5345 ptr := v_0
5346 if v_1.Op != OpRISCV64MOVWreg {
5347 break
5348 }
5349 x := v_1.Args[0]
5350 mem := v_2
5351 v.reset(OpRISCV64MOVBstore)
5352 v.AuxInt = int32ToAuxInt(off)
5353 v.Aux = symToAux(sym)
5354 v.AddArg3(ptr, x, mem)
5355 return true
5356 }
5357
5358
5359 for {
5360 off := auxIntToInt32(v.AuxInt)
5361 sym := auxToSym(v.Aux)
5362 ptr := v_0
5363 if v_1.Op != OpRISCV64MOVBUreg {
5364 break
5365 }
5366 x := v_1.Args[0]
5367 mem := v_2
5368 v.reset(OpRISCV64MOVBstore)
5369 v.AuxInt = int32ToAuxInt(off)
5370 v.Aux = symToAux(sym)
5371 v.AddArg3(ptr, x, mem)
5372 return true
5373 }
5374
5375
5376 for {
5377 off := auxIntToInt32(v.AuxInt)
5378 sym := auxToSym(v.Aux)
5379 ptr := v_0
5380 if v_1.Op != OpRISCV64MOVHUreg {
5381 break
5382 }
5383 x := v_1.Args[0]
5384 mem := v_2
5385 v.reset(OpRISCV64MOVBstore)
5386 v.AuxInt = int32ToAuxInt(off)
5387 v.Aux = symToAux(sym)
5388 v.AddArg3(ptr, x, mem)
5389 return true
5390 }
5391
5392
5393 for {
5394 off := auxIntToInt32(v.AuxInt)
5395 sym := auxToSym(v.Aux)
5396 ptr := v_0
5397 if v_1.Op != OpRISCV64MOVWUreg {
5398 break
5399 }
5400 x := v_1.Args[0]
5401 mem := v_2
5402 v.reset(OpRISCV64MOVBstore)
5403 v.AuxInt = int32ToAuxInt(off)
5404 v.Aux = symToAux(sym)
5405 v.AddArg3(ptr, x, mem)
5406 return true
5407 }
5408 return false
5409 }
5410 func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
5411 v_1 := v.Args[1]
5412 v_0 := v.Args[0]
5413 b := v.Block
5414 config := b.Func.Config
5415
5416
5417
5418 for {
5419 off1 := auxIntToInt32(v.AuxInt)
5420 sym1 := auxToSym(v.Aux)
5421 if v_0.Op != OpRISCV64MOVaddr {
5422 break
5423 }
5424 off2 := auxIntToInt32(v_0.AuxInt)
5425 sym2 := auxToSym(v_0.Aux)
5426 base := v_0.Args[0]
5427 mem := v_1
5428 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5429 break
5430 }
5431 v.reset(OpRISCV64MOVBstorezero)
5432 v.AuxInt = int32ToAuxInt(off1 + off2)
5433 v.Aux = symToAux(mergeSym(sym1, sym2))
5434 v.AddArg2(base, mem)
5435 return true
5436 }
5437
5438
5439
5440 for {
5441 off1 := auxIntToInt32(v.AuxInt)
5442 sym := auxToSym(v.Aux)
5443 if v_0.Op != OpRISCV64ADDI {
5444 break
5445 }
5446 off2 := auxIntToInt64(v_0.AuxInt)
5447 base := v_0.Args[0]
5448 mem := v_1
5449 if !(is32Bit(int64(off1) + off2)) {
5450 break
5451 }
5452 v.reset(OpRISCV64MOVBstorezero)
5453 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5454 v.Aux = symToAux(sym)
5455 v.AddArg2(base, mem)
5456 return true
5457 }
5458 return false
5459 }
5460 func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
5461 v_1 := v.Args[1]
5462 v_0 := v.Args[0]
5463 b := v.Block
5464 config := b.Func.Config
5465
5466
5467
5468 for {
5469 off1 := auxIntToInt32(v.AuxInt)
5470 sym1 := auxToSym(v.Aux)
5471 if v_0.Op != OpRISCV64MOVaddr {
5472 break
5473 }
5474 off2 := auxIntToInt32(v_0.AuxInt)
5475 sym2 := auxToSym(v_0.Aux)
5476 base := v_0.Args[0]
5477 mem := v_1
5478 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5479 break
5480 }
5481 v.reset(OpRISCV64MOVDload)
5482 v.AuxInt = int32ToAuxInt(off1 + off2)
5483 v.Aux = symToAux(mergeSym(sym1, sym2))
5484 v.AddArg2(base, mem)
5485 return true
5486 }
5487
5488
5489
5490 for {
5491 off1 := auxIntToInt32(v.AuxInt)
5492 sym := auxToSym(v.Aux)
5493 if v_0.Op != OpRISCV64ADDI {
5494 break
5495 }
5496 off2 := auxIntToInt64(v_0.AuxInt)
5497 base := v_0.Args[0]
5498 mem := v_1
5499 if !(is32Bit(int64(off1) + off2)) {
5500 break
5501 }
5502 v.reset(OpRISCV64MOVDload)
5503 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5504 v.Aux = symToAux(sym)
5505 v.AddArg2(base, mem)
5506 return true
5507 }
5508
5509
5510
5511 for {
5512 off := auxIntToInt32(v.AuxInt)
5513 sym := auxToSym(v.Aux)
5514 ptr1 := v_0
5515 if v_1.Op != OpRISCV64MOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5516 break
5517 }
5518 x := v_1.Args[1]
5519 ptr2 := v_1.Args[0]
5520 if !(isSamePtr(ptr1, ptr2)) {
5521 break
5522 }
5523 v.reset(OpRISCV64MOVDreg)
5524 v.AddArg(x)
5525 return true
5526 }
5527
5528
5529
5530 for {
5531 off := auxIntToInt32(v.AuxInt)
5532 sym := auxToSym(v.Aux)
5533 ptr1 := v_0
5534 if v_1.Op != OpRISCV64FMOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5535 break
5536 }
5537 x := v_1.Args[1]
5538 ptr2 := v_1.Args[0]
5539 if !(isSamePtr(ptr1, ptr2)) {
5540 break
5541 }
5542 v.reset(OpRISCV64FMVXD)
5543 v.AddArg(x)
5544 return true
5545 }
5546 return false
5547 }
5548 func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
5549 v_0 := v.Args[0]
5550
5551
5552 for {
5553 if v_0.Op != OpRISCV64MOVDconst {
5554 break
5555 }
5556 c := auxIntToInt64(v_0.AuxInt)
5557 v.reset(OpRISCV64MOVDconst)
5558 v.AuxInt = int64ToAuxInt(c)
5559 return true
5560 }
5561 return false
5562 }
5563 func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
5564 v_0 := v.Args[0]
5565
5566
5567
5568 for {
5569 x := v_0
5570 if !(x.Uses == 1) {
5571 break
5572 }
5573 v.reset(OpRISCV64MOVDnop)
5574 v.AddArg(x)
5575 return true
5576 }
5577 return false
5578 }
5579 func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
5580 v_2 := v.Args[2]
5581 v_1 := v.Args[1]
5582 v_0 := v.Args[0]
5583 b := v.Block
5584 config := b.Func.Config
5585
5586
5587
5588 for {
5589 off1 := auxIntToInt32(v.AuxInt)
5590 sym1 := auxToSym(v.Aux)
5591 if v_0.Op != OpRISCV64MOVaddr {
5592 break
5593 }
5594 off2 := auxIntToInt32(v_0.AuxInt)
5595 sym2 := auxToSym(v_0.Aux)
5596 base := v_0.Args[0]
5597 val := v_1
5598 mem := v_2
5599 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5600 break
5601 }
5602 v.reset(OpRISCV64MOVDstore)
5603 v.AuxInt = int32ToAuxInt(off1 + off2)
5604 v.Aux = symToAux(mergeSym(sym1, sym2))
5605 v.AddArg3(base, val, mem)
5606 return true
5607 }
5608
5609
5610
5611 for {
5612 off1 := auxIntToInt32(v.AuxInt)
5613 sym := auxToSym(v.Aux)
5614 if v_0.Op != OpRISCV64ADDI {
5615 break
5616 }
5617 off2 := auxIntToInt64(v_0.AuxInt)
5618 base := v_0.Args[0]
5619 val := v_1
5620 mem := v_2
5621 if !(is32Bit(int64(off1) + off2)) {
5622 break
5623 }
5624 v.reset(OpRISCV64MOVDstore)
5625 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5626 v.Aux = symToAux(sym)
5627 v.AddArg3(base, val, mem)
5628 return true
5629 }
5630
5631
5632 for {
5633 off := auxIntToInt32(v.AuxInt)
5634 sym := auxToSym(v.Aux)
5635 ptr := v_0
5636 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5637 break
5638 }
5639 mem := v_2
5640 v.reset(OpRISCV64MOVDstorezero)
5641 v.AuxInt = int32ToAuxInt(off)
5642 v.Aux = symToAux(sym)
5643 v.AddArg2(ptr, mem)
5644 return true
5645 }
5646 return false
5647 }
5648 func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool {
5649 v_1 := v.Args[1]
5650 v_0 := v.Args[0]
5651 b := v.Block
5652 config := b.Func.Config
5653
5654
5655
5656 for {
5657 off1 := auxIntToInt32(v.AuxInt)
5658 sym1 := auxToSym(v.Aux)
5659 if v_0.Op != OpRISCV64MOVaddr {
5660 break
5661 }
5662 off2 := auxIntToInt32(v_0.AuxInt)
5663 sym2 := auxToSym(v_0.Aux)
5664 base := v_0.Args[0]
5665 mem := v_1
5666 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5667 break
5668 }
5669 v.reset(OpRISCV64MOVDstorezero)
5670 v.AuxInt = int32ToAuxInt(off1 + off2)
5671 v.Aux = symToAux(mergeSym(sym1, sym2))
5672 v.AddArg2(base, mem)
5673 return true
5674 }
5675
5676
5677
5678 for {
5679 off1 := auxIntToInt32(v.AuxInt)
5680 sym := auxToSym(v.Aux)
5681 if v_0.Op != OpRISCV64ADDI {
5682 break
5683 }
5684 off2 := auxIntToInt64(v_0.AuxInt)
5685 base := v_0.Args[0]
5686 mem := v_1
5687 if !(is32Bit(int64(off1) + off2)) {
5688 break
5689 }
5690 v.reset(OpRISCV64MOVDstorezero)
5691 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5692 v.Aux = symToAux(sym)
5693 v.AddArg2(base, mem)
5694 return true
5695 }
5696 return false
5697 }
5698 func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
5699 v_1 := v.Args[1]
5700 v_0 := v.Args[0]
5701 b := v.Block
5702 config := b.Func.Config
5703
5704
5705
5706 for {
5707 off1 := auxIntToInt32(v.AuxInt)
5708 sym1 := auxToSym(v.Aux)
5709 if v_0.Op != OpRISCV64MOVaddr {
5710 break
5711 }
5712 off2 := auxIntToInt32(v_0.AuxInt)
5713 sym2 := auxToSym(v_0.Aux)
5714 base := v_0.Args[0]
5715 mem := v_1
5716 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5717 break
5718 }
5719 v.reset(OpRISCV64MOVHUload)
5720 v.AuxInt = int32ToAuxInt(off1 + off2)
5721 v.Aux = symToAux(mergeSym(sym1, sym2))
5722 v.AddArg2(base, mem)
5723 return true
5724 }
5725
5726
5727
5728 for {
5729 off1 := auxIntToInt32(v.AuxInt)
5730 sym := auxToSym(v.Aux)
5731 if v_0.Op != OpRISCV64ADDI {
5732 break
5733 }
5734 off2 := auxIntToInt64(v_0.AuxInt)
5735 base := v_0.Args[0]
5736 mem := v_1
5737 if !(is32Bit(int64(off1) + off2)) {
5738 break
5739 }
5740 v.reset(OpRISCV64MOVHUload)
5741 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5742 v.Aux = symToAux(sym)
5743 v.AddArg2(base, mem)
5744 return true
5745 }
5746
5747
5748
5749 for {
5750 off := auxIntToInt32(v.AuxInt)
5751 sym := auxToSym(v.Aux)
5752 ptr1 := v_0
5753 if v_1.Op != OpRISCV64MOVHstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5754 break
5755 }
5756 x := v_1.Args[1]
5757 ptr2 := v_1.Args[0]
5758 if !(isSamePtr(ptr1, ptr2)) {
5759 break
5760 }
5761 v.reset(OpRISCV64MOVHUreg)
5762 v.AddArg(x)
5763 return true
5764 }
5765 return false
5766 }
5767 func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
5768 v_0 := v.Args[0]
5769 b := v.Block
5770
5771
5772
5773 for {
5774 x := v_0
5775 if x.Op != OpRISCV64ANDI {
5776 break
5777 }
5778 c := auxIntToInt64(x.AuxInt)
5779 if !(c >= 0 && int64(uint16(c)) == c) {
5780 break
5781 }
5782 v.copyOf(x)
5783 return true
5784 }
5785
5786
5787
5788 for {
5789 if v_0.Op != OpRISCV64ANDI {
5790 break
5791 }
5792 c := auxIntToInt64(v_0.AuxInt)
5793 x := v_0.Args[0]
5794 if !(c < 0) {
5795 break
5796 }
5797 v.reset(OpRISCV64ANDI)
5798 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
5799 v.AddArg(x)
5800 return true
5801 }
5802
5803
5804 for {
5805 if v_0.Op != OpRISCV64MOVDconst {
5806 break
5807 }
5808 c := auxIntToInt64(v_0.AuxInt)
5809 v.reset(OpRISCV64MOVDconst)
5810 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
5811 return true
5812 }
5813
5814
5815 for {
5816 x := v_0
5817 if x.Op != OpRISCV64MOVBUload {
5818 break
5819 }
5820 v.reset(OpRISCV64MOVDreg)
5821 v.AddArg(x)
5822 return true
5823 }
5824
5825
5826 for {
5827 x := v_0
5828 if x.Op != OpRISCV64MOVHUload {
5829 break
5830 }
5831 v.reset(OpRISCV64MOVDreg)
5832 v.AddArg(x)
5833 return true
5834 }
5835
5836
5837 for {
5838 x := v_0
5839 if x.Op != OpRISCV64MOVBUreg {
5840 break
5841 }
5842 v.reset(OpRISCV64MOVDreg)
5843 v.AddArg(x)
5844 return true
5845 }
5846
5847
5848 for {
5849 x := v_0
5850 if x.Op != OpRISCV64MOVHUreg {
5851 break
5852 }
5853 v.reset(OpRISCV64MOVDreg)
5854 v.AddArg(x)
5855 return true
5856 }
5857
5858
5859
5860 for {
5861 t := v.Type
5862 x := v_0
5863 if x.Op != OpRISCV64MOVHload {
5864 break
5865 }
5866 off := auxIntToInt32(x.AuxInt)
5867 sym := auxToSym(x.Aux)
5868 mem := x.Args[1]
5869 ptr := x.Args[0]
5870 if !(x.Uses == 1 && clobber(x)) {
5871 break
5872 }
5873 b = x.Block
5874 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHUload, t)
5875 v.copyOf(v0)
5876 v0.AuxInt = int32ToAuxInt(off)
5877 v0.Aux = symToAux(sym)
5878 v0.AddArg2(ptr, mem)
5879 return true
5880 }
5881 return false
5882 }
5883 func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
5884 v_1 := v.Args[1]
5885 v_0 := v.Args[0]
5886 b := v.Block
5887 config := b.Func.Config
5888
5889
5890
5891 for {
5892 off1 := auxIntToInt32(v.AuxInt)
5893 sym1 := auxToSym(v.Aux)
5894 if v_0.Op != OpRISCV64MOVaddr {
5895 break
5896 }
5897 off2 := auxIntToInt32(v_0.AuxInt)
5898 sym2 := auxToSym(v_0.Aux)
5899 base := v_0.Args[0]
5900 mem := v_1
5901 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5902 break
5903 }
5904 v.reset(OpRISCV64MOVHload)
5905 v.AuxInt = int32ToAuxInt(off1 + off2)
5906 v.Aux = symToAux(mergeSym(sym1, sym2))
5907 v.AddArg2(base, mem)
5908 return true
5909 }
5910
5911
5912
5913 for {
5914 off1 := auxIntToInt32(v.AuxInt)
5915 sym := auxToSym(v.Aux)
5916 if v_0.Op != OpRISCV64ADDI {
5917 break
5918 }
5919 off2 := auxIntToInt64(v_0.AuxInt)
5920 base := v_0.Args[0]
5921 mem := v_1
5922 if !(is32Bit(int64(off1) + off2)) {
5923 break
5924 }
5925 v.reset(OpRISCV64MOVHload)
5926 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5927 v.Aux = symToAux(sym)
5928 v.AddArg2(base, mem)
5929 return true
5930 }
5931
5932
5933
5934 for {
5935 off := auxIntToInt32(v.AuxInt)
5936 sym := auxToSym(v.Aux)
5937 ptr1 := v_0
5938 if v_1.Op != OpRISCV64MOVHstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5939 break
5940 }
5941 x := v_1.Args[1]
5942 ptr2 := v_1.Args[0]
5943 if !(isSamePtr(ptr1, ptr2)) {
5944 break
5945 }
5946 v.reset(OpRISCV64MOVHreg)
5947 v.AddArg(x)
5948 return true
5949 }
5950 return false
5951 }
5952 func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
5953 v_0 := v.Args[0]
5954 b := v.Block
5955
5956
5957
5958 for {
5959 x := v_0
5960 if x.Op != OpRISCV64ANDI {
5961 break
5962 }
5963 c := auxIntToInt64(x.AuxInt)
5964 if !(c >= 0 && int64(int16(c)) == c) {
5965 break
5966 }
5967 v.copyOf(x)
5968 return true
5969 }
5970
5971
5972 for {
5973 if v_0.Op != OpRISCV64MOVDconst {
5974 break
5975 }
5976 c := auxIntToInt64(v_0.AuxInt)
5977 v.reset(OpRISCV64MOVDconst)
5978 v.AuxInt = int64ToAuxInt(int64(int16(c)))
5979 return true
5980 }
5981
5982
5983 for {
5984 x := v_0
5985 if x.Op != OpRISCV64MOVBload {
5986 break
5987 }
5988 v.reset(OpRISCV64MOVDreg)
5989 v.AddArg(x)
5990 return true
5991 }
5992
5993
5994 for {
5995 x := v_0
5996 if x.Op != OpRISCV64MOVBUload {
5997 break
5998 }
5999 v.reset(OpRISCV64MOVDreg)
6000 v.AddArg(x)
6001 return true
6002 }
6003
6004
6005 for {
6006 x := v_0
6007 if x.Op != OpRISCV64MOVHload {
6008 break
6009 }
6010 v.reset(OpRISCV64MOVDreg)
6011 v.AddArg(x)
6012 return true
6013 }
6014
6015
6016 for {
6017 x := v_0
6018 if x.Op != OpRISCV64MOVBreg {
6019 break
6020 }
6021 v.reset(OpRISCV64MOVDreg)
6022 v.AddArg(x)
6023 return true
6024 }
6025
6026
6027 for {
6028 x := v_0
6029 if x.Op != OpRISCV64MOVBUreg {
6030 break
6031 }
6032 v.reset(OpRISCV64MOVDreg)
6033 v.AddArg(x)
6034 return true
6035 }
6036
6037
6038 for {
6039 x := v_0
6040 if x.Op != OpRISCV64MOVHreg {
6041 break
6042 }
6043 v.reset(OpRISCV64MOVDreg)
6044 v.AddArg(x)
6045 return true
6046 }
6047
6048
6049
6050 for {
6051 t := v.Type
6052 x := v_0
6053 if x.Op != OpRISCV64MOVHUload {
6054 break
6055 }
6056 off := auxIntToInt32(x.AuxInt)
6057 sym := auxToSym(x.Aux)
6058 mem := x.Args[1]
6059 ptr := x.Args[0]
6060 if !(x.Uses == 1 && clobber(x)) {
6061 break
6062 }
6063 b = x.Block
6064 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHload, t)
6065 v.copyOf(v0)
6066 v0.AuxInt = int32ToAuxInt(off)
6067 v0.Aux = symToAux(sym)
6068 v0.AddArg2(ptr, mem)
6069 return true
6070 }
6071 return false
6072 }
6073 func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
6074 v_2 := v.Args[2]
6075 v_1 := v.Args[1]
6076 v_0 := v.Args[0]
6077 b := v.Block
6078 config := b.Func.Config
6079
6080
6081
6082 for {
6083 off1 := auxIntToInt32(v.AuxInt)
6084 sym1 := auxToSym(v.Aux)
6085 if v_0.Op != OpRISCV64MOVaddr {
6086 break
6087 }
6088 off2 := auxIntToInt32(v_0.AuxInt)
6089 sym2 := auxToSym(v_0.Aux)
6090 base := v_0.Args[0]
6091 val := v_1
6092 mem := v_2
6093 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6094 break
6095 }
6096 v.reset(OpRISCV64MOVHstore)
6097 v.AuxInt = int32ToAuxInt(off1 + off2)
6098 v.Aux = symToAux(mergeSym(sym1, sym2))
6099 v.AddArg3(base, val, mem)
6100 return true
6101 }
6102
6103
6104
6105 for {
6106 off1 := auxIntToInt32(v.AuxInt)
6107 sym := auxToSym(v.Aux)
6108 if v_0.Op != OpRISCV64ADDI {
6109 break
6110 }
6111 off2 := auxIntToInt64(v_0.AuxInt)
6112 base := v_0.Args[0]
6113 val := v_1
6114 mem := v_2
6115 if !(is32Bit(int64(off1) + off2)) {
6116 break
6117 }
6118 v.reset(OpRISCV64MOVHstore)
6119 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6120 v.Aux = symToAux(sym)
6121 v.AddArg3(base, val, mem)
6122 return true
6123 }
6124
6125
6126 for {
6127 off := auxIntToInt32(v.AuxInt)
6128 sym := auxToSym(v.Aux)
6129 ptr := v_0
6130 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6131 break
6132 }
6133 mem := v_2
6134 v.reset(OpRISCV64MOVHstorezero)
6135 v.AuxInt = int32ToAuxInt(off)
6136 v.Aux = symToAux(sym)
6137 v.AddArg2(ptr, mem)
6138 return true
6139 }
6140
6141
6142 for {
6143 off := auxIntToInt32(v.AuxInt)
6144 sym := auxToSym(v.Aux)
6145 ptr := v_0
6146 if v_1.Op != OpRISCV64MOVHreg {
6147 break
6148 }
6149 x := v_1.Args[0]
6150 mem := v_2
6151 v.reset(OpRISCV64MOVHstore)
6152 v.AuxInt = int32ToAuxInt(off)
6153 v.Aux = symToAux(sym)
6154 v.AddArg3(ptr, x, mem)
6155 return true
6156 }
6157
6158
6159 for {
6160 off := auxIntToInt32(v.AuxInt)
6161 sym := auxToSym(v.Aux)
6162 ptr := v_0
6163 if v_1.Op != OpRISCV64MOVWreg {
6164 break
6165 }
6166 x := v_1.Args[0]
6167 mem := v_2
6168 v.reset(OpRISCV64MOVHstore)
6169 v.AuxInt = int32ToAuxInt(off)
6170 v.Aux = symToAux(sym)
6171 v.AddArg3(ptr, x, mem)
6172 return true
6173 }
6174
6175
6176 for {
6177 off := auxIntToInt32(v.AuxInt)
6178 sym := auxToSym(v.Aux)
6179 ptr := v_0
6180 if v_1.Op != OpRISCV64MOVHUreg {
6181 break
6182 }
6183 x := v_1.Args[0]
6184 mem := v_2
6185 v.reset(OpRISCV64MOVHstore)
6186 v.AuxInt = int32ToAuxInt(off)
6187 v.Aux = symToAux(sym)
6188 v.AddArg3(ptr, x, mem)
6189 return true
6190 }
6191
6192
6193 for {
6194 off := auxIntToInt32(v.AuxInt)
6195 sym := auxToSym(v.Aux)
6196 ptr := v_0
6197 if v_1.Op != OpRISCV64MOVWUreg {
6198 break
6199 }
6200 x := v_1.Args[0]
6201 mem := v_2
6202 v.reset(OpRISCV64MOVHstore)
6203 v.AuxInt = int32ToAuxInt(off)
6204 v.Aux = symToAux(sym)
6205 v.AddArg3(ptr, x, mem)
6206 return true
6207 }
6208 return false
6209 }
6210 func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool {
6211 v_1 := v.Args[1]
6212 v_0 := v.Args[0]
6213 b := v.Block
6214 config := b.Func.Config
6215
6216
6217
6218 for {
6219 off1 := auxIntToInt32(v.AuxInt)
6220 sym1 := auxToSym(v.Aux)
6221 if v_0.Op != OpRISCV64MOVaddr {
6222 break
6223 }
6224 off2 := auxIntToInt32(v_0.AuxInt)
6225 sym2 := auxToSym(v_0.Aux)
6226 base := v_0.Args[0]
6227 mem := v_1
6228 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6229 break
6230 }
6231 v.reset(OpRISCV64MOVHstorezero)
6232 v.AuxInt = int32ToAuxInt(off1 + off2)
6233 v.Aux = symToAux(mergeSym(sym1, sym2))
6234 v.AddArg2(base, mem)
6235 return true
6236 }
6237
6238
6239
6240 for {
6241 off1 := auxIntToInt32(v.AuxInt)
6242 sym := auxToSym(v.Aux)
6243 if v_0.Op != OpRISCV64ADDI {
6244 break
6245 }
6246 off2 := auxIntToInt64(v_0.AuxInt)
6247 base := v_0.Args[0]
6248 mem := v_1
6249 if !(is32Bit(int64(off1) + off2)) {
6250 break
6251 }
6252 v.reset(OpRISCV64MOVHstorezero)
6253 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6254 v.Aux = symToAux(sym)
6255 v.AddArg2(base, mem)
6256 return true
6257 }
6258 return false
6259 }
6260 func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
6261 v_1 := v.Args[1]
6262 v_0 := v.Args[0]
6263 b := v.Block
6264 config := b.Func.Config
6265 typ := &b.Func.Config.Types
6266
6267
6268
6269 for {
6270 off1 := auxIntToInt32(v.AuxInt)
6271 sym1 := auxToSym(v.Aux)
6272 if v_0.Op != OpRISCV64MOVaddr {
6273 break
6274 }
6275 off2 := auxIntToInt32(v_0.AuxInt)
6276 sym2 := auxToSym(v_0.Aux)
6277 base := v_0.Args[0]
6278 mem := v_1
6279 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6280 break
6281 }
6282 v.reset(OpRISCV64MOVWUload)
6283 v.AuxInt = int32ToAuxInt(off1 + off2)
6284 v.Aux = symToAux(mergeSym(sym1, sym2))
6285 v.AddArg2(base, mem)
6286 return true
6287 }
6288
6289
6290
6291 for {
6292 off1 := auxIntToInt32(v.AuxInt)
6293 sym := auxToSym(v.Aux)
6294 if v_0.Op != OpRISCV64ADDI {
6295 break
6296 }
6297 off2 := auxIntToInt64(v_0.AuxInt)
6298 base := v_0.Args[0]
6299 mem := v_1
6300 if !(is32Bit(int64(off1) + off2)) {
6301 break
6302 }
6303 v.reset(OpRISCV64MOVWUload)
6304 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6305 v.Aux = symToAux(sym)
6306 v.AddArg2(base, mem)
6307 return true
6308 }
6309
6310
6311
6312 for {
6313 off := auxIntToInt32(v.AuxInt)
6314 sym := auxToSym(v.Aux)
6315 ptr1 := v_0
6316 if v_1.Op != OpRISCV64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6317 break
6318 }
6319 x := v_1.Args[1]
6320 ptr2 := v_1.Args[0]
6321 if !(isSamePtr(ptr1, ptr2)) {
6322 break
6323 }
6324 v.reset(OpRISCV64MOVWUreg)
6325 v.AddArg(x)
6326 return true
6327 }
6328
6329
6330
6331 for {
6332 off := auxIntToInt32(v.AuxInt)
6333 sym := auxToSym(v.Aux)
6334 ptr1 := v_0
6335 if v_1.Op != OpRISCV64FMOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6336 break
6337 }
6338 x := v_1.Args[1]
6339 ptr2 := v_1.Args[0]
6340 if !(isSamePtr(ptr1, ptr2)) {
6341 break
6342 }
6343 v.reset(OpRISCV64MOVWUreg)
6344 v0 := b.NewValue0(v_1.Pos, OpRISCV64FMVXS, typ.Int32)
6345 v0.AddArg(x)
6346 v.AddArg(v0)
6347 return true
6348 }
6349 return false
6350 }
6351 func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
6352 v_0 := v.Args[0]
6353 b := v.Block
6354 typ := &b.Func.Config.Types
6355
6356
6357
6358 for {
6359 x := v_0
6360 if x.Op != OpRISCV64ANDI {
6361 break
6362 }
6363 c := auxIntToInt64(x.AuxInt)
6364 if !(c >= 0 && int64(uint32(c)) == c) {
6365 break
6366 }
6367 v.copyOf(x)
6368 return true
6369 }
6370
6371
6372
6373 for {
6374 if v_0.Op != OpRISCV64ANDI {
6375 break
6376 }
6377 c := auxIntToInt64(v_0.AuxInt)
6378 x := v_0.Args[0]
6379 if !(c < 0) {
6380 break
6381 }
6382 v.reset(OpRISCV64AND)
6383 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6384 v0.AuxInt = int64ToAuxInt(int64(uint32(c)))
6385 v.AddArg2(v0, x)
6386 return true
6387 }
6388
6389
6390 for {
6391 if v_0.Op != OpRISCV64MOVDconst {
6392 break
6393 }
6394 c := auxIntToInt64(v_0.AuxInt)
6395 v.reset(OpRISCV64MOVDconst)
6396 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
6397 return true
6398 }
6399
6400
6401 for {
6402 x := v_0
6403 if x.Op != OpRISCV64MOVBUload {
6404 break
6405 }
6406 v.reset(OpRISCV64MOVDreg)
6407 v.AddArg(x)
6408 return true
6409 }
6410
6411
6412 for {
6413 x := v_0
6414 if x.Op != OpRISCV64MOVHUload {
6415 break
6416 }
6417 v.reset(OpRISCV64MOVDreg)
6418 v.AddArg(x)
6419 return true
6420 }
6421
6422
6423 for {
6424 x := v_0
6425 if x.Op != OpRISCV64MOVWUload {
6426 break
6427 }
6428 v.reset(OpRISCV64MOVDreg)
6429 v.AddArg(x)
6430 return true
6431 }
6432
6433
6434 for {
6435 x := v_0
6436 if x.Op != OpRISCV64MOVBUreg {
6437 break
6438 }
6439 v.reset(OpRISCV64MOVDreg)
6440 v.AddArg(x)
6441 return true
6442 }
6443
6444
6445 for {
6446 x := v_0
6447 if x.Op != OpRISCV64MOVHUreg {
6448 break
6449 }
6450 v.reset(OpRISCV64MOVDreg)
6451 v.AddArg(x)
6452 return true
6453 }
6454
6455
6456 for {
6457 x := v_0
6458 if x.Op != OpRISCV64MOVWUreg {
6459 break
6460 }
6461 v.reset(OpRISCV64MOVDreg)
6462 v.AddArg(x)
6463 return true
6464 }
6465
6466
6467
6468 for {
6469 t := v.Type
6470 x := v_0
6471 if x.Op != OpRISCV64MOVWload {
6472 break
6473 }
6474 off := auxIntToInt32(x.AuxInt)
6475 sym := auxToSym(x.Aux)
6476 mem := x.Args[1]
6477 ptr := x.Args[0]
6478 if !(x.Uses == 1 && clobber(x)) {
6479 break
6480 }
6481 b = x.Block
6482 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWUload, t)
6483 v.copyOf(v0)
6484 v0.AuxInt = int32ToAuxInt(off)
6485 v0.Aux = symToAux(sym)
6486 v0.AddArg2(ptr, mem)
6487 return true
6488 }
6489 return false
6490 }
6491 func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
6492 v_1 := v.Args[1]
6493 v_0 := v.Args[0]
6494 b := v.Block
6495 config := b.Func.Config
6496
6497
6498
6499 for {
6500 off1 := auxIntToInt32(v.AuxInt)
6501 sym1 := auxToSym(v.Aux)
6502 if v_0.Op != OpRISCV64MOVaddr {
6503 break
6504 }
6505 off2 := auxIntToInt32(v_0.AuxInt)
6506 sym2 := auxToSym(v_0.Aux)
6507 base := v_0.Args[0]
6508 mem := v_1
6509 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6510 break
6511 }
6512 v.reset(OpRISCV64MOVWload)
6513 v.AuxInt = int32ToAuxInt(off1 + off2)
6514 v.Aux = symToAux(mergeSym(sym1, sym2))
6515 v.AddArg2(base, mem)
6516 return true
6517 }
6518
6519
6520
6521 for {
6522 off1 := auxIntToInt32(v.AuxInt)
6523 sym := auxToSym(v.Aux)
6524 if v_0.Op != OpRISCV64ADDI {
6525 break
6526 }
6527 off2 := auxIntToInt64(v_0.AuxInt)
6528 base := v_0.Args[0]
6529 mem := v_1
6530 if !(is32Bit(int64(off1) + off2)) {
6531 break
6532 }
6533 v.reset(OpRISCV64MOVWload)
6534 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6535 v.Aux = symToAux(sym)
6536 v.AddArg2(base, mem)
6537 return true
6538 }
6539
6540
6541
6542 for {
6543 off := auxIntToInt32(v.AuxInt)
6544 sym := auxToSym(v.Aux)
6545 ptr1 := v_0
6546 if v_1.Op != OpRISCV64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6547 break
6548 }
6549 x := v_1.Args[1]
6550 ptr2 := v_1.Args[0]
6551 if !(isSamePtr(ptr1, ptr2)) {
6552 break
6553 }
6554 v.reset(OpRISCV64MOVWreg)
6555 v.AddArg(x)
6556 return true
6557 }
6558
6559
6560
6561 for {
6562 off := auxIntToInt32(v.AuxInt)
6563 sym := auxToSym(v.Aux)
6564 ptr1 := v_0
6565 if v_1.Op != OpRISCV64FMOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6566 break
6567 }
6568 x := v_1.Args[1]
6569 ptr2 := v_1.Args[0]
6570 if !(isSamePtr(ptr1, ptr2)) {
6571 break
6572 }
6573 v.reset(OpRISCV64FMVXS)
6574 v.AddArg(x)
6575 return true
6576 }
6577 return false
6578 }
6579 func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
6580 v_0 := v.Args[0]
6581 b := v.Block
6582
6583
6584
6585 for {
6586 x := v_0
6587 if x.Op != OpRISCV64ANDI {
6588 break
6589 }
6590 c := auxIntToInt64(x.AuxInt)
6591 if !(c >= 0 && int64(int32(c)) == c) {
6592 break
6593 }
6594 v.copyOf(x)
6595 return true
6596 }
6597
6598
6599 for {
6600 if v_0.Op != OpRISCV64NEG {
6601 break
6602 }
6603 x := v_0.Args[0]
6604 v.reset(OpRISCV64NEGW)
6605 v.AddArg(x)
6606 return true
6607 }
6608
6609
6610 for {
6611 if v_0.Op != OpRISCV64MOVDconst {
6612 break
6613 }
6614 c := auxIntToInt64(v_0.AuxInt)
6615 v.reset(OpRISCV64MOVDconst)
6616 v.AuxInt = int64ToAuxInt(int64(int32(c)))
6617 return true
6618 }
6619
6620
6621 for {
6622 x := v_0
6623 if x.Op != OpRISCV64MOVBload {
6624 break
6625 }
6626 v.reset(OpRISCV64MOVDreg)
6627 v.AddArg(x)
6628 return true
6629 }
6630
6631
6632 for {
6633 x := v_0
6634 if x.Op != OpRISCV64MOVBUload {
6635 break
6636 }
6637 v.reset(OpRISCV64MOVDreg)
6638 v.AddArg(x)
6639 return true
6640 }
6641
6642
6643 for {
6644 x := v_0
6645 if x.Op != OpRISCV64MOVHload {
6646 break
6647 }
6648 v.reset(OpRISCV64MOVDreg)
6649 v.AddArg(x)
6650 return true
6651 }
6652
6653
6654 for {
6655 x := v_0
6656 if x.Op != OpRISCV64MOVHUload {
6657 break
6658 }
6659 v.reset(OpRISCV64MOVDreg)
6660 v.AddArg(x)
6661 return true
6662 }
6663
6664
6665 for {
6666 x := v_0
6667 if x.Op != OpRISCV64MOVWload {
6668 break
6669 }
6670 v.reset(OpRISCV64MOVDreg)
6671 v.AddArg(x)
6672 return true
6673 }
6674
6675
6676
6677 for {
6678 x := v_0
6679 if x.Op != OpRISCV64ADDIW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6680 break
6681 }
6682 v.reset(OpRISCV64MOVDreg)
6683 v.AddArg(x)
6684 return true
6685 }
6686
6687
6688
6689 for {
6690 x := v_0
6691 if x.Op != OpRISCV64SUBW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6692 break
6693 }
6694 v.reset(OpRISCV64MOVDreg)
6695 v.AddArg(x)
6696 return true
6697 }
6698
6699
6700
6701 for {
6702 x := v_0
6703 if x.Op != OpRISCV64NEGW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6704 break
6705 }
6706 v.reset(OpRISCV64MOVDreg)
6707 v.AddArg(x)
6708 return true
6709 }
6710
6711
6712
6713 for {
6714 x := v_0
6715 if x.Op != OpRISCV64MULW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6716 break
6717 }
6718 v.reset(OpRISCV64MOVDreg)
6719 v.AddArg(x)
6720 return true
6721 }
6722
6723
6724
6725 for {
6726 x := v_0
6727 if x.Op != OpRISCV64DIVW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6728 break
6729 }
6730 v.reset(OpRISCV64MOVDreg)
6731 v.AddArg(x)
6732 return true
6733 }
6734
6735
6736
6737 for {
6738 x := v_0
6739 if x.Op != OpRISCV64DIVUW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6740 break
6741 }
6742 v.reset(OpRISCV64MOVDreg)
6743 v.AddArg(x)
6744 return true
6745 }
6746
6747
6748
6749 for {
6750 x := v_0
6751 if x.Op != OpRISCV64REMW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6752 break
6753 }
6754 v.reset(OpRISCV64MOVDreg)
6755 v.AddArg(x)
6756 return true
6757 }
6758
6759
6760
6761 for {
6762 x := v_0
6763 if x.Op != OpRISCV64REMUW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6764 break
6765 }
6766 v.reset(OpRISCV64MOVDreg)
6767 v.AddArg(x)
6768 return true
6769 }
6770
6771
6772
6773 for {
6774 x := v_0
6775 if x.Op != OpRISCV64ROLW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6776 break
6777 }
6778 v.reset(OpRISCV64MOVDreg)
6779 v.AddArg(x)
6780 return true
6781 }
6782
6783
6784
6785 for {
6786 x := v_0
6787 if x.Op != OpRISCV64RORW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6788 break
6789 }
6790 v.reset(OpRISCV64MOVDreg)
6791 v.AddArg(x)
6792 return true
6793 }
6794
6795
6796
6797 for {
6798 x := v_0
6799 if x.Op != OpRISCV64RORIW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6800 break
6801 }
6802 v.reset(OpRISCV64MOVDreg)
6803 v.AddArg(x)
6804 return true
6805 }
6806
6807
6808 for {
6809 x := v_0
6810 if x.Op != OpRISCV64MOVBreg {
6811 break
6812 }
6813 v.reset(OpRISCV64MOVDreg)
6814 v.AddArg(x)
6815 return true
6816 }
6817
6818
6819 for {
6820 x := v_0
6821 if x.Op != OpRISCV64MOVBUreg {
6822 break
6823 }
6824 v.reset(OpRISCV64MOVDreg)
6825 v.AddArg(x)
6826 return true
6827 }
6828
6829
6830 for {
6831 x := v_0
6832 if x.Op != OpRISCV64MOVHreg {
6833 break
6834 }
6835 v.reset(OpRISCV64MOVDreg)
6836 v.AddArg(x)
6837 return true
6838 }
6839
6840
6841 for {
6842 x := v_0
6843 if x.Op != OpRISCV64MOVWreg {
6844 break
6845 }
6846 v.reset(OpRISCV64MOVDreg)
6847 v.AddArg(x)
6848 return true
6849 }
6850
6851
6852
6853 for {
6854 t := v.Type
6855 x := v_0
6856 if x.Op != OpRISCV64MOVWUload {
6857 break
6858 }
6859 off := auxIntToInt32(x.AuxInt)
6860 sym := auxToSym(x.Aux)
6861 mem := x.Args[1]
6862 ptr := x.Args[0]
6863 if !(x.Uses == 1 && clobber(x)) {
6864 break
6865 }
6866 b = x.Block
6867 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWload, t)
6868 v.copyOf(v0)
6869 v0.AuxInt = int32ToAuxInt(off)
6870 v0.Aux = symToAux(sym)
6871 v0.AddArg2(ptr, mem)
6872 return true
6873 }
6874 return false
6875 }
6876 func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
6877 v_2 := v.Args[2]
6878 v_1 := v.Args[1]
6879 v_0 := v.Args[0]
6880 b := v.Block
6881 config := b.Func.Config
6882
6883
6884
6885 for {
6886 off1 := auxIntToInt32(v.AuxInt)
6887 sym1 := auxToSym(v.Aux)
6888 if v_0.Op != OpRISCV64MOVaddr {
6889 break
6890 }
6891 off2 := auxIntToInt32(v_0.AuxInt)
6892 sym2 := auxToSym(v_0.Aux)
6893 base := v_0.Args[0]
6894 val := v_1
6895 mem := v_2
6896 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6897 break
6898 }
6899 v.reset(OpRISCV64MOVWstore)
6900 v.AuxInt = int32ToAuxInt(off1 + off2)
6901 v.Aux = symToAux(mergeSym(sym1, sym2))
6902 v.AddArg3(base, val, mem)
6903 return true
6904 }
6905
6906
6907
6908 for {
6909 off1 := auxIntToInt32(v.AuxInt)
6910 sym := auxToSym(v.Aux)
6911 if v_0.Op != OpRISCV64ADDI {
6912 break
6913 }
6914 off2 := auxIntToInt64(v_0.AuxInt)
6915 base := v_0.Args[0]
6916 val := v_1
6917 mem := v_2
6918 if !(is32Bit(int64(off1) + off2)) {
6919 break
6920 }
6921 v.reset(OpRISCV64MOVWstore)
6922 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6923 v.Aux = symToAux(sym)
6924 v.AddArg3(base, val, mem)
6925 return true
6926 }
6927
6928
6929 for {
6930 off := auxIntToInt32(v.AuxInt)
6931 sym := auxToSym(v.Aux)
6932 ptr := v_0
6933 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6934 break
6935 }
6936 mem := v_2
6937 v.reset(OpRISCV64MOVWstorezero)
6938 v.AuxInt = int32ToAuxInt(off)
6939 v.Aux = symToAux(sym)
6940 v.AddArg2(ptr, mem)
6941 return true
6942 }
6943
6944
6945 for {
6946 off := auxIntToInt32(v.AuxInt)
6947 sym := auxToSym(v.Aux)
6948 ptr := v_0
6949 if v_1.Op != OpRISCV64MOVWreg {
6950 break
6951 }
6952 x := v_1.Args[0]
6953 mem := v_2
6954 v.reset(OpRISCV64MOVWstore)
6955 v.AuxInt = int32ToAuxInt(off)
6956 v.Aux = symToAux(sym)
6957 v.AddArg3(ptr, x, mem)
6958 return true
6959 }
6960
6961
6962 for {
6963 off := auxIntToInt32(v.AuxInt)
6964 sym := auxToSym(v.Aux)
6965 ptr := v_0
6966 if v_1.Op != OpRISCV64MOVWUreg {
6967 break
6968 }
6969 x := v_1.Args[0]
6970 mem := v_2
6971 v.reset(OpRISCV64MOVWstore)
6972 v.AuxInt = int32ToAuxInt(off)
6973 v.Aux = symToAux(sym)
6974 v.AddArg3(ptr, x, mem)
6975 return true
6976 }
6977 return false
6978 }
6979 func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
6980 v_1 := v.Args[1]
6981 v_0 := v.Args[0]
6982 b := v.Block
6983 config := b.Func.Config
6984
6985
6986
6987 for {
6988 off1 := auxIntToInt32(v.AuxInt)
6989 sym1 := auxToSym(v.Aux)
6990 if v_0.Op != OpRISCV64MOVaddr {
6991 break
6992 }
6993 off2 := auxIntToInt32(v_0.AuxInt)
6994 sym2 := auxToSym(v_0.Aux)
6995 base := v_0.Args[0]
6996 mem := v_1
6997 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6998 break
6999 }
7000 v.reset(OpRISCV64MOVWstorezero)
7001 v.AuxInt = int32ToAuxInt(off1 + off2)
7002 v.Aux = symToAux(mergeSym(sym1, sym2))
7003 v.AddArg2(base, mem)
7004 return true
7005 }
7006
7007
7008
7009 for {
7010 off1 := auxIntToInt32(v.AuxInt)
7011 sym := auxToSym(v.Aux)
7012 if v_0.Op != OpRISCV64ADDI {
7013 break
7014 }
7015 off2 := auxIntToInt64(v_0.AuxInt)
7016 base := v_0.Args[0]
7017 mem := v_1
7018 if !(is32Bit(int64(off1) + off2)) {
7019 break
7020 }
7021 v.reset(OpRISCV64MOVWstorezero)
7022 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
7023 v.Aux = symToAux(sym)
7024 v.AddArg2(base, mem)
7025 return true
7026 }
7027 return false
7028 }
7029 func rewriteValueRISCV64_OpRISCV64NEG(v *Value) bool {
7030 v_0 := v.Args[0]
7031 b := v.Block
7032
7033
7034 for {
7035 if v_0.Op != OpRISCV64SUB {
7036 break
7037 }
7038 y := v_0.Args[1]
7039 x := v_0.Args[0]
7040 v.reset(OpRISCV64SUB)
7041 v.AddArg2(y, x)
7042 return true
7043 }
7044
7045
7046
7047 for {
7048 t := v.Type
7049 s := v_0
7050 if s.Op != OpRISCV64ADDI {
7051 break
7052 }
7053 val := auxIntToInt64(s.AuxInt)
7054 s_0 := s.Args[0]
7055 if s_0.Op != OpRISCV64SUB {
7056 break
7057 }
7058 y := s_0.Args[1]
7059 x := s_0.Args[0]
7060 if !(s.Uses == 1 && is32Bit(-val)) {
7061 break
7062 }
7063 v.reset(OpRISCV64ADDI)
7064 v.AuxInt = int64ToAuxInt(-val)
7065 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, t)
7066 v0.AddArg2(y, x)
7067 v.AddArg(v0)
7068 return true
7069 }
7070
7071
7072 for {
7073 if v_0.Op != OpRISCV64NEG {
7074 break
7075 }
7076 x := v_0.Args[0]
7077 v.copyOf(x)
7078 return true
7079 }
7080
7081
7082
7083 for {
7084 s := v_0
7085 if s.Op != OpRISCV64ADDI {
7086 break
7087 }
7088 val := auxIntToInt64(s.AuxInt)
7089 s_0 := s.Args[0]
7090 if s_0.Op != OpRISCV64NEG {
7091 break
7092 }
7093 x := s_0.Args[0]
7094 if !(s.Uses == 1 && is32Bit(-val)) {
7095 break
7096 }
7097 v.reset(OpRISCV64ADDI)
7098 v.AuxInt = int64ToAuxInt(-val)
7099 v.AddArg(x)
7100 return true
7101 }
7102
7103
7104 for {
7105 if v_0.Op != OpRISCV64MOVDconst {
7106 break
7107 }
7108 x := auxIntToInt64(v_0.AuxInt)
7109 v.reset(OpRISCV64MOVDconst)
7110 v.AuxInt = int64ToAuxInt(-x)
7111 return true
7112 }
7113 return false
7114 }
7115 func rewriteValueRISCV64_OpRISCV64NEGW(v *Value) bool {
7116 v_0 := v.Args[0]
7117
7118
7119 for {
7120 if v_0.Op != OpRISCV64MOVDconst {
7121 break
7122 }
7123 x := auxIntToInt64(v_0.AuxInt)
7124 v.reset(OpRISCV64MOVDconst)
7125 v.AuxInt = int64ToAuxInt(int64(int32(-x)))
7126 return true
7127 }
7128 return false
7129 }
7130 func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
7131 v_1 := v.Args[1]
7132 v_0 := v.Args[0]
7133 b := v.Block
7134 typ := &b.Func.Config.Types
7135
7136
7137
7138 for {
7139 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7140 if v_0.Op != OpRISCV64MOVDconst {
7141 continue
7142 }
7143 val := auxIntToInt64(v_0.AuxInt)
7144 x := v_1
7145 if !(is32Bit(val)) {
7146 continue
7147 }
7148 v.reset(OpRISCV64ORI)
7149 v.AuxInt = int64ToAuxInt(val)
7150 v.AddArg(x)
7151 return true
7152 }
7153 break
7154 }
7155
7156
7157 for {
7158 x := v_0
7159 if x != v_1 {
7160 break
7161 }
7162 v.copyOf(x)
7163 return true
7164 }
7165
7166
7167 for {
7168 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7169 if v_0.Op != OpRISCV64CZEROEQZ {
7170 continue
7171 }
7172 t := v_0.Type
7173 cond := v_0.Args[1]
7174 x := v_0.Args[0]
7175 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7176 continue
7177 }
7178 _ = v_1.Args[1]
7179 v_1_0 := v_1.Args[0]
7180 if v_1_0.Op != OpRISCV64ADD {
7181 continue
7182 }
7183 _ = v_1_0.Args[1]
7184 v_1_0_0 := v_1_0.Args[0]
7185 v_1_0_1 := v_1_0.Args[1]
7186 for _i1 := 0; _i1 <= 1; _i1, v_1_0_0, v_1_0_1 = _i1+1, v_1_0_1, v_1_0_0 {
7187 if x != v_1_0_0 {
7188 continue
7189 }
7190 y := v_1_0_1
7191 if cond != v_1.Args[1] {
7192 continue
7193 }
7194 v.reset(OpRISCV64ADD)
7195 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7196 v0.AddArg2(y, cond)
7197 v.AddArg2(x, v0)
7198 return true
7199 }
7200 }
7201 break
7202 }
7203
7204
7205 for {
7206 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7207 if v_0.Op != OpRISCV64CZEROEQZ {
7208 continue
7209 }
7210 t := v_0.Type
7211 cond := v_0.Args[1]
7212 x := v_0.Args[0]
7213 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7214 continue
7215 }
7216 _ = v_1.Args[1]
7217 v_1_0 := v_1.Args[0]
7218 if v_1_0.Op != OpRISCV64SUB {
7219 continue
7220 }
7221 y := v_1_0.Args[1]
7222 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7223 continue
7224 }
7225 v.reset(OpRISCV64SUB)
7226 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7227 v0.AddArg2(y, cond)
7228 v.AddArg2(x, v0)
7229 return true
7230 }
7231 break
7232 }
7233
7234
7235 for {
7236 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7237 if v_0.Op != OpRISCV64CZEROEQZ {
7238 continue
7239 }
7240 t := v_0.Type
7241 cond := v_0.Args[1]
7242 x := v_0.Args[0]
7243 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7244 continue
7245 }
7246 _ = v_1.Args[1]
7247 v_1_0 := v_1.Args[0]
7248 if v_1_0.Op != OpRISCV64OR {
7249 continue
7250 }
7251 _ = v_1_0.Args[1]
7252 v_1_0_0 := v_1_0.Args[0]
7253 v_1_0_1 := v_1_0.Args[1]
7254 for _i1 := 0; _i1 <= 1; _i1, v_1_0_0, v_1_0_1 = _i1+1, v_1_0_1, v_1_0_0 {
7255 if x != v_1_0_0 {
7256 continue
7257 }
7258 y := v_1_0_1
7259 if cond != v_1.Args[1] {
7260 continue
7261 }
7262 v.reset(OpRISCV64OR)
7263 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7264 v0.AddArg2(y, cond)
7265 v.AddArg2(x, v0)
7266 return true
7267 }
7268 }
7269 break
7270 }
7271
7272
7273 for {
7274 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7275 if v_0.Op != OpRISCV64CZEROEQZ {
7276 continue
7277 }
7278 t := v_0.Type
7279 cond := v_0.Args[1]
7280 x := v_0.Args[0]
7281 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7282 continue
7283 }
7284 _ = v_1.Args[1]
7285 v_1_0 := v_1.Args[0]
7286 if v_1_0.Op != OpRISCV64XOR {
7287 continue
7288 }
7289 _ = v_1_0.Args[1]
7290 v_1_0_0 := v_1_0.Args[0]
7291 v_1_0_1 := v_1_0.Args[1]
7292 for _i1 := 0; _i1 <= 1; _i1, v_1_0_0, v_1_0_1 = _i1+1, v_1_0_1, v_1_0_0 {
7293 if x != v_1_0_0 {
7294 continue
7295 }
7296 y := v_1_0_1
7297 if cond != v_1.Args[1] {
7298 continue
7299 }
7300 v.reset(OpRISCV64XOR)
7301 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7302 v0.AddArg2(y, cond)
7303 v.AddArg2(x, v0)
7304 return true
7305 }
7306 }
7307 break
7308 }
7309
7310
7311 for {
7312 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7313 if v_0.Op != OpRISCV64CZEROEQZ {
7314 continue
7315 }
7316 t := v_0.Type
7317 cond := v_0.Args[1]
7318 x := v_0.Args[0]
7319 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7320 continue
7321 }
7322 _ = v_1.Args[1]
7323 v_1_0 := v_1.Args[0]
7324 if v_1_0.Op != OpRISCV64SUBW {
7325 continue
7326 }
7327 y := v_1_0.Args[1]
7328 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7329 continue
7330 }
7331 v.reset(OpRISCV64SUBW)
7332 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7333 v0.AddArg2(y, cond)
7334 v.AddArg2(x, v0)
7335 return true
7336 }
7337 break
7338 }
7339
7340
7341 for {
7342 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7343 if v_0.Op != OpRISCV64CZEROEQZ {
7344 continue
7345 }
7346 t := v_0.Type
7347 cond := v_0.Args[1]
7348 v_0_0 := v_0.Args[0]
7349 if v_0_0.Op != OpRISCV64ADD {
7350 continue
7351 }
7352 _ = v_0_0.Args[1]
7353 v_0_0_0 := v_0_0.Args[0]
7354 v_0_0_1 := v_0_0.Args[1]
7355 for _i1 := 0; _i1 <= 1; _i1, v_0_0_0, v_0_0_1 = _i1+1, v_0_0_1, v_0_0_0 {
7356 x := v_0_0_0
7357 y := v_0_0_1
7358 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7359 continue
7360 }
7361 _ = v_1.Args[1]
7362 if x != v_1.Args[0] || cond != v_1.Args[1] {
7363 continue
7364 }
7365 v.reset(OpRISCV64ADD)
7366 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7367 v0.AddArg2(y, cond)
7368 v.AddArg2(x, v0)
7369 return true
7370 }
7371 }
7372 break
7373 }
7374
7375
7376 for {
7377 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7378 if v_0.Op != OpRISCV64CZEROEQZ {
7379 continue
7380 }
7381 t := v_0.Type
7382 cond := v_0.Args[1]
7383 v_0_0 := v_0.Args[0]
7384 if v_0_0.Op != OpRISCV64SUB {
7385 continue
7386 }
7387 y := v_0_0.Args[1]
7388 x := v_0_0.Args[0]
7389 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7390 continue
7391 }
7392 _ = v_1.Args[1]
7393 if x != v_1.Args[0] || cond != v_1.Args[1] {
7394 continue
7395 }
7396 v.reset(OpRISCV64SUB)
7397 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7398 v0.AddArg2(y, cond)
7399 v.AddArg2(x, v0)
7400 return true
7401 }
7402 break
7403 }
7404
7405
7406 for {
7407 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7408 if v_0.Op != OpRISCV64CZEROEQZ {
7409 continue
7410 }
7411 t := v_0.Type
7412 cond := v_0.Args[1]
7413 v_0_0 := v_0.Args[0]
7414 if v_0_0.Op != OpRISCV64OR {
7415 continue
7416 }
7417 _ = v_0_0.Args[1]
7418 v_0_0_0 := v_0_0.Args[0]
7419 v_0_0_1 := v_0_0.Args[1]
7420 for _i1 := 0; _i1 <= 1; _i1, v_0_0_0, v_0_0_1 = _i1+1, v_0_0_1, v_0_0_0 {
7421 x := v_0_0_0
7422 y := v_0_0_1
7423 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7424 continue
7425 }
7426 _ = v_1.Args[1]
7427 if x != v_1.Args[0] || cond != v_1.Args[1] {
7428 continue
7429 }
7430 v.reset(OpRISCV64OR)
7431 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7432 v0.AddArg2(y, cond)
7433 v.AddArg2(x, v0)
7434 return true
7435 }
7436 }
7437 break
7438 }
7439
7440
7441 for {
7442 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7443 if v_0.Op != OpRISCV64CZEROEQZ {
7444 continue
7445 }
7446 t := v_0.Type
7447 cond := v_0.Args[1]
7448 v_0_0 := v_0.Args[0]
7449 if v_0_0.Op != OpRISCV64XOR {
7450 continue
7451 }
7452 _ = v_0_0.Args[1]
7453 v_0_0_0 := v_0_0.Args[0]
7454 v_0_0_1 := v_0_0.Args[1]
7455 for _i1 := 0; _i1 <= 1; _i1, v_0_0_0, v_0_0_1 = _i1+1, v_0_0_1, v_0_0_0 {
7456 x := v_0_0_0
7457 y := v_0_0_1
7458 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7459 continue
7460 }
7461 _ = v_1.Args[1]
7462 if x != v_1.Args[0] || cond != v_1.Args[1] {
7463 continue
7464 }
7465 v.reset(OpRISCV64XOR)
7466 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7467 v0.AddArg2(y, cond)
7468 v.AddArg2(x, v0)
7469 return true
7470 }
7471 }
7472 break
7473 }
7474
7475
7476 for {
7477 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7478 if v_0.Op != OpRISCV64CZEROEQZ {
7479 continue
7480 }
7481 t := v_0.Type
7482 cond := v_0.Args[1]
7483 v_0_0 := v_0.Args[0]
7484 if v_0_0.Op != OpRISCV64SUBW {
7485 continue
7486 }
7487 y := v_0_0.Args[1]
7488 x := v_0_0.Args[0]
7489 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7490 continue
7491 }
7492 _ = v_1.Args[1]
7493 if x != v_1.Args[0] || cond != v_1.Args[1] {
7494 continue
7495 }
7496 v.reset(OpRISCV64SUBW)
7497 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7498 v0.AddArg2(y, cond)
7499 v.AddArg2(x, v0)
7500 return true
7501 }
7502 break
7503 }
7504
7505
7506 for {
7507 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7508 x := v_0
7509 if x.Op != OpRISCV64CZEROEQZ {
7510 continue
7511 }
7512 cond := x.Args[1]
7513 z := x.Args[0]
7514 if v_1.Op != OpRISCV64CZERONEZ {
7515 continue
7516 }
7517 _ = v_1.Args[1]
7518 y := v_1.Args[0]
7519 if y.Op != OpRISCV64AND {
7520 continue
7521 }
7522 y_0 := y.Args[0]
7523 y_1 := y.Args[1]
7524 for _i1 := 0; _i1 <= 1; _i1, y_0, y_1 = _i1+1, y_1, y_0 {
7525 if z != y_0 || cond != v_1.Args[1] {
7526 continue
7527 }
7528 v.reset(OpRISCV64OR)
7529 v.AddArg2(y, x)
7530 return true
7531 }
7532 }
7533 break
7534 }
7535
7536
7537 for {
7538 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7539 if v_0.Op != OpRISCV64CZEROEQZ {
7540 continue
7541 }
7542 cond := v_0.Args[1]
7543 x := v_0.Args[0]
7544 if x.Op != OpRISCV64AND {
7545 continue
7546 }
7547 x_0 := x.Args[0]
7548 x_1 := x.Args[1]
7549 for _i1 := 0; _i1 <= 1; _i1, x_0, x_1 = _i1+1, x_1, x_0 {
7550 z := x_0
7551 y := v_1
7552 if y.Op != OpRISCV64CZERONEZ {
7553 continue
7554 }
7555 _ = y.Args[1]
7556 if z != y.Args[0] || cond != y.Args[1] {
7557 continue
7558 }
7559 v.reset(OpRISCV64OR)
7560 v.AddArg2(x, y)
7561 return true
7562 }
7563 }
7564 break
7565 }
7566
7567
7568 for {
7569 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7570 x := v_0
7571 if x.Op != OpRISCV64CZEROEQZ {
7572 continue
7573 }
7574 cond := x.Args[1]
7575 z := x.Args[0]
7576 if v_1.Op != OpRISCV64CZERONEZ {
7577 continue
7578 }
7579 _ = v_1.Args[1]
7580 y := v_1.Args[0]
7581 if y.Op != OpRISCV64ANDI {
7582 continue
7583 }
7584 if z != y.Args[0] || cond != v_1.Args[1] {
7585 continue
7586 }
7587 v.reset(OpRISCV64OR)
7588 v.AddArg2(y, x)
7589 return true
7590 }
7591 break
7592 }
7593
7594
7595 for {
7596 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7597 if v_0.Op != OpRISCV64CZEROEQZ {
7598 continue
7599 }
7600 cond := v_0.Args[1]
7601 x := v_0.Args[0]
7602 if x.Op != OpRISCV64ANDI {
7603 continue
7604 }
7605 z := x.Args[0]
7606 y := v_1
7607 if y.Op != OpRISCV64CZERONEZ {
7608 continue
7609 }
7610 _ = y.Args[1]
7611 if z != y.Args[0] || cond != y.Args[1] {
7612 continue
7613 }
7614 v.reset(OpRISCV64OR)
7615 v.AddArg2(x, y)
7616 return true
7617 }
7618 break
7619 }
7620
7621
7622 for {
7623 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7624 if v_0.Op != OpRISCV64CZEROEQZ {
7625 continue
7626 }
7627 t := v_0.Type
7628 cond := v_0.Args[1]
7629 x := v_0.Args[0]
7630 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7631 continue
7632 }
7633 _ = v_1.Args[1]
7634 v_1_0 := v_1.Args[0]
7635 if v_1_0.Op != OpRISCV64ADDI {
7636 continue
7637 }
7638 c := auxIntToInt64(v_1_0.AuxInt)
7639 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7640 continue
7641 }
7642 v.reset(OpRISCV64ADD)
7643 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7644 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7645 v1.AuxInt = int64ToAuxInt(c)
7646 v0.AddArg2(v1, cond)
7647 v.AddArg2(x, v0)
7648 return true
7649 }
7650 break
7651 }
7652
7653
7654 for {
7655 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7656 if v_0.Op != OpRISCV64CZEROEQZ {
7657 continue
7658 }
7659 t := v_0.Type
7660 cond := v_0.Args[1]
7661 x := v_0.Args[0]
7662 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7663 continue
7664 }
7665 _ = v_1.Args[1]
7666 v_1_0 := v_1.Args[0]
7667 if v_1_0.Op != OpRISCV64ORI {
7668 continue
7669 }
7670 c := auxIntToInt64(v_1_0.AuxInt)
7671 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7672 continue
7673 }
7674 v.reset(OpRISCV64OR)
7675 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7676 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7677 v1.AuxInt = int64ToAuxInt(c)
7678 v0.AddArg2(v1, cond)
7679 v.AddArg2(x, v0)
7680 return true
7681 }
7682 break
7683 }
7684
7685
7686 for {
7687 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7688 if v_0.Op != OpRISCV64CZEROEQZ {
7689 continue
7690 }
7691 t := v_0.Type
7692 cond := v_0.Args[1]
7693 x := v_0.Args[0]
7694 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7695 continue
7696 }
7697 _ = v_1.Args[1]
7698 v_1_0 := v_1.Args[0]
7699 if v_1_0.Op != OpRISCV64XORI {
7700 continue
7701 }
7702 c := auxIntToInt64(v_1_0.AuxInt)
7703 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7704 continue
7705 }
7706 v.reset(OpRISCV64XOR)
7707 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7708 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7709 v1.AuxInt = int64ToAuxInt(c)
7710 v0.AddArg2(v1, cond)
7711 v.AddArg2(x, v0)
7712 return true
7713 }
7714 break
7715 }
7716
7717
7718 for {
7719 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7720 if v_0.Op != OpRISCV64CZEROEQZ {
7721 continue
7722 }
7723 t := v_0.Type
7724 cond := v_0.Args[1]
7725 v_0_0 := v_0.Args[0]
7726 if v_0_0.Op != OpRISCV64ADDI {
7727 continue
7728 }
7729 c := auxIntToInt64(v_0_0.AuxInt)
7730 x := v_0_0.Args[0]
7731 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7732 continue
7733 }
7734 _ = v_1.Args[1]
7735 if x != v_1.Args[0] || cond != v_1.Args[1] {
7736 continue
7737 }
7738 v.reset(OpRISCV64ADD)
7739 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7740 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7741 v1.AuxInt = int64ToAuxInt(c)
7742 v0.AddArg2(v1, cond)
7743 v.AddArg2(x, v0)
7744 return true
7745 }
7746 break
7747 }
7748
7749
7750 for {
7751 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7752 if v_0.Op != OpRISCV64CZEROEQZ {
7753 continue
7754 }
7755 t := v_0.Type
7756 cond := v_0.Args[1]
7757 v_0_0 := v_0.Args[0]
7758 if v_0_0.Op != OpRISCV64ORI {
7759 continue
7760 }
7761 c := auxIntToInt64(v_0_0.AuxInt)
7762 x := v_0_0.Args[0]
7763 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7764 continue
7765 }
7766 _ = v_1.Args[1]
7767 if x != v_1.Args[0] || cond != v_1.Args[1] {
7768 continue
7769 }
7770 v.reset(OpRISCV64OR)
7771 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7772 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7773 v1.AuxInt = int64ToAuxInt(c)
7774 v0.AddArg2(v1, cond)
7775 v.AddArg2(x, v0)
7776 return true
7777 }
7778 break
7779 }
7780
7781
7782 for {
7783 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7784 if v_0.Op != OpRISCV64CZEROEQZ {
7785 continue
7786 }
7787 t := v_0.Type
7788 cond := v_0.Args[1]
7789 v_0_0 := v_0.Args[0]
7790 if v_0_0.Op != OpRISCV64XORI {
7791 continue
7792 }
7793 c := auxIntToInt64(v_0_0.AuxInt)
7794 x := v_0_0.Args[0]
7795 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7796 continue
7797 }
7798 _ = v_1.Args[1]
7799 if x != v_1.Args[0] || cond != v_1.Args[1] {
7800 continue
7801 }
7802 v.reset(OpRISCV64XOR)
7803 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7804 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7805 v1.AuxInt = int64ToAuxInt(c)
7806 v0.AddArg2(v1, cond)
7807 v.AddArg2(x, v0)
7808 return true
7809 }
7810 break
7811 }
7812 return false
7813 }
7814 func rewriteValueRISCV64_OpRISCV64ORI(v *Value) bool {
7815 v_0 := v.Args[0]
7816
7817
7818 for {
7819 if auxIntToInt64(v.AuxInt) != 0 {
7820 break
7821 }
7822 x := v_0
7823 v.copyOf(x)
7824 return true
7825 }
7826
7827
7828 for {
7829 if auxIntToInt64(v.AuxInt) != -1 {
7830 break
7831 }
7832 v.reset(OpRISCV64MOVDconst)
7833 v.AuxInt = int64ToAuxInt(-1)
7834 return true
7835 }
7836
7837
7838 for {
7839 x := auxIntToInt64(v.AuxInt)
7840 if v_0.Op != OpRISCV64MOVDconst {
7841 break
7842 }
7843 y := auxIntToInt64(v_0.AuxInt)
7844 v.reset(OpRISCV64MOVDconst)
7845 v.AuxInt = int64ToAuxInt(x | y)
7846 return true
7847 }
7848
7849
7850 for {
7851 x := auxIntToInt64(v.AuxInt)
7852 if v_0.Op != OpRISCV64ORI {
7853 break
7854 }
7855 y := auxIntToInt64(v_0.AuxInt)
7856 z := v_0.Args[0]
7857 v.reset(OpRISCV64ORI)
7858 v.AuxInt = int64ToAuxInt(x | y)
7859 v.AddArg(z)
7860 return true
7861 }
7862 return false
7863 }
7864 func rewriteValueRISCV64_OpRISCV64ORN(v *Value) bool {
7865 v_1 := v.Args[1]
7866 v_0 := v.Args[0]
7867
7868
7869 for {
7870 x := v_0
7871 if x != v_1 {
7872 break
7873 }
7874 v.reset(OpRISCV64MOVDconst)
7875 v.AuxInt = int64ToAuxInt(-1)
7876 return true
7877 }
7878 return false
7879 }
7880 func rewriteValueRISCV64_OpRISCV64ROL(v *Value) bool {
7881 v_1 := v.Args[1]
7882 v_0 := v.Args[0]
7883
7884
7885 for {
7886 x := v_0
7887 if v_1.Op != OpRISCV64MOVDconst {
7888 break
7889 }
7890 val := auxIntToInt64(v_1.AuxInt)
7891 v.reset(OpRISCV64RORI)
7892 v.AuxInt = int64ToAuxInt(-val & 63)
7893 v.AddArg(x)
7894 return true
7895 }
7896
7897
7898 for {
7899 x := v_0
7900 if v_1.Op != OpRISCV64NEG {
7901 break
7902 }
7903 y := v_1.Args[0]
7904 v.reset(OpRISCV64ROR)
7905 v.AddArg2(x, y)
7906 return true
7907 }
7908 return false
7909 }
7910 func rewriteValueRISCV64_OpRISCV64ROLW(v *Value) bool {
7911 v_1 := v.Args[1]
7912 v_0 := v.Args[0]
7913
7914
7915 for {
7916 x := v_0
7917 if v_1.Op != OpRISCV64MOVDconst {
7918 break
7919 }
7920 val := auxIntToInt64(v_1.AuxInt)
7921 v.reset(OpRISCV64RORIW)
7922 v.AuxInt = int64ToAuxInt(-val & 31)
7923 v.AddArg(x)
7924 return true
7925 }
7926
7927
7928 for {
7929 x := v_0
7930 if v_1.Op != OpRISCV64NEG {
7931 break
7932 }
7933 y := v_1.Args[0]
7934 v.reset(OpRISCV64RORW)
7935 v.AddArg2(x, y)
7936 return true
7937 }
7938 return false
7939 }
7940 func rewriteValueRISCV64_OpRISCV64ROR(v *Value) bool {
7941 v_1 := v.Args[1]
7942 v_0 := v.Args[0]
7943
7944
7945 for {
7946 x := v_0
7947 if v_1.Op != OpRISCV64MOVDconst {
7948 break
7949 }
7950 val := auxIntToInt64(v_1.AuxInt)
7951 v.reset(OpRISCV64RORI)
7952 v.AuxInt = int64ToAuxInt(val & 63)
7953 v.AddArg(x)
7954 return true
7955 }
7956 return false
7957 }
7958 func rewriteValueRISCV64_OpRISCV64RORW(v *Value) bool {
7959 v_1 := v.Args[1]
7960 v_0 := v.Args[0]
7961
7962
7963 for {
7964 x := v_0
7965 if v_1.Op != OpRISCV64MOVDconst {
7966 break
7967 }
7968 val := auxIntToInt64(v_1.AuxInt)
7969 v.reset(OpRISCV64RORIW)
7970 v.AuxInt = int64ToAuxInt(val & 31)
7971 v.AddArg(x)
7972 return true
7973 }
7974 return false
7975 }
7976 func rewriteValueRISCV64_OpRISCV64SEQZ(v *Value) bool {
7977 v_0 := v.Args[0]
7978 b := v.Block
7979 typ := &b.Func.Config.Types
7980
7981
7982 for {
7983 if v_0.Op != OpRISCV64NEG {
7984 break
7985 }
7986 x := v_0.Args[0]
7987 v.reset(OpRISCV64SEQZ)
7988 v.AddArg(x)
7989 return true
7990 }
7991
7992
7993 for {
7994 if v_0.Op != OpRISCV64SEQZ {
7995 break
7996 }
7997 x := v_0.Args[0]
7998 v.reset(OpRISCV64SNEZ)
7999 v.AddArg(x)
8000 return true
8001 }
8002
8003
8004 for {
8005 if v_0.Op != OpRISCV64SNEZ {
8006 break
8007 }
8008 x := v_0.Args[0]
8009 v.reset(OpRISCV64SEQZ)
8010 v.AddArg(x)
8011 return true
8012 }
8013
8014
8015 for {
8016 if v_0.Op != OpRISCV64ANDI {
8017 break
8018 }
8019 c := auxIntToInt64(v_0.AuxInt)
8020 v_0_0 := v_0.Args[0]
8021 if v_0_0.Op != OpRISCV64FCLASSD {
8022 break
8023 }
8024 v_0_0_0 := v_0_0.Args[0]
8025 if v_0_0_0.Op != OpRISCV64FNEGD {
8026 break
8027 }
8028 x := v_0_0_0.Args[0]
8029 v.reset(OpRISCV64SEQZ)
8030 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8031 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
8032 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8033 v1.AddArg(x)
8034 v0.AddArg(v1)
8035 v.AddArg(v0)
8036 return true
8037 }
8038
8039
8040 for {
8041 if v_0.Op != OpRISCV64ANDI {
8042 break
8043 }
8044 c := auxIntToInt64(v_0.AuxInt)
8045 v_0_0 := v_0.Args[0]
8046 if v_0_0.Op != OpRISCV64FCLASSD {
8047 break
8048 }
8049 v_0_0_0 := v_0_0.Args[0]
8050 if v_0_0_0.Op != OpRISCV64FABSD {
8051 break
8052 }
8053 x := v_0_0_0.Args[0]
8054 v.reset(OpRISCV64SEQZ)
8055 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8056 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
8057 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8058 v1.AddArg(x)
8059 v0.AddArg(v1)
8060 v.AddArg(v0)
8061 return true
8062 }
8063 return false
8064 }
8065 func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
8066 v_1 := v.Args[1]
8067 v_0 := v.Args[0]
8068
8069
8070 for {
8071 x := v_0
8072 if v_1.Op != OpRISCV64MOVDconst {
8073 break
8074 }
8075 val := auxIntToInt64(v_1.AuxInt)
8076 v.reset(OpRISCV64SLLI)
8077 v.AuxInt = int64ToAuxInt(val & 63)
8078 v.AddArg(x)
8079 return true
8080 }
8081 return false
8082 }
8083 func rewriteValueRISCV64_OpRISCV64SLLI(v *Value) bool {
8084 v_0 := v.Args[0]
8085
8086
8087
8088 for {
8089 x := auxIntToInt64(v.AuxInt)
8090 if v_0.Op != OpRISCV64MOVDconst {
8091 break
8092 }
8093 y := auxIntToInt64(v_0.AuxInt)
8094 if !(is32Bit(y << uint32(x))) {
8095 break
8096 }
8097 v.reset(OpRISCV64MOVDconst)
8098 v.AuxInt = int64ToAuxInt(y << uint32(x))
8099 return true
8100 }
8101
8102
8103
8104 for {
8105 t := v.Type
8106 c := auxIntToInt64(v.AuxInt)
8107 if v_0.Op != OpRISCV64ADD {
8108 break
8109 }
8110 x := v_0.Args[1]
8111 if x != v_0.Args[0] || !(c < t.Size()*8-1) {
8112 break
8113 }
8114 v.reset(OpRISCV64SLLI)
8115 v.AuxInt = int64ToAuxInt(c + 1)
8116 v.AddArg(x)
8117 return true
8118 }
8119
8120
8121
8122 for {
8123 t := v.Type
8124 c := auxIntToInt64(v.AuxInt)
8125 if v_0.Op != OpRISCV64ADD {
8126 break
8127 }
8128 x := v_0.Args[1]
8129 if x != v_0.Args[0] || !(c >= t.Size()*8-1) {
8130 break
8131 }
8132 v.reset(OpRISCV64MOVDconst)
8133 v.AuxInt = int64ToAuxInt(0)
8134 return true
8135 }
8136 return false
8137 }
8138 func rewriteValueRISCV64_OpRISCV64SLLW(v *Value) bool {
8139 v_1 := v.Args[1]
8140 v_0 := v.Args[0]
8141
8142
8143 for {
8144 x := v_0
8145 if v_1.Op != OpRISCV64MOVDconst {
8146 break
8147 }
8148 val := auxIntToInt64(v_1.AuxInt)
8149 v.reset(OpRISCV64SLLIW)
8150 v.AuxInt = int64ToAuxInt(val & 31)
8151 v.AddArg(x)
8152 return true
8153 }
8154 return false
8155 }
8156 func rewriteValueRISCV64_OpRISCV64SLT(v *Value) bool {
8157 v_1 := v.Args[1]
8158 v_0 := v.Args[0]
8159
8160
8161
8162 for {
8163 x := v_0
8164 if v_1.Op != OpRISCV64MOVDconst {
8165 break
8166 }
8167 val := auxIntToInt64(v_1.AuxInt)
8168 if !(is12Bit(val)) {
8169 break
8170 }
8171 v.reset(OpRISCV64SLTI)
8172 v.AuxInt = int64ToAuxInt(val)
8173 v.AddArg(x)
8174 return true
8175 }
8176
8177
8178 for {
8179 x := v_0
8180 if x != v_1 {
8181 break
8182 }
8183 v.reset(OpRISCV64MOVDconst)
8184 v.AuxInt = int64ToAuxInt(0)
8185 return true
8186 }
8187 return false
8188 }
8189 func rewriteValueRISCV64_OpRISCV64SLTI(v *Value) bool {
8190 v_0 := v.Args[0]
8191
8192
8193 for {
8194 x := auxIntToInt64(v.AuxInt)
8195 if v_0.Op != OpRISCV64MOVDconst {
8196 break
8197 }
8198 y := auxIntToInt64(v_0.AuxInt)
8199 v.reset(OpRISCV64MOVDconst)
8200 v.AuxInt = int64ToAuxInt(b2i(int64(y) < int64(x)))
8201 return true
8202 }
8203
8204
8205
8206 for {
8207 x := auxIntToInt64(v.AuxInt)
8208 if v_0.Op != OpRISCV64ANDI {
8209 break
8210 }
8211 y := auxIntToInt64(v_0.AuxInt)
8212 if !(y >= 0 && int64(y) < int64(x)) {
8213 break
8214 }
8215 v.reset(OpRISCV64MOVDconst)
8216 v.AuxInt = int64ToAuxInt(1)
8217 return true
8218 }
8219 return false
8220 }
8221 func rewriteValueRISCV64_OpRISCV64SLTIU(v *Value) bool {
8222 v_0 := v.Args[0]
8223
8224
8225 for {
8226 x := auxIntToInt64(v.AuxInt)
8227 if v_0.Op != OpRISCV64MOVDconst {
8228 break
8229 }
8230 y := auxIntToInt64(v_0.AuxInt)
8231 v.reset(OpRISCV64MOVDconst)
8232 v.AuxInt = int64ToAuxInt(b2i(uint64(y) < uint64(x)))
8233 return true
8234 }
8235
8236
8237
8238 for {
8239 x := auxIntToInt64(v.AuxInt)
8240 if v_0.Op != OpRISCV64ANDI {
8241 break
8242 }
8243 y := auxIntToInt64(v_0.AuxInt)
8244 if !(y >= 0 && uint64(y) < uint64(x)) {
8245 break
8246 }
8247 v.reset(OpRISCV64MOVDconst)
8248 v.AuxInt = int64ToAuxInt(1)
8249 return true
8250 }
8251
8252
8253
8254 for {
8255 x := auxIntToInt64(v.AuxInt)
8256 if v_0.Op != OpRISCV64ORI {
8257 break
8258 }
8259 y := auxIntToInt64(v_0.AuxInt)
8260 if !(y >= 0 && uint64(y) >= uint64(x)) {
8261 break
8262 }
8263 v.reset(OpRISCV64MOVDconst)
8264 v.AuxInt = int64ToAuxInt(0)
8265 return true
8266 }
8267 return false
8268 }
8269 func rewriteValueRISCV64_OpRISCV64SLTU(v *Value) bool {
8270 v_1 := v.Args[1]
8271 v_0 := v.Args[0]
8272
8273
8274
8275 for {
8276 x := v_0
8277 if v_1.Op != OpRISCV64MOVDconst {
8278 break
8279 }
8280 val := auxIntToInt64(v_1.AuxInt)
8281 if !(is12Bit(val)) {
8282 break
8283 }
8284 v.reset(OpRISCV64SLTIU)
8285 v.AuxInt = int64ToAuxInt(val)
8286 v.AddArg(x)
8287 return true
8288 }
8289
8290
8291 for {
8292 x := v_0
8293 if x != v_1 {
8294 break
8295 }
8296 v.reset(OpRISCV64MOVDconst)
8297 v.AuxInt = int64ToAuxInt(0)
8298 return true
8299 }
8300 return false
8301 }
8302 func rewriteValueRISCV64_OpRISCV64SNEZ(v *Value) bool {
8303 v_0 := v.Args[0]
8304 b := v.Block
8305 typ := &b.Func.Config.Types
8306
8307
8308 for {
8309 if v_0.Op != OpRISCV64NEG {
8310 break
8311 }
8312 x := v_0.Args[0]
8313 v.reset(OpRISCV64SNEZ)
8314 v.AddArg(x)
8315 return true
8316 }
8317
8318
8319 for {
8320 if v_0.Op != OpRISCV64SEQZ {
8321 break
8322 }
8323 x := v_0.Args[0]
8324 v.reset(OpRISCV64SEQZ)
8325 v.AddArg(x)
8326 return true
8327 }
8328
8329
8330 for {
8331 if v_0.Op != OpRISCV64SNEZ {
8332 break
8333 }
8334 x := v_0.Args[0]
8335 v.reset(OpRISCV64SNEZ)
8336 v.AddArg(x)
8337 return true
8338 }
8339
8340
8341 for {
8342 if v_0.Op != OpRISCV64ANDI {
8343 break
8344 }
8345 c := auxIntToInt64(v_0.AuxInt)
8346 v_0_0 := v_0.Args[0]
8347 if v_0_0.Op != OpRISCV64FCLASSD {
8348 break
8349 }
8350 v_0_0_0 := v_0_0.Args[0]
8351 if v_0_0_0.Op != OpRISCV64FNEGD {
8352 break
8353 }
8354 x := v_0_0_0.Args[0]
8355 v.reset(OpRISCV64SNEZ)
8356 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8357 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
8358 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8359 v1.AddArg(x)
8360 v0.AddArg(v1)
8361 v.AddArg(v0)
8362 return true
8363 }
8364
8365
8366 for {
8367 if v_0.Op != OpRISCV64ANDI {
8368 break
8369 }
8370 c := auxIntToInt64(v_0.AuxInt)
8371 v_0_0 := v_0.Args[0]
8372 if v_0_0.Op != OpRISCV64FCLASSD {
8373 break
8374 }
8375 v_0_0_0 := v_0_0.Args[0]
8376 if v_0_0_0.Op != OpRISCV64FABSD {
8377 break
8378 }
8379 x := v_0_0_0.Args[0]
8380 v.reset(OpRISCV64SNEZ)
8381 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8382 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
8383 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8384 v1.AddArg(x)
8385 v0.AddArg(v1)
8386 v.AddArg(v0)
8387 return true
8388 }
8389 return false
8390 }
8391 func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
8392 v_1 := v.Args[1]
8393 v_0 := v.Args[0]
8394
8395
8396 for {
8397 x := v_0
8398 if v_1.Op != OpRISCV64MOVDconst {
8399 break
8400 }
8401 val := auxIntToInt64(v_1.AuxInt)
8402 v.reset(OpRISCV64SRAI)
8403 v.AuxInt = int64ToAuxInt(val & 63)
8404 v.AddArg(x)
8405 return true
8406 }
8407 return false
8408 }
8409 func rewriteValueRISCV64_OpRISCV64SRAI(v *Value) bool {
8410 v_0 := v.Args[0]
8411 b := v.Block
8412
8413
8414
8415 for {
8416 x := auxIntToInt64(v.AuxInt)
8417 if v_0.Op != OpRISCV64MOVWreg {
8418 break
8419 }
8420 y := v_0.Args[0]
8421 if !(x >= 0 && x <= 31) {
8422 break
8423 }
8424 v.reset(OpRISCV64SRAIW)
8425 v.AuxInt = int64ToAuxInt(x)
8426 v.AddArg(y)
8427 return true
8428 }
8429
8430
8431
8432 for {
8433 t := v.Type
8434 x := auxIntToInt64(v.AuxInt)
8435 if v_0.Op != OpRISCV64MOVBreg {
8436 break
8437 }
8438 y := v_0.Args[0]
8439 if !(x >= 8) {
8440 break
8441 }
8442 v.reset(OpRISCV64SRAI)
8443 v.AuxInt = int64ToAuxInt(63)
8444 v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
8445 v0.AuxInt = int64ToAuxInt(56)
8446 v0.AddArg(y)
8447 v.AddArg(v0)
8448 return true
8449 }
8450
8451
8452
8453 for {
8454 t := v.Type
8455 x := auxIntToInt64(v.AuxInt)
8456 if v_0.Op != OpRISCV64MOVHreg {
8457 break
8458 }
8459 y := v_0.Args[0]
8460 if !(x >= 16) {
8461 break
8462 }
8463 v.reset(OpRISCV64SRAI)
8464 v.AuxInt = int64ToAuxInt(63)
8465 v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
8466 v0.AuxInt = int64ToAuxInt(48)
8467 v0.AddArg(y)
8468 v.AddArg(v0)
8469 return true
8470 }
8471
8472
8473
8474 for {
8475 x := auxIntToInt64(v.AuxInt)
8476 if v_0.Op != OpRISCV64MOVWreg {
8477 break
8478 }
8479 y := v_0.Args[0]
8480 if !(x >= 32) {
8481 break
8482 }
8483 v.reset(OpRISCV64SRAIW)
8484 v.AuxInt = int64ToAuxInt(31)
8485 v.AddArg(y)
8486 return true
8487 }
8488
8489
8490 for {
8491 x := auxIntToInt64(v.AuxInt)
8492 if v_0.Op != OpRISCV64MOVDconst {
8493 break
8494 }
8495 y := auxIntToInt64(v_0.AuxInt)
8496 v.reset(OpRISCV64MOVDconst)
8497 v.AuxInt = int64ToAuxInt(int64(y) >> uint32(x))
8498 return true
8499 }
8500 return false
8501 }
8502 func rewriteValueRISCV64_OpRISCV64SRAW(v *Value) bool {
8503 v_1 := v.Args[1]
8504 v_0 := v.Args[0]
8505
8506
8507 for {
8508 x := v_0
8509 if v_1.Op != OpRISCV64MOVDconst {
8510 break
8511 }
8512 val := auxIntToInt64(v_1.AuxInt)
8513 v.reset(OpRISCV64SRAIW)
8514 v.AuxInt = int64ToAuxInt(val & 31)
8515 v.AddArg(x)
8516 return true
8517 }
8518 return false
8519 }
8520 func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
8521 v_1 := v.Args[1]
8522 v_0 := v.Args[0]
8523
8524
8525 for {
8526 x := v_0
8527 if v_1.Op != OpRISCV64MOVDconst {
8528 break
8529 }
8530 val := auxIntToInt64(v_1.AuxInt)
8531 v.reset(OpRISCV64SRLI)
8532 v.AuxInt = int64ToAuxInt(val & 63)
8533 v.AddArg(x)
8534 return true
8535 }
8536 return false
8537 }
8538 func rewriteValueRISCV64_OpRISCV64SRLI(v *Value) bool {
8539 v_0 := v.Args[0]
8540
8541
8542
8543 for {
8544 x := auxIntToInt64(v.AuxInt)
8545 if v_0.Op != OpRISCV64MOVWUreg {
8546 break
8547 }
8548 y := v_0.Args[0]
8549 if !(x >= 0 && x <= 31) {
8550 break
8551 }
8552 v.reset(OpRISCV64SRLIW)
8553 v.AuxInt = int64ToAuxInt(x)
8554 v.AddArg(y)
8555 return true
8556 }
8557
8558
8559
8560 for {
8561 x := auxIntToInt64(v.AuxInt)
8562 if v_0.Op != OpRISCV64MOVBUreg {
8563 break
8564 }
8565 if !(x >= 8) {
8566 break
8567 }
8568 v.reset(OpRISCV64MOVDconst)
8569 v.AuxInt = int64ToAuxInt(0)
8570 return true
8571 }
8572
8573
8574
8575 for {
8576 x := auxIntToInt64(v.AuxInt)
8577 if v_0.Op != OpRISCV64MOVHUreg {
8578 break
8579 }
8580 if !(x >= 16) {
8581 break
8582 }
8583 v.reset(OpRISCV64MOVDconst)
8584 v.AuxInt = int64ToAuxInt(0)
8585 return true
8586 }
8587
8588
8589
8590 for {
8591 x := auxIntToInt64(v.AuxInt)
8592 if v_0.Op != OpRISCV64MOVWUreg {
8593 break
8594 }
8595 if !(x >= 32) {
8596 break
8597 }
8598 v.reset(OpRISCV64MOVDconst)
8599 v.AuxInt = int64ToAuxInt(0)
8600 return true
8601 }
8602
8603
8604 for {
8605 x := auxIntToInt64(v.AuxInt)
8606 if v_0.Op != OpRISCV64MOVDconst {
8607 break
8608 }
8609 y := auxIntToInt64(v_0.AuxInt)
8610 v.reset(OpRISCV64MOVDconst)
8611 v.AuxInt = int64ToAuxInt(int64(uint64(y) >> uint32(x)))
8612 return true
8613 }
8614 return false
8615 }
8616 func rewriteValueRISCV64_OpRISCV64SRLW(v *Value) bool {
8617 v_1 := v.Args[1]
8618 v_0 := v.Args[0]
8619
8620
8621 for {
8622 x := v_0
8623 if v_1.Op != OpRISCV64MOVDconst {
8624 break
8625 }
8626 val := auxIntToInt64(v_1.AuxInt)
8627 v.reset(OpRISCV64SRLIW)
8628 v.AuxInt = int64ToAuxInt(val & 31)
8629 v.AddArg(x)
8630 return true
8631 }
8632 return false
8633 }
8634 func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
8635 v_1 := v.Args[1]
8636 v_0 := v.Args[0]
8637 b := v.Block
8638
8639
8640 for {
8641 x := v_0
8642 if v_1.Op != OpRISCV64NEG {
8643 break
8644 }
8645 y := v_1.Args[0]
8646 v.reset(OpRISCV64ADD)
8647 v.AddArg2(x, y)
8648 return true
8649 }
8650
8651
8652 for {
8653 x := v_0
8654 if x != v_1 {
8655 break
8656 }
8657 v.reset(OpRISCV64MOVDconst)
8658 v.AuxInt = int64ToAuxInt(0)
8659 return true
8660 }
8661
8662
8663
8664 for {
8665 x := v_0
8666 if v_1.Op != OpRISCV64MOVDconst {
8667 break
8668 }
8669 val := auxIntToInt64(v_1.AuxInt)
8670 if !(is32Bit(-val)) {
8671 break
8672 }
8673 v.reset(OpRISCV64ADDI)
8674 v.AuxInt = int64ToAuxInt(-val)
8675 v.AddArg(x)
8676 return true
8677 }
8678
8679
8680
8681 for {
8682 t := v.Type
8683 if v_0.Op != OpRISCV64MOVDconst {
8684 break
8685 }
8686 val := auxIntToInt64(v_0.AuxInt)
8687 y := v_1
8688 if !(is32Bit(-val)) {
8689 break
8690 }
8691 v.reset(OpRISCV64NEG)
8692 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, t)
8693 v0.AuxInt = int64ToAuxInt(-val)
8694 v0.AddArg(y)
8695 v.AddArg(v0)
8696 return true
8697 }
8698
8699
8700 for {
8701 x := v_0
8702 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
8703 break
8704 }
8705 v.copyOf(x)
8706 return true
8707 }
8708
8709
8710 for {
8711 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
8712 break
8713 }
8714 x := v_1
8715 v.reset(OpRISCV64NEG)
8716 v.AddArg(x)
8717 return true
8718 }
8719 return false
8720 }
8721 func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
8722 v_1 := v.Args[1]
8723 v_0 := v.Args[0]
8724
8725
8726 for {
8727 x := v_0
8728 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
8729 break
8730 }
8731 v.reset(OpRISCV64ADDIW)
8732 v.AuxInt = int64ToAuxInt(0)
8733 v.AddArg(x)
8734 return true
8735 }
8736
8737
8738 for {
8739 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
8740 break
8741 }
8742 x := v_1
8743 v.reset(OpRISCV64NEGW)
8744 v.AddArg(x)
8745 return true
8746 }
8747 return false
8748 }
8749 func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
8750 v_1 := v.Args[1]
8751 v_0 := v.Args[0]
8752
8753
8754
8755 for {
8756 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
8757 if v_0.Op != OpRISCV64MOVDconst {
8758 continue
8759 }
8760 val := auxIntToInt64(v_0.AuxInt)
8761 x := v_1
8762 if !(is32Bit(val)) {
8763 continue
8764 }
8765 v.reset(OpRISCV64XORI)
8766 v.AuxInt = int64ToAuxInt(val)
8767 v.AddArg(x)
8768 return true
8769 }
8770 break
8771 }
8772
8773
8774 for {
8775 x := v_0
8776 if x != v_1 {
8777 break
8778 }
8779 v.reset(OpRISCV64MOVDconst)
8780 v.AuxInt = int64ToAuxInt(0)
8781 return true
8782 }
8783 return false
8784 }
8785 func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
8786 v_1 := v.Args[1]
8787 v_0 := v.Args[0]
8788 b := v.Block
8789 typ := &b.Func.Config.Types
8790
8791
8792 for {
8793 t := v.Type
8794 x := v_0
8795 y := v_1
8796 v.reset(OpRISCV64OR)
8797 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
8798 v1 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8799 v1.AuxInt = int64ToAuxInt(15)
8800 v1.AddArg(y)
8801 v0.AddArg2(x, v1)
8802 v2 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8803 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8804 v3.AddArg(x)
8805 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8806 v4.AuxInt = int64ToAuxInt(15)
8807 v5 := b.NewValue0(v.Pos, OpRISCV64NEG, y.Type)
8808 v5.AddArg(y)
8809 v4.AddArg(v5)
8810 v2.AddArg2(v3, v4)
8811 v.AddArg2(v0, v2)
8812 return true
8813 }
8814 }
8815 func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
8816 v_1 := v.Args[1]
8817 v_0 := v.Args[0]
8818 b := v.Block
8819 typ := &b.Func.Config.Types
8820
8821
8822 for {
8823 t := v.Type
8824 x := v_0
8825 y := v_1
8826 v.reset(OpRISCV64OR)
8827 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
8828 v1 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8829 v1.AuxInt = int64ToAuxInt(7)
8830 v1.AddArg(y)
8831 v0.AddArg2(x, v1)
8832 v2 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8833 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8834 v3.AddArg(x)
8835 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8836 v4.AuxInt = int64ToAuxInt(7)
8837 v5 := b.NewValue0(v.Pos, OpRISCV64NEG, y.Type)
8838 v5.AddArg(y)
8839 v4.AddArg(v5)
8840 v2.AddArg2(v3, v4)
8841 v.AddArg2(v0, v2)
8842 return true
8843 }
8844 }
8845 func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
8846 v_1 := v.Args[1]
8847 v_0 := v.Args[0]
8848 b := v.Block
8849 typ := &b.Func.Config.Types
8850
8851
8852
8853 for {
8854 t := v.Type
8855 x := v_0
8856 y := v_1
8857 if !(!shiftIsBounded(v)) {
8858 break
8859 }
8860 v.reset(OpRISCV64AND)
8861 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8862 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8863 v1.AddArg(x)
8864 v0.AddArg2(v1, y)
8865 v2 := b.NewValue0(v.Pos, OpNeg16, t)
8866 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8867 v3.AuxInt = int64ToAuxInt(64)
8868 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8869 v4.AddArg(y)
8870 v3.AddArg(v4)
8871 v2.AddArg(v3)
8872 v.AddArg2(v0, v2)
8873 return true
8874 }
8875
8876
8877
8878 for {
8879 x := v_0
8880 y := v_1
8881 if !(shiftIsBounded(v)) {
8882 break
8883 }
8884 v.reset(OpRISCV64SRL)
8885 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8886 v0.AddArg(x)
8887 v.AddArg2(v0, y)
8888 return true
8889 }
8890 return false
8891 }
8892 func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
8893 v_1 := v.Args[1]
8894 v_0 := v.Args[0]
8895 b := v.Block
8896 typ := &b.Func.Config.Types
8897
8898
8899
8900 for {
8901 t := v.Type
8902 x := v_0
8903 y := v_1
8904 if !(!shiftIsBounded(v)) {
8905 break
8906 }
8907 v.reset(OpRISCV64AND)
8908 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8909 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8910 v1.AddArg(x)
8911 v0.AddArg2(v1, y)
8912 v2 := b.NewValue0(v.Pos, OpNeg16, t)
8913 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8914 v3.AuxInt = int64ToAuxInt(64)
8915 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
8916 v4.AddArg(y)
8917 v3.AddArg(v4)
8918 v2.AddArg(v3)
8919 v.AddArg2(v0, v2)
8920 return true
8921 }
8922
8923
8924
8925 for {
8926 x := v_0
8927 y := v_1
8928 if !(shiftIsBounded(v)) {
8929 break
8930 }
8931 v.reset(OpRISCV64SRL)
8932 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8933 v0.AddArg(x)
8934 v.AddArg2(v0, y)
8935 return true
8936 }
8937 return false
8938 }
8939 func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
8940 v_1 := v.Args[1]
8941 v_0 := v.Args[0]
8942 b := v.Block
8943 typ := &b.Func.Config.Types
8944
8945
8946
8947 for {
8948 t := v.Type
8949 x := v_0
8950 y := v_1
8951 if !(!shiftIsBounded(v)) {
8952 break
8953 }
8954 v.reset(OpRISCV64AND)
8955 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8956 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8957 v1.AddArg(x)
8958 v0.AddArg2(v1, y)
8959 v2 := b.NewValue0(v.Pos, OpNeg16, t)
8960 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8961 v3.AuxInt = int64ToAuxInt(64)
8962 v3.AddArg(y)
8963 v2.AddArg(v3)
8964 v.AddArg2(v0, v2)
8965 return true
8966 }
8967
8968
8969
8970 for {
8971 x := v_0
8972 y := v_1
8973 if !(shiftIsBounded(v)) {
8974 break
8975 }
8976 v.reset(OpRISCV64SRL)
8977 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8978 v0.AddArg(x)
8979 v.AddArg2(v0, y)
8980 return true
8981 }
8982 return false
8983 }
8984 func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
8985 v_1 := v.Args[1]
8986 v_0 := v.Args[0]
8987 b := v.Block
8988 typ := &b.Func.Config.Types
8989
8990
8991
8992 for {
8993 t := v.Type
8994 x := v_0
8995 y := v_1
8996 if !(!shiftIsBounded(v)) {
8997 break
8998 }
8999 v.reset(OpRISCV64AND)
9000 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9001 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9002 v1.AddArg(x)
9003 v0.AddArg2(v1, y)
9004 v2 := b.NewValue0(v.Pos, OpNeg16, t)
9005 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9006 v3.AuxInt = int64ToAuxInt(64)
9007 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9008 v4.AddArg(y)
9009 v3.AddArg(v4)
9010 v2.AddArg(v3)
9011 v.AddArg2(v0, v2)
9012 return true
9013 }
9014
9015
9016
9017 for {
9018 x := v_0
9019 y := v_1
9020 if !(shiftIsBounded(v)) {
9021 break
9022 }
9023 v.reset(OpRISCV64SRL)
9024 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9025 v0.AddArg(x)
9026 v.AddArg2(v0, y)
9027 return true
9028 }
9029 return false
9030 }
9031 func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
9032 v_1 := v.Args[1]
9033 v_0 := v.Args[0]
9034 b := v.Block
9035 typ := &b.Func.Config.Types
9036
9037
9038
9039 for {
9040 t := v.Type
9041 x := v_0
9042 y := v_1
9043 if !(!shiftIsBounded(v)) {
9044 break
9045 }
9046 v.reset(OpRISCV64SRA)
9047 v.Type = t
9048 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9049 v0.AddArg(x)
9050 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9051 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9052 v2.AuxInt = int64ToAuxInt(-1)
9053 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9054 v3.AuxInt = int64ToAuxInt(64)
9055 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9056 v4.AddArg(y)
9057 v3.AddArg(v4)
9058 v2.AddArg(v3)
9059 v1.AddArg2(y, v2)
9060 v.AddArg2(v0, v1)
9061 return true
9062 }
9063
9064
9065
9066 for {
9067 x := v_0
9068 y := v_1
9069 if !(shiftIsBounded(v)) {
9070 break
9071 }
9072 v.reset(OpRISCV64SRA)
9073 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9074 v0.AddArg(x)
9075 v.AddArg2(v0, y)
9076 return true
9077 }
9078 return false
9079 }
9080 func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
9081 v_1 := v.Args[1]
9082 v_0 := v.Args[0]
9083 b := v.Block
9084 typ := &b.Func.Config.Types
9085
9086
9087
9088 for {
9089 t := v.Type
9090 x := v_0
9091 y := v_1
9092 if !(!shiftIsBounded(v)) {
9093 break
9094 }
9095 v.reset(OpRISCV64SRA)
9096 v.Type = t
9097 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9098 v0.AddArg(x)
9099 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9100 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9101 v2.AuxInt = int64ToAuxInt(-1)
9102 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9103 v3.AuxInt = int64ToAuxInt(64)
9104 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9105 v4.AddArg(y)
9106 v3.AddArg(v4)
9107 v2.AddArg(v3)
9108 v1.AddArg2(y, v2)
9109 v.AddArg2(v0, v1)
9110 return true
9111 }
9112
9113
9114
9115 for {
9116 x := v_0
9117 y := v_1
9118 if !(shiftIsBounded(v)) {
9119 break
9120 }
9121 v.reset(OpRISCV64SRA)
9122 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9123 v0.AddArg(x)
9124 v.AddArg2(v0, y)
9125 return true
9126 }
9127 return false
9128 }
9129 func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
9130 v_1 := v.Args[1]
9131 v_0 := v.Args[0]
9132 b := v.Block
9133 typ := &b.Func.Config.Types
9134
9135
9136
9137 for {
9138 t := v.Type
9139 x := v_0
9140 y := v_1
9141 if !(!shiftIsBounded(v)) {
9142 break
9143 }
9144 v.reset(OpRISCV64SRA)
9145 v.Type = t
9146 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9147 v0.AddArg(x)
9148 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9149 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9150 v2.AuxInt = int64ToAuxInt(-1)
9151 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9152 v3.AuxInt = int64ToAuxInt(64)
9153 v3.AddArg(y)
9154 v2.AddArg(v3)
9155 v1.AddArg2(y, v2)
9156 v.AddArg2(v0, v1)
9157 return true
9158 }
9159
9160
9161
9162 for {
9163 x := v_0
9164 y := v_1
9165 if !(shiftIsBounded(v)) {
9166 break
9167 }
9168 v.reset(OpRISCV64SRA)
9169 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9170 v0.AddArg(x)
9171 v.AddArg2(v0, y)
9172 return true
9173 }
9174 return false
9175 }
9176 func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
9177 v_1 := v.Args[1]
9178 v_0 := v.Args[0]
9179 b := v.Block
9180 typ := &b.Func.Config.Types
9181
9182
9183
9184 for {
9185 t := v.Type
9186 x := v_0
9187 y := v_1
9188 if !(!shiftIsBounded(v)) {
9189 break
9190 }
9191 v.reset(OpRISCV64SRA)
9192 v.Type = t
9193 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9194 v0.AddArg(x)
9195 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9196 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9197 v2.AuxInt = int64ToAuxInt(-1)
9198 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9199 v3.AuxInt = int64ToAuxInt(64)
9200 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9201 v4.AddArg(y)
9202 v3.AddArg(v4)
9203 v2.AddArg(v3)
9204 v1.AddArg2(y, v2)
9205 v.AddArg2(v0, v1)
9206 return true
9207 }
9208
9209
9210
9211 for {
9212 x := v_0
9213 y := v_1
9214 if !(shiftIsBounded(v)) {
9215 break
9216 }
9217 v.reset(OpRISCV64SRA)
9218 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9219 v0.AddArg(x)
9220 v.AddArg2(v0, y)
9221 return true
9222 }
9223 return false
9224 }
9225 func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
9226 v_1 := v.Args[1]
9227 v_0 := v.Args[0]
9228 b := v.Block
9229 typ := &b.Func.Config.Types
9230
9231
9232
9233 for {
9234 t := v.Type
9235 x := v_0
9236 y := v_1
9237 if !(!shiftIsBounded(v)) {
9238 break
9239 }
9240 v.reset(OpRISCV64AND)
9241 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9242 v0.AddArg2(x, y)
9243 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9244 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9245 v2.AuxInt = int64ToAuxInt(32)
9246 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9247 v3.AddArg(y)
9248 v2.AddArg(v3)
9249 v1.AddArg(v2)
9250 v.AddArg2(v0, v1)
9251 return true
9252 }
9253
9254
9255
9256 for {
9257 x := v_0
9258 y := v_1
9259 if !(shiftIsBounded(v)) {
9260 break
9261 }
9262 v.reset(OpRISCV64SRLW)
9263 v.AddArg2(x, y)
9264 return true
9265 }
9266 return false
9267 }
9268 func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
9269 v_1 := v.Args[1]
9270 v_0 := v.Args[0]
9271 b := v.Block
9272 typ := &b.Func.Config.Types
9273
9274
9275
9276 for {
9277 t := v.Type
9278 x := v_0
9279 y := v_1
9280 if !(!shiftIsBounded(v)) {
9281 break
9282 }
9283 v.reset(OpRISCV64AND)
9284 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9285 v0.AddArg2(x, y)
9286 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9287 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9288 v2.AuxInt = int64ToAuxInt(32)
9289 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9290 v3.AddArg(y)
9291 v2.AddArg(v3)
9292 v1.AddArg(v2)
9293 v.AddArg2(v0, v1)
9294 return true
9295 }
9296
9297
9298
9299 for {
9300 x := v_0
9301 y := v_1
9302 if !(shiftIsBounded(v)) {
9303 break
9304 }
9305 v.reset(OpRISCV64SRLW)
9306 v.AddArg2(x, y)
9307 return true
9308 }
9309 return false
9310 }
9311 func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
9312 v_1 := v.Args[1]
9313 v_0 := v.Args[0]
9314 b := v.Block
9315
9316
9317
9318 for {
9319 t := v.Type
9320 x := v_0
9321 y := v_1
9322 if !(!shiftIsBounded(v)) {
9323 break
9324 }
9325 v.reset(OpRISCV64AND)
9326 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9327 v0.AddArg2(x, y)
9328 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9329 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9330 v2.AuxInt = int64ToAuxInt(32)
9331 v2.AddArg(y)
9332 v1.AddArg(v2)
9333 v.AddArg2(v0, v1)
9334 return true
9335 }
9336
9337
9338
9339 for {
9340 x := v_0
9341 y := v_1
9342 if !(shiftIsBounded(v)) {
9343 break
9344 }
9345 v.reset(OpRISCV64SRLW)
9346 v.AddArg2(x, y)
9347 return true
9348 }
9349 return false
9350 }
9351 func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
9352 v_1 := v.Args[1]
9353 v_0 := v.Args[0]
9354 b := v.Block
9355 typ := &b.Func.Config.Types
9356
9357
9358
9359 for {
9360 t := v.Type
9361 x := v_0
9362 y := v_1
9363 if !(!shiftIsBounded(v)) {
9364 break
9365 }
9366 v.reset(OpRISCV64AND)
9367 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9368 v0.AddArg2(x, y)
9369 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9370 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9371 v2.AuxInt = int64ToAuxInt(32)
9372 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9373 v3.AddArg(y)
9374 v2.AddArg(v3)
9375 v1.AddArg(v2)
9376 v.AddArg2(v0, v1)
9377 return true
9378 }
9379
9380
9381
9382 for {
9383 x := v_0
9384 y := v_1
9385 if !(shiftIsBounded(v)) {
9386 break
9387 }
9388 v.reset(OpRISCV64SRLW)
9389 v.AddArg2(x, y)
9390 return true
9391 }
9392 return false
9393 }
9394 func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
9395 v_1 := v.Args[1]
9396 v_0 := v.Args[0]
9397 b := v.Block
9398 typ := &b.Func.Config.Types
9399
9400
9401
9402 for {
9403 t := v.Type
9404 x := v_0
9405 y := v_1
9406 if !(!shiftIsBounded(v)) {
9407 break
9408 }
9409 v.reset(OpRISCV64SRAW)
9410 v.Type = t
9411 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9412 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9413 v1.AuxInt = int64ToAuxInt(-1)
9414 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9415 v2.AuxInt = int64ToAuxInt(32)
9416 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9417 v3.AddArg(y)
9418 v2.AddArg(v3)
9419 v1.AddArg(v2)
9420 v0.AddArg2(y, v1)
9421 v.AddArg2(x, v0)
9422 return true
9423 }
9424
9425
9426
9427 for {
9428 x := v_0
9429 y := v_1
9430 if !(shiftIsBounded(v)) {
9431 break
9432 }
9433 v.reset(OpRISCV64SRAW)
9434 v.AddArg2(x, y)
9435 return true
9436 }
9437 return false
9438 }
9439 func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
9440 v_1 := v.Args[1]
9441 v_0 := v.Args[0]
9442 b := v.Block
9443 typ := &b.Func.Config.Types
9444
9445
9446
9447 for {
9448 t := v.Type
9449 x := v_0
9450 y := v_1
9451 if !(!shiftIsBounded(v)) {
9452 break
9453 }
9454 v.reset(OpRISCV64SRAW)
9455 v.Type = t
9456 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9457 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9458 v1.AuxInt = int64ToAuxInt(-1)
9459 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9460 v2.AuxInt = int64ToAuxInt(32)
9461 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9462 v3.AddArg(y)
9463 v2.AddArg(v3)
9464 v1.AddArg(v2)
9465 v0.AddArg2(y, v1)
9466 v.AddArg2(x, v0)
9467 return true
9468 }
9469
9470
9471
9472 for {
9473 x := v_0
9474 y := v_1
9475 if !(shiftIsBounded(v)) {
9476 break
9477 }
9478 v.reset(OpRISCV64SRAW)
9479 v.AddArg2(x, y)
9480 return true
9481 }
9482 return false
9483 }
9484 func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
9485 v_1 := v.Args[1]
9486 v_0 := v.Args[0]
9487 b := v.Block
9488
9489
9490
9491 for {
9492 t := v.Type
9493 x := v_0
9494 y := v_1
9495 if !(!shiftIsBounded(v)) {
9496 break
9497 }
9498 v.reset(OpRISCV64SRAW)
9499 v.Type = t
9500 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9501 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9502 v1.AuxInt = int64ToAuxInt(-1)
9503 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9504 v2.AuxInt = int64ToAuxInt(32)
9505 v2.AddArg(y)
9506 v1.AddArg(v2)
9507 v0.AddArg2(y, v1)
9508 v.AddArg2(x, v0)
9509 return true
9510 }
9511
9512
9513
9514 for {
9515 x := v_0
9516 y := v_1
9517 if !(shiftIsBounded(v)) {
9518 break
9519 }
9520 v.reset(OpRISCV64SRAW)
9521 v.AddArg2(x, y)
9522 return true
9523 }
9524 return false
9525 }
9526 func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
9527 v_1 := v.Args[1]
9528 v_0 := v.Args[0]
9529 b := v.Block
9530 typ := &b.Func.Config.Types
9531
9532
9533
9534 for {
9535 t := v.Type
9536 x := v_0
9537 y := v_1
9538 if !(!shiftIsBounded(v)) {
9539 break
9540 }
9541 v.reset(OpRISCV64SRAW)
9542 v.Type = t
9543 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9544 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9545 v1.AuxInt = int64ToAuxInt(-1)
9546 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9547 v2.AuxInt = int64ToAuxInt(32)
9548 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9549 v3.AddArg(y)
9550 v2.AddArg(v3)
9551 v1.AddArg(v2)
9552 v0.AddArg2(y, v1)
9553 v.AddArg2(x, v0)
9554 return true
9555 }
9556
9557
9558
9559 for {
9560 x := v_0
9561 y := v_1
9562 if !(shiftIsBounded(v)) {
9563 break
9564 }
9565 v.reset(OpRISCV64SRAW)
9566 v.AddArg2(x, y)
9567 return true
9568 }
9569 return false
9570 }
9571 func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
9572 v_1 := v.Args[1]
9573 v_0 := v.Args[0]
9574 b := v.Block
9575 typ := &b.Func.Config.Types
9576
9577
9578
9579 for {
9580 t := v.Type
9581 x := v_0
9582 y := v_1
9583 if !(!shiftIsBounded(v)) {
9584 break
9585 }
9586 v.reset(OpRISCV64AND)
9587 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9588 v0.AddArg2(x, y)
9589 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9590 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9591 v2.AuxInt = int64ToAuxInt(64)
9592 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9593 v3.AddArg(y)
9594 v2.AddArg(v3)
9595 v1.AddArg(v2)
9596 v.AddArg2(v0, v1)
9597 return true
9598 }
9599
9600
9601
9602 for {
9603 x := v_0
9604 y := v_1
9605 if !(shiftIsBounded(v)) {
9606 break
9607 }
9608 v.reset(OpRISCV64SRL)
9609 v.AddArg2(x, y)
9610 return true
9611 }
9612 return false
9613 }
9614 func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
9615 v_1 := v.Args[1]
9616 v_0 := v.Args[0]
9617 b := v.Block
9618 typ := &b.Func.Config.Types
9619
9620
9621
9622 for {
9623 t := v.Type
9624 x := v_0
9625 y := v_1
9626 if !(!shiftIsBounded(v)) {
9627 break
9628 }
9629 v.reset(OpRISCV64AND)
9630 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9631 v0.AddArg2(x, y)
9632 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9633 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9634 v2.AuxInt = int64ToAuxInt(64)
9635 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9636 v3.AddArg(y)
9637 v2.AddArg(v3)
9638 v1.AddArg(v2)
9639 v.AddArg2(v0, v1)
9640 return true
9641 }
9642
9643
9644
9645 for {
9646 x := v_0
9647 y := v_1
9648 if !(shiftIsBounded(v)) {
9649 break
9650 }
9651 v.reset(OpRISCV64SRL)
9652 v.AddArg2(x, y)
9653 return true
9654 }
9655 return false
9656 }
9657 func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
9658 v_1 := v.Args[1]
9659 v_0 := v.Args[0]
9660 b := v.Block
9661
9662
9663
9664 for {
9665 t := v.Type
9666 x := v_0
9667 y := v_1
9668 if !(!shiftIsBounded(v)) {
9669 break
9670 }
9671 v.reset(OpRISCV64AND)
9672 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9673 v0.AddArg2(x, y)
9674 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9675 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9676 v2.AuxInt = int64ToAuxInt(64)
9677 v2.AddArg(y)
9678 v1.AddArg(v2)
9679 v.AddArg2(v0, v1)
9680 return true
9681 }
9682
9683
9684
9685 for {
9686 x := v_0
9687 y := v_1
9688 if !(shiftIsBounded(v)) {
9689 break
9690 }
9691 v.reset(OpRISCV64SRL)
9692 v.AddArg2(x, y)
9693 return true
9694 }
9695 return false
9696 }
9697 func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
9698 v_1 := v.Args[1]
9699 v_0 := v.Args[0]
9700 b := v.Block
9701 typ := &b.Func.Config.Types
9702
9703
9704
9705 for {
9706 t := v.Type
9707 x := v_0
9708 y := v_1
9709 if !(!shiftIsBounded(v)) {
9710 break
9711 }
9712 v.reset(OpRISCV64AND)
9713 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9714 v0.AddArg2(x, y)
9715 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9716 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9717 v2.AuxInt = int64ToAuxInt(64)
9718 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9719 v3.AddArg(y)
9720 v2.AddArg(v3)
9721 v1.AddArg(v2)
9722 v.AddArg2(v0, v1)
9723 return true
9724 }
9725
9726
9727
9728 for {
9729 x := v_0
9730 y := v_1
9731 if !(shiftIsBounded(v)) {
9732 break
9733 }
9734 v.reset(OpRISCV64SRL)
9735 v.AddArg2(x, y)
9736 return true
9737 }
9738 return false
9739 }
9740 func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
9741 v_1 := v.Args[1]
9742 v_0 := v.Args[0]
9743 b := v.Block
9744 typ := &b.Func.Config.Types
9745
9746
9747
9748 for {
9749 t := v.Type
9750 x := v_0
9751 y := v_1
9752 if !(!shiftIsBounded(v)) {
9753 break
9754 }
9755 v.reset(OpRISCV64SRA)
9756 v.Type = t
9757 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9758 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9759 v1.AuxInt = int64ToAuxInt(-1)
9760 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9761 v2.AuxInt = int64ToAuxInt(64)
9762 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9763 v3.AddArg(y)
9764 v2.AddArg(v3)
9765 v1.AddArg(v2)
9766 v0.AddArg2(y, v1)
9767 v.AddArg2(x, v0)
9768 return true
9769 }
9770
9771
9772
9773 for {
9774 x := v_0
9775 y := v_1
9776 if !(shiftIsBounded(v)) {
9777 break
9778 }
9779 v.reset(OpRISCV64SRA)
9780 v.AddArg2(x, y)
9781 return true
9782 }
9783 return false
9784 }
9785 func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
9786 v_1 := v.Args[1]
9787 v_0 := v.Args[0]
9788 b := v.Block
9789 typ := &b.Func.Config.Types
9790
9791
9792
9793 for {
9794 t := v.Type
9795 x := v_0
9796 y := v_1
9797 if !(!shiftIsBounded(v)) {
9798 break
9799 }
9800 v.reset(OpRISCV64SRA)
9801 v.Type = t
9802 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9803 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9804 v1.AuxInt = int64ToAuxInt(-1)
9805 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9806 v2.AuxInt = int64ToAuxInt(64)
9807 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9808 v3.AddArg(y)
9809 v2.AddArg(v3)
9810 v1.AddArg(v2)
9811 v0.AddArg2(y, v1)
9812 v.AddArg2(x, v0)
9813 return true
9814 }
9815
9816
9817
9818 for {
9819 x := v_0
9820 y := v_1
9821 if !(shiftIsBounded(v)) {
9822 break
9823 }
9824 v.reset(OpRISCV64SRA)
9825 v.AddArg2(x, y)
9826 return true
9827 }
9828 return false
9829 }
9830 func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
9831 v_1 := v.Args[1]
9832 v_0 := v.Args[0]
9833 b := v.Block
9834
9835
9836
9837 for {
9838 t := v.Type
9839 x := v_0
9840 y := v_1
9841 if !(!shiftIsBounded(v)) {
9842 break
9843 }
9844 v.reset(OpRISCV64SRA)
9845 v.Type = t
9846 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9847 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9848 v1.AuxInt = int64ToAuxInt(-1)
9849 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9850 v2.AuxInt = int64ToAuxInt(64)
9851 v2.AddArg(y)
9852 v1.AddArg(v2)
9853 v0.AddArg2(y, v1)
9854 v.AddArg2(x, v0)
9855 return true
9856 }
9857
9858
9859
9860 for {
9861 x := v_0
9862 y := v_1
9863 if !(shiftIsBounded(v)) {
9864 break
9865 }
9866 v.reset(OpRISCV64SRA)
9867 v.AddArg2(x, y)
9868 return true
9869 }
9870 return false
9871 }
9872 func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
9873 v_1 := v.Args[1]
9874 v_0 := v.Args[0]
9875 b := v.Block
9876 typ := &b.Func.Config.Types
9877
9878
9879
9880 for {
9881 t := v.Type
9882 x := v_0
9883 y := v_1
9884 if !(!shiftIsBounded(v)) {
9885 break
9886 }
9887 v.reset(OpRISCV64SRA)
9888 v.Type = t
9889 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9890 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9891 v1.AuxInt = int64ToAuxInt(-1)
9892 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9893 v2.AuxInt = int64ToAuxInt(64)
9894 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9895 v3.AddArg(y)
9896 v2.AddArg(v3)
9897 v1.AddArg(v2)
9898 v0.AddArg2(y, v1)
9899 v.AddArg2(x, v0)
9900 return true
9901 }
9902
9903
9904
9905 for {
9906 x := v_0
9907 y := v_1
9908 if !(shiftIsBounded(v)) {
9909 break
9910 }
9911 v.reset(OpRISCV64SRA)
9912 v.AddArg2(x, y)
9913 return true
9914 }
9915 return false
9916 }
9917 func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
9918 v_1 := v.Args[1]
9919 v_0 := v.Args[0]
9920 b := v.Block
9921 typ := &b.Func.Config.Types
9922
9923
9924
9925 for {
9926 t := v.Type
9927 x := v_0
9928 y := v_1
9929 if !(!shiftIsBounded(v)) {
9930 break
9931 }
9932 v.reset(OpRISCV64AND)
9933 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9934 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9935 v1.AddArg(x)
9936 v0.AddArg2(v1, y)
9937 v2 := b.NewValue0(v.Pos, OpNeg8, t)
9938 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9939 v3.AuxInt = int64ToAuxInt(64)
9940 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9941 v4.AddArg(y)
9942 v3.AddArg(v4)
9943 v2.AddArg(v3)
9944 v.AddArg2(v0, v2)
9945 return true
9946 }
9947
9948
9949
9950 for {
9951 x := v_0
9952 y := v_1
9953 if !(shiftIsBounded(v)) {
9954 break
9955 }
9956 v.reset(OpRISCV64SRL)
9957 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9958 v0.AddArg(x)
9959 v.AddArg2(v0, y)
9960 return true
9961 }
9962 return false
9963 }
9964 func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
9965 v_1 := v.Args[1]
9966 v_0 := v.Args[0]
9967 b := v.Block
9968 typ := &b.Func.Config.Types
9969
9970
9971
9972 for {
9973 t := v.Type
9974 x := v_0
9975 y := v_1
9976 if !(!shiftIsBounded(v)) {
9977 break
9978 }
9979 v.reset(OpRISCV64AND)
9980 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9981 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9982 v1.AddArg(x)
9983 v0.AddArg2(v1, y)
9984 v2 := b.NewValue0(v.Pos, OpNeg8, t)
9985 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9986 v3.AuxInt = int64ToAuxInt(64)
9987 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9988 v4.AddArg(y)
9989 v3.AddArg(v4)
9990 v2.AddArg(v3)
9991 v.AddArg2(v0, v2)
9992 return true
9993 }
9994
9995
9996
9997 for {
9998 x := v_0
9999 y := v_1
10000 if !(shiftIsBounded(v)) {
10001 break
10002 }
10003 v.reset(OpRISCV64SRL)
10004 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10005 v0.AddArg(x)
10006 v.AddArg2(v0, y)
10007 return true
10008 }
10009 return false
10010 }
10011 func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
10012 v_1 := v.Args[1]
10013 v_0 := v.Args[0]
10014 b := v.Block
10015 typ := &b.Func.Config.Types
10016
10017
10018
10019 for {
10020 t := v.Type
10021 x := v_0
10022 y := v_1
10023 if !(!shiftIsBounded(v)) {
10024 break
10025 }
10026 v.reset(OpRISCV64AND)
10027 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
10028 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10029 v1.AddArg(x)
10030 v0.AddArg2(v1, y)
10031 v2 := b.NewValue0(v.Pos, OpNeg8, t)
10032 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
10033 v3.AuxInt = int64ToAuxInt(64)
10034 v3.AddArg(y)
10035 v2.AddArg(v3)
10036 v.AddArg2(v0, v2)
10037 return true
10038 }
10039
10040
10041
10042 for {
10043 x := v_0
10044 y := v_1
10045 if !(shiftIsBounded(v)) {
10046 break
10047 }
10048 v.reset(OpRISCV64SRL)
10049 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10050 v0.AddArg(x)
10051 v.AddArg2(v0, y)
10052 return true
10053 }
10054 return false
10055 }
10056 func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
10057 v_1 := v.Args[1]
10058 v_0 := v.Args[0]
10059 b := v.Block
10060 typ := &b.Func.Config.Types
10061
10062
10063
10064 for {
10065 t := v.Type
10066 x := v_0
10067 y := v_1
10068 if !(!shiftIsBounded(v)) {
10069 break
10070 }
10071 v.reset(OpRISCV64AND)
10072 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
10073 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10074 v1.AddArg(x)
10075 v0.AddArg2(v1, y)
10076 v2 := b.NewValue0(v.Pos, OpNeg8, t)
10077 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
10078 v3.AuxInt = int64ToAuxInt(64)
10079 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10080 v4.AddArg(y)
10081 v3.AddArg(v4)
10082 v2.AddArg(v3)
10083 v.AddArg2(v0, v2)
10084 return true
10085 }
10086
10087
10088
10089 for {
10090 x := v_0
10091 y := v_1
10092 if !(shiftIsBounded(v)) {
10093 break
10094 }
10095 v.reset(OpRISCV64SRL)
10096 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10097 v0.AddArg(x)
10098 v.AddArg2(v0, y)
10099 return true
10100 }
10101 return false
10102 }
10103 func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
10104 v_1 := v.Args[1]
10105 v_0 := v.Args[0]
10106 b := v.Block
10107 typ := &b.Func.Config.Types
10108
10109
10110
10111 for {
10112 t := v.Type
10113 x := v_0
10114 y := v_1
10115 if !(!shiftIsBounded(v)) {
10116 break
10117 }
10118 v.reset(OpRISCV64SRA)
10119 v.Type = t
10120 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10121 v0.AddArg(x)
10122 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10123 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10124 v2.AuxInt = int64ToAuxInt(-1)
10125 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10126 v3.AuxInt = int64ToAuxInt(64)
10127 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
10128 v4.AddArg(y)
10129 v3.AddArg(v4)
10130 v2.AddArg(v3)
10131 v1.AddArg2(y, v2)
10132 v.AddArg2(v0, v1)
10133 return true
10134 }
10135
10136
10137
10138 for {
10139 x := v_0
10140 y := v_1
10141 if !(shiftIsBounded(v)) {
10142 break
10143 }
10144 v.reset(OpRISCV64SRA)
10145 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10146 v0.AddArg(x)
10147 v.AddArg2(v0, y)
10148 return true
10149 }
10150 return false
10151 }
10152 func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
10153 v_1 := v.Args[1]
10154 v_0 := v.Args[0]
10155 b := v.Block
10156 typ := &b.Func.Config.Types
10157
10158
10159
10160 for {
10161 t := v.Type
10162 x := v_0
10163 y := v_1
10164 if !(!shiftIsBounded(v)) {
10165 break
10166 }
10167 v.reset(OpRISCV64SRA)
10168 v.Type = t
10169 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10170 v0.AddArg(x)
10171 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10172 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10173 v2.AuxInt = int64ToAuxInt(-1)
10174 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10175 v3.AuxInt = int64ToAuxInt(64)
10176 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
10177 v4.AddArg(y)
10178 v3.AddArg(v4)
10179 v2.AddArg(v3)
10180 v1.AddArg2(y, v2)
10181 v.AddArg2(v0, v1)
10182 return true
10183 }
10184
10185
10186
10187 for {
10188 x := v_0
10189 y := v_1
10190 if !(shiftIsBounded(v)) {
10191 break
10192 }
10193 v.reset(OpRISCV64SRA)
10194 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10195 v0.AddArg(x)
10196 v.AddArg2(v0, y)
10197 return true
10198 }
10199 return false
10200 }
10201 func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
10202 v_1 := v.Args[1]
10203 v_0 := v.Args[0]
10204 b := v.Block
10205 typ := &b.Func.Config.Types
10206
10207
10208
10209 for {
10210 t := v.Type
10211 x := v_0
10212 y := v_1
10213 if !(!shiftIsBounded(v)) {
10214 break
10215 }
10216 v.reset(OpRISCV64SRA)
10217 v.Type = t
10218 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10219 v0.AddArg(x)
10220 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10221 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10222 v2.AuxInt = int64ToAuxInt(-1)
10223 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10224 v3.AuxInt = int64ToAuxInt(64)
10225 v3.AddArg(y)
10226 v2.AddArg(v3)
10227 v1.AddArg2(y, v2)
10228 v.AddArg2(v0, v1)
10229 return true
10230 }
10231
10232
10233
10234 for {
10235 x := v_0
10236 y := v_1
10237 if !(shiftIsBounded(v)) {
10238 break
10239 }
10240 v.reset(OpRISCV64SRA)
10241 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10242 v0.AddArg(x)
10243 v.AddArg2(v0, y)
10244 return true
10245 }
10246 return false
10247 }
10248 func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
10249 v_1 := v.Args[1]
10250 v_0 := v.Args[0]
10251 b := v.Block
10252 typ := &b.Func.Config.Types
10253
10254
10255
10256 for {
10257 t := v.Type
10258 x := v_0
10259 y := v_1
10260 if !(!shiftIsBounded(v)) {
10261 break
10262 }
10263 v.reset(OpRISCV64SRA)
10264 v.Type = t
10265 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10266 v0.AddArg(x)
10267 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10268 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10269 v2.AuxInt = int64ToAuxInt(-1)
10270 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10271 v3.AuxInt = int64ToAuxInt(64)
10272 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10273 v4.AddArg(y)
10274 v3.AddArg(v4)
10275 v2.AddArg(v3)
10276 v1.AddArg2(y, v2)
10277 v.AddArg2(v0, v1)
10278 return true
10279 }
10280
10281
10282
10283 for {
10284 x := v_0
10285 y := v_1
10286 if !(shiftIsBounded(v)) {
10287 break
10288 }
10289 v.reset(OpRISCV64SRA)
10290 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10291 v0.AddArg(x)
10292 v.AddArg2(v0, y)
10293 return true
10294 }
10295 return false
10296 }
10297 func rewriteValueRISCV64_OpSelect0(v *Value) bool {
10298 v_0 := v.Args[0]
10299 b := v.Block
10300 typ := &b.Func.Config.Types
10301
10302
10303 for {
10304 if v_0.Op != OpAdd64carry {
10305 break
10306 }
10307 c := v_0.Args[2]
10308 x := v_0.Args[0]
10309 y := v_0.Args[1]
10310 v.reset(OpRISCV64ADD)
10311 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
10312 v0.AddArg2(x, y)
10313 v.AddArg2(v0, c)
10314 return true
10315 }
10316
10317
10318 for {
10319 if v_0.Op != OpSub64borrow {
10320 break
10321 }
10322 c := v_0.Args[2]
10323 x := v_0.Args[0]
10324 y := v_0.Args[1]
10325 v.reset(OpRISCV64SUB)
10326 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
10327 v0.AddArg2(x, y)
10328 v.AddArg2(v0, c)
10329 return true
10330 }
10331
10332
10333
10334 for {
10335 m := v_0
10336 if m.Op != OpRISCV64LoweredMuluhilo {
10337 break
10338 }
10339 y := m.Args[1]
10340 x := m.Args[0]
10341 if !(m.Uses == 1) {
10342 break
10343 }
10344 v.reset(OpRISCV64MULHU)
10345 v.AddArg2(x, y)
10346 return true
10347 }
10348 return false
10349 }
10350 func rewriteValueRISCV64_OpSelect1(v *Value) bool {
10351 v_0 := v.Args[0]
10352 b := v.Block
10353 typ := &b.Func.Config.Types
10354
10355
10356 for {
10357 if v_0.Op != OpAdd64carry {
10358 break
10359 }
10360 c := v_0.Args[2]
10361 x := v_0.Args[0]
10362 y := v_0.Args[1]
10363 v.reset(OpRISCV64OR)
10364 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10365 s := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
10366 s.AddArg2(x, y)
10367 v0.AddArg2(s, x)
10368 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10369 v3 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
10370 v3.AddArg2(s, c)
10371 v2.AddArg2(v3, s)
10372 v.AddArg2(v0, v2)
10373 return true
10374 }
10375
10376
10377 for {
10378 if v_0.Op != OpSub64borrow {
10379 break
10380 }
10381 c := v_0.Args[2]
10382 x := v_0.Args[0]
10383 y := v_0.Args[1]
10384 v.reset(OpRISCV64OR)
10385 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10386 s := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
10387 s.AddArg2(x, y)
10388 v0.AddArg2(x, s)
10389 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10390 v3 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
10391 v3.AddArg2(s, c)
10392 v2.AddArg2(s, v3)
10393 v.AddArg2(v0, v2)
10394 return true
10395 }
10396
10397
10398
10399 for {
10400 m := v_0
10401 if m.Op != OpRISCV64LoweredMuluhilo {
10402 break
10403 }
10404 y := m.Args[1]
10405 x := m.Args[0]
10406 if !(m.Uses == 1) {
10407 break
10408 }
10409 v.reset(OpRISCV64MUL)
10410 v.AddArg2(x, y)
10411 return true
10412 }
10413 return false
10414 }
10415 func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
10416 v_0 := v.Args[0]
10417 b := v.Block
10418
10419
10420 for {
10421 t := v.Type
10422 x := v_0
10423 v.reset(OpRISCV64SRAI)
10424 v.AuxInt = int64ToAuxInt(63)
10425 v0 := b.NewValue0(v.Pos, OpRISCV64NEG, t)
10426 v0.AddArg(x)
10427 v.AddArg(v0)
10428 return true
10429 }
10430 }
10431 func rewriteValueRISCV64_OpStore(v *Value) bool {
10432 v_2 := v.Args[2]
10433 v_1 := v.Args[1]
10434 v_0 := v.Args[0]
10435
10436
10437
10438 for {
10439 t := auxToType(v.Aux)
10440 ptr := v_0
10441 val := v_1
10442 mem := v_2
10443 if !(t.Size() == 1) {
10444 break
10445 }
10446 v.reset(OpRISCV64MOVBstore)
10447 v.AddArg3(ptr, val, mem)
10448 return true
10449 }
10450
10451
10452
10453 for {
10454 t := auxToType(v.Aux)
10455 ptr := v_0
10456 val := v_1
10457 mem := v_2
10458 if !(t.Size() == 2) {
10459 break
10460 }
10461 v.reset(OpRISCV64MOVHstore)
10462 v.AddArg3(ptr, val, mem)
10463 return true
10464 }
10465
10466
10467
10468 for {
10469 t := auxToType(v.Aux)
10470 ptr := v_0
10471 val := v_1
10472 mem := v_2
10473 if !(t.Size() == 4 && !t.IsFloat()) {
10474 break
10475 }
10476 v.reset(OpRISCV64MOVWstore)
10477 v.AddArg3(ptr, val, mem)
10478 return true
10479 }
10480
10481
10482
10483 for {
10484 t := auxToType(v.Aux)
10485 ptr := v_0
10486 val := v_1
10487 mem := v_2
10488 if !(t.Size() == 8 && !t.IsFloat()) {
10489 break
10490 }
10491 v.reset(OpRISCV64MOVDstore)
10492 v.AddArg3(ptr, val, mem)
10493 return true
10494 }
10495
10496
10497
10498 for {
10499 t := auxToType(v.Aux)
10500 ptr := v_0
10501 val := v_1
10502 mem := v_2
10503 if !(t.Size() == 4 && t.IsFloat()) {
10504 break
10505 }
10506 v.reset(OpRISCV64FMOVWstore)
10507 v.AddArg3(ptr, val, mem)
10508 return true
10509 }
10510
10511
10512
10513 for {
10514 t := auxToType(v.Aux)
10515 ptr := v_0
10516 val := v_1
10517 mem := v_2
10518 if !(t.Size() == 8 && t.IsFloat()) {
10519 break
10520 }
10521 v.reset(OpRISCV64FMOVDstore)
10522 v.AddArg3(ptr, val, mem)
10523 return true
10524 }
10525 return false
10526 }
10527 func rewriteValueRISCV64_OpZero(v *Value) bool {
10528 v_1 := v.Args[1]
10529 v_0 := v.Args[0]
10530 b := v.Block
10531 config := b.Func.Config
10532 typ := &b.Func.Config.Types
10533
10534
10535 for {
10536 if auxIntToInt64(v.AuxInt) != 0 {
10537 break
10538 }
10539 mem := v_1
10540 v.copyOf(mem)
10541 return true
10542 }
10543
10544
10545 for {
10546 if auxIntToInt64(v.AuxInt) != 1 {
10547 break
10548 }
10549 ptr := v_0
10550 mem := v_1
10551 v.reset(OpRISCV64MOVBstore)
10552 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10553 v0.AuxInt = int64ToAuxInt(0)
10554 v.AddArg3(ptr, v0, mem)
10555 return true
10556 }
10557
10558
10559
10560 for {
10561 if auxIntToInt64(v.AuxInt) != 2 {
10562 break
10563 }
10564 t := auxToType(v.Aux)
10565 ptr := v_0
10566 mem := v_1
10567 if !(t.Alignment()%2 == 0) {
10568 break
10569 }
10570 v.reset(OpRISCV64MOVHstore)
10571 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10572 v0.AuxInt = int64ToAuxInt(0)
10573 v.AddArg3(ptr, v0, mem)
10574 return true
10575 }
10576
10577
10578 for {
10579 if auxIntToInt64(v.AuxInt) != 2 {
10580 break
10581 }
10582 ptr := v_0
10583 mem := v_1
10584 v.reset(OpRISCV64MOVBstore)
10585 v.AuxInt = int32ToAuxInt(1)
10586 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10587 v0.AuxInt = int64ToAuxInt(0)
10588 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10589 v1.AddArg3(ptr, v0, mem)
10590 v.AddArg3(ptr, v0, v1)
10591 return true
10592 }
10593
10594
10595
10596 for {
10597 if auxIntToInt64(v.AuxInt) != 4 {
10598 break
10599 }
10600 t := auxToType(v.Aux)
10601 ptr := v_0
10602 mem := v_1
10603 if !(t.Alignment()%4 == 0) {
10604 break
10605 }
10606 v.reset(OpRISCV64MOVWstore)
10607 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10608 v0.AuxInt = int64ToAuxInt(0)
10609 v.AddArg3(ptr, v0, mem)
10610 return true
10611 }
10612
10613
10614
10615 for {
10616 if auxIntToInt64(v.AuxInt) != 4 {
10617 break
10618 }
10619 t := auxToType(v.Aux)
10620 ptr := v_0
10621 mem := v_1
10622 if !(t.Alignment()%2 == 0) {
10623 break
10624 }
10625 v.reset(OpRISCV64MOVHstore)
10626 v.AuxInt = int32ToAuxInt(2)
10627 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10628 v0.AuxInt = int64ToAuxInt(0)
10629 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10630 v1.AddArg3(ptr, v0, mem)
10631 v.AddArg3(ptr, v0, v1)
10632 return true
10633 }
10634
10635
10636 for {
10637 if auxIntToInt64(v.AuxInt) != 4 {
10638 break
10639 }
10640 ptr := v_0
10641 mem := v_1
10642 v.reset(OpRISCV64MOVBstore)
10643 v.AuxInt = int32ToAuxInt(3)
10644 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10645 v0.AuxInt = int64ToAuxInt(0)
10646 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10647 v1.AuxInt = int32ToAuxInt(2)
10648 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10649 v2.AuxInt = int32ToAuxInt(1)
10650 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10651 v3.AddArg3(ptr, v0, mem)
10652 v2.AddArg3(ptr, v0, v3)
10653 v1.AddArg3(ptr, v0, v2)
10654 v.AddArg3(ptr, v0, v1)
10655 return true
10656 }
10657
10658
10659
10660 for {
10661 if auxIntToInt64(v.AuxInt) != 8 {
10662 break
10663 }
10664 t := auxToType(v.Aux)
10665 ptr := v_0
10666 mem := v_1
10667 if !(t.Alignment()%8 == 0) {
10668 break
10669 }
10670 v.reset(OpRISCV64MOVDstore)
10671 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10672 v0.AuxInt = int64ToAuxInt(0)
10673 v.AddArg3(ptr, v0, mem)
10674 return true
10675 }
10676
10677
10678
10679 for {
10680 if auxIntToInt64(v.AuxInt) != 8 {
10681 break
10682 }
10683 t := auxToType(v.Aux)
10684 ptr := v_0
10685 mem := v_1
10686 if !(t.Alignment()%4 == 0) {
10687 break
10688 }
10689 v.reset(OpRISCV64MOVWstore)
10690 v.AuxInt = int32ToAuxInt(4)
10691 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10692 v0.AuxInt = int64ToAuxInt(0)
10693 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
10694 v1.AddArg3(ptr, v0, mem)
10695 v.AddArg3(ptr, v0, v1)
10696 return true
10697 }
10698
10699
10700
10701 for {
10702 if auxIntToInt64(v.AuxInt) != 8 {
10703 break
10704 }
10705 t := auxToType(v.Aux)
10706 ptr := v_0
10707 mem := v_1
10708 if !(t.Alignment()%2 == 0) {
10709 break
10710 }
10711 v.reset(OpRISCV64MOVHstore)
10712 v.AuxInt = int32ToAuxInt(6)
10713 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10714 v0.AuxInt = int64ToAuxInt(0)
10715 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10716 v1.AuxInt = int32ToAuxInt(4)
10717 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10718 v2.AuxInt = int32ToAuxInt(2)
10719 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10720 v3.AddArg3(ptr, v0, mem)
10721 v2.AddArg3(ptr, v0, v3)
10722 v1.AddArg3(ptr, v0, v2)
10723 v.AddArg3(ptr, v0, v1)
10724 return true
10725 }
10726
10727
10728 for {
10729 if auxIntToInt64(v.AuxInt) != 3 {
10730 break
10731 }
10732 ptr := v_0
10733 mem := v_1
10734 v.reset(OpRISCV64MOVBstore)
10735 v.AuxInt = int32ToAuxInt(2)
10736 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10737 v0.AuxInt = int64ToAuxInt(0)
10738 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10739 v1.AuxInt = int32ToAuxInt(1)
10740 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10741 v2.AddArg3(ptr, v0, mem)
10742 v1.AddArg3(ptr, v0, v2)
10743 v.AddArg3(ptr, v0, v1)
10744 return true
10745 }
10746
10747
10748
10749 for {
10750 if auxIntToInt64(v.AuxInt) != 6 {
10751 break
10752 }
10753 t := auxToType(v.Aux)
10754 ptr := v_0
10755 mem := v_1
10756 if !(t.Alignment()%2 == 0) {
10757 break
10758 }
10759 v.reset(OpRISCV64MOVHstore)
10760 v.AuxInt = int32ToAuxInt(4)
10761 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10762 v0.AuxInt = int64ToAuxInt(0)
10763 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10764 v1.AuxInt = int32ToAuxInt(2)
10765 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10766 v2.AddArg3(ptr, v0, mem)
10767 v1.AddArg3(ptr, v0, v2)
10768 v.AddArg3(ptr, v0, v1)
10769 return true
10770 }
10771
10772
10773
10774 for {
10775 s := auxIntToInt64(v.AuxInt)
10776 t := auxToType(v.Aux)
10777 ptr := v_0
10778 mem := v_1
10779 if !(s <= 24*moveSize(t.Alignment(), config)) {
10780 break
10781 }
10782 v.reset(OpRISCV64LoweredZero)
10783 v.AuxInt = int64ToAuxInt(s)
10784 v.Aux = int64ToAux(t.Alignment())
10785 v.AddArg2(ptr, mem)
10786 return true
10787 }
10788
10789
10790
10791 for {
10792 s := auxIntToInt64(v.AuxInt)
10793 t := auxToType(v.Aux)
10794 ptr := v_0
10795 mem := v_1
10796 if !(s > 24*moveSize(t.Alignment(), config)) {
10797 break
10798 }
10799 v.reset(OpRISCV64LoweredZeroLoop)
10800 v.AuxInt = int64ToAuxInt(s)
10801 v.Aux = int64ToAux(t.Alignment())
10802 v.AddArg2(ptr, mem)
10803 return true
10804 }
10805 return false
10806 }
10807 func rewriteBlockRISCV64(b *Block) bool {
10808 typ := &b.Func.Config.Types
10809 switch b.Kind {
10810 case BlockRISCV64BEQ:
10811
10812
10813 for b.Controls[0].Op == OpRISCV64MOVDconst {
10814 v_0 := b.Controls[0]
10815 if auxIntToInt64(v_0.AuxInt) != 0 {
10816 break
10817 }
10818 cond := b.Controls[1]
10819 b.resetWithControl(BlockRISCV64BEQZ, cond)
10820 return true
10821 }
10822
10823
10824 for b.Controls[1].Op == OpRISCV64MOVDconst {
10825 cond := b.Controls[0]
10826 v_1 := b.Controls[1]
10827 if auxIntToInt64(v_1.AuxInt) != 0 {
10828 break
10829 }
10830 b.resetWithControl(BlockRISCV64BEQZ, cond)
10831 return true
10832 }
10833 case BlockRISCV64BEQZ:
10834
10835
10836 for b.Controls[0].Op == OpRISCV64SEQZ {
10837 v_0 := b.Controls[0]
10838 x := v_0.Args[0]
10839 b.resetWithControl(BlockRISCV64BNEZ, x)
10840 return true
10841 }
10842
10843
10844 for b.Controls[0].Op == OpRISCV64SNEZ {
10845 v_0 := b.Controls[0]
10846 x := v_0.Args[0]
10847 b.resetWithControl(BlockRISCV64BEQZ, x)
10848 return true
10849 }
10850
10851
10852 for b.Controls[0].Op == OpRISCV64NEG {
10853 v_0 := b.Controls[0]
10854 x := v_0.Args[0]
10855 b.resetWithControl(BlockRISCV64BEQZ, x)
10856 return true
10857 }
10858
10859
10860 for b.Controls[0].Op == OpRISCV64FNES {
10861 v_0 := b.Controls[0]
10862 t := v_0.Type
10863 _ = v_0.Args[1]
10864 v_0_0 := v_0.Args[0]
10865 v_0_1 := v_0.Args[1]
10866 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
10867 x := v_0_0
10868 y := v_0_1
10869 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
10870 v0.AddArg2(x, y)
10871 b.resetWithControl(BlockRISCV64BNEZ, v0)
10872 return true
10873 }
10874 }
10875
10876
10877 for b.Controls[0].Op == OpRISCV64FNED {
10878 v_0 := b.Controls[0]
10879 t := v_0.Type
10880 _ = v_0.Args[1]
10881 v_0_0 := v_0.Args[0]
10882 v_0_1 := v_0.Args[1]
10883 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
10884 x := v_0_0
10885 y := v_0_1
10886 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
10887 v0.AddArg2(x, y)
10888 b.resetWithControl(BlockRISCV64BNEZ, v0)
10889 return true
10890 }
10891 }
10892
10893
10894 for b.Controls[0].Op == OpRISCV64SUB {
10895 v_0 := b.Controls[0]
10896 y := v_0.Args[1]
10897 x := v_0.Args[0]
10898 b.resetWithControl2(BlockRISCV64BEQ, x, y)
10899 return true
10900 }
10901
10902
10903 for b.Controls[0].Op == OpRISCV64SLT {
10904 v_0 := b.Controls[0]
10905 y := v_0.Args[1]
10906 x := v_0.Args[0]
10907 b.resetWithControl2(BlockRISCV64BGE, x, y)
10908 return true
10909 }
10910
10911
10912 for b.Controls[0].Op == OpRISCV64SLTU {
10913 v_0 := b.Controls[0]
10914 y := v_0.Args[1]
10915 x := v_0.Args[0]
10916 b.resetWithControl2(BlockRISCV64BGEU, x, y)
10917 return true
10918 }
10919
10920
10921 for b.Controls[0].Op == OpRISCV64SLTI {
10922 v_0 := b.Controls[0]
10923 x := auxIntToInt64(v_0.AuxInt)
10924 y := v_0.Args[0]
10925 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
10926 v0.AuxInt = int64ToAuxInt(x)
10927 b.resetWithControl2(BlockRISCV64BGE, y, v0)
10928 return true
10929 }
10930
10931
10932 for b.Controls[0].Op == OpRISCV64SLTIU {
10933 v_0 := b.Controls[0]
10934 x := auxIntToInt64(v_0.AuxInt)
10935 y := v_0.Args[0]
10936 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
10937 v0.AuxInt = int64ToAuxInt(x)
10938 b.resetWithControl2(BlockRISCV64BGEU, y, v0)
10939 return true
10940 }
10941
10942
10943 for b.Controls[0].Op == OpRISCV64ANDI {
10944 v_0 := b.Controls[0]
10945 c := auxIntToInt64(v_0.AuxInt)
10946 v_0_0 := v_0.Args[0]
10947 if v_0_0.Op != OpRISCV64FCLASSD {
10948 break
10949 }
10950 v_0_0_0 := v_0_0.Args[0]
10951 if v_0_0_0.Op != OpRISCV64FNEGD {
10952 break
10953 }
10954 x := v_0_0_0.Args[0]
10955 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
10956 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
10957 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
10958 v1.AddArg(x)
10959 v0.AddArg(v1)
10960 b.resetWithControl(BlockRISCV64BEQZ, v0)
10961 return true
10962 }
10963
10964
10965 for b.Controls[0].Op == OpRISCV64ANDI {
10966 v_0 := b.Controls[0]
10967 c := auxIntToInt64(v_0.AuxInt)
10968 v_0_0 := v_0.Args[0]
10969 if v_0_0.Op != OpRISCV64FCLASSD {
10970 break
10971 }
10972 v_0_0_0 := v_0_0.Args[0]
10973 if v_0_0_0.Op != OpRISCV64FABSD {
10974 break
10975 }
10976 x := v_0_0_0.Args[0]
10977 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
10978 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
10979 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
10980 v1.AddArg(x)
10981 v0.AddArg(v1)
10982 b.resetWithControl(BlockRISCV64BEQZ, v0)
10983 return true
10984 }
10985 case BlockRISCV64BGE:
10986
10987
10988 for b.Controls[0].Op == OpRISCV64MOVDconst {
10989 v_0 := b.Controls[0]
10990 if auxIntToInt64(v_0.AuxInt) != 0 {
10991 break
10992 }
10993 cond := b.Controls[1]
10994 b.resetWithControl(BlockRISCV64BLEZ, cond)
10995 return true
10996 }
10997
10998
10999 for b.Controls[1].Op == OpRISCV64MOVDconst {
11000 cond := b.Controls[0]
11001 v_1 := b.Controls[1]
11002 if auxIntToInt64(v_1.AuxInt) != 0 {
11003 break
11004 }
11005 b.resetWithControl(BlockRISCV64BGEZ, cond)
11006 return true
11007 }
11008 case BlockRISCV64BGEU:
11009
11010
11011 for b.Controls[0].Op == OpRISCV64MOVDconst {
11012 v_0 := b.Controls[0]
11013 if auxIntToInt64(v_0.AuxInt) != 0 {
11014 break
11015 }
11016 cond := b.Controls[1]
11017 b.resetWithControl(BlockRISCV64BEQZ, cond)
11018 return true
11019 }
11020 case BlockRISCV64BLT:
11021
11022
11023 for b.Controls[0].Op == OpRISCV64MOVDconst {
11024 v_0 := b.Controls[0]
11025 if auxIntToInt64(v_0.AuxInt) != 0 {
11026 break
11027 }
11028 cond := b.Controls[1]
11029 b.resetWithControl(BlockRISCV64BGTZ, cond)
11030 return true
11031 }
11032
11033
11034 for b.Controls[1].Op == OpRISCV64MOVDconst {
11035 cond := b.Controls[0]
11036 v_1 := b.Controls[1]
11037 if auxIntToInt64(v_1.AuxInt) != 0 {
11038 break
11039 }
11040 b.resetWithControl(BlockRISCV64BLTZ, cond)
11041 return true
11042 }
11043 case BlockRISCV64BLTU:
11044
11045
11046 for b.Controls[0].Op == OpRISCV64MOVDconst {
11047 v_0 := b.Controls[0]
11048 if auxIntToInt64(v_0.AuxInt) != 0 {
11049 break
11050 }
11051 cond := b.Controls[1]
11052 b.resetWithControl(BlockRISCV64BNEZ, cond)
11053 return true
11054 }
11055 case BlockRISCV64BNE:
11056
11057
11058 for b.Controls[0].Op == OpRISCV64MOVDconst {
11059 v_0 := b.Controls[0]
11060 if auxIntToInt64(v_0.AuxInt) != 0 {
11061 break
11062 }
11063 cond := b.Controls[1]
11064 b.resetWithControl(BlockRISCV64BNEZ, cond)
11065 return true
11066 }
11067
11068
11069 for b.Controls[1].Op == OpRISCV64MOVDconst {
11070 cond := b.Controls[0]
11071 v_1 := b.Controls[1]
11072 if auxIntToInt64(v_1.AuxInt) != 0 {
11073 break
11074 }
11075 b.resetWithControl(BlockRISCV64BNEZ, cond)
11076 return true
11077 }
11078 case BlockRISCV64BNEZ:
11079
11080
11081 for b.Controls[0].Op == OpRISCV64SEQZ {
11082 v_0 := b.Controls[0]
11083 x := v_0.Args[0]
11084 b.resetWithControl(BlockRISCV64BEQZ, x)
11085 return true
11086 }
11087
11088
11089 for b.Controls[0].Op == OpRISCV64SNEZ {
11090 v_0 := b.Controls[0]
11091 x := v_0.Args[0]
11092 b.resetWithControl(BlockRISCV64BNEZ, x)
11093 return true
11094 }
11095
11096
11097 for b.Controls[0].Op == OpRISCV64NEG {
11098 v_0 := b.Controls[0]
11099 x := v_0.Args[0]
11100 b.resetWithControl(BlockRISCV64BNEZ, x)
11101 return true
11102 }
11103
11104
11105 for b.Controls[0].Op == OpRISCV64FNES {
11106 v_0 := b.Controls[0]
11107 t := v_0.Type
11108 _ = v_0.Args[1]
11109 v_0_0 := v_0.Args[0]
11110 v_0_1 := v_0.Args[1]
11111 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
11112 x := v_0_0
11113 y := v_0_1
11114 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
11115 v0.AddArg2(x, y)
11116 b.resetWithControl(BlockRISCV64BEQZ, v0)
11117 return true
11118 }
11119 }
11120
11121
11122 for b.Controls[0].Op == OpRISCV64FNED {
11123 v_0 := b.Controls[0]
11124 t := v_0.Type
11125 _ = v_0.Args[1]
11126 v_0_0 := v_0.Args[0]
11127 v_0_1 := v_0.Args[1]
11128 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
11129 x := v_0_0
11130 y := v_0_1
11131 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
11132 v0.AddArg2(x, y)
11133 b.resetWithControl(BlockRISCV64BEQZ, v0)
11134 return true
11135 }
11136 }
11137
11138
11139 for b.Controls[0].Op == OpRISCV64SUB {
11140 v_0 := b.Controls[0]
11141 y := v_0.Args[1]
11142 x := v_0.Args[0]
11143 b.resetWithControl2(BlockRISCV64BNE, x, y)
11144 return true
11145 }
11146
11147
11148 for b.Controls[0].Op == OpRISCV64SLT {
11149 v_0 := b.Controls[0]
11150 y := v_0.Args[1]
11151 x := v_0.Args[0]
11152 b.resetWithControl2(BlockRISCV64BLT, x, y)
11153 return true
11154 }
11155
11156
11157 for b.Controls[0].Op == OpRISCV64SLTU {
11158 v_0 := b.Controls[0]
11159 y := v_0.Args[1]
11160 x := v_0.Args[0]
11161 b.resetWithControl2(BlockRISCV64BLTU, x, y)
11162 return true
11163 }
11164
11165
11166 for b.Controls[0].Op == OpRISCV64SLTI {
11167 v_0 := b.Controls[0]
11168 x := auxIntToInt64(v_0.AuxInt)
11169 y := v_0.Args[0]
11170 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
11171 v0.AuxInt = int64ToAuxInt(x)
11172 b.resetWithControl2(BlockRISCV64BLT, y, v0)
11173 return true
11174 }
11175
11176
11177 for b.Controls[0].Op == OpRISCV64SLTIU {
11178 v_0 := b.Controls[0]
11179 x := auxIntToInt64(v_0.AuxInt)
11180 y := v_0.Args[0]
11181 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
11182 v0.AuxInt = int64ToAuxInt(x)
11183 b.resetWithControl2(BlockRISCV64BLTU, y, v0)
11184 return true
11185 }
11186
11187
11188 for b.Controls[0].Op == OpRISCV64ANDI {
11189 v_0 := b.Controls[0]
11190 c := auxIntToInt64(v_0.AuxInt)
11191 v_0_0 := v_0.Args[0]
11192 if v_0_0.Op != OpRISCV64FCLASSD {
11193 break
11194 }
11195 v_0_0_0 := v_0_0.Args[0]
11196 if v_0_0_0.Op != OpRISCV64FNEGD {
11197 break
11198 }
11199 x := v_0_0_0.Args[0]
11200 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
11201 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
11202 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
11203 v1.AddArg(x)
11204 v0.AddArg(v1)
11205 b.resetWithControl(BlockRISCV64BNEZ, v0)
11206 return true
11207 }
11208
11209
11210 for b.Controls[0].Op == OpRISCV64ANDI {
11211 v_0 := b.Controls[0]
11212 c := auxIntToInt64(v_0.AuxInt)
11213 v_0_0 := v_0.Args[0]
11214 if v_0_0.Op != OpRISCV64FCLASSD {
11215 break
11216 }
11217 v_0_0_0 := v_0_0.Args[0]
11218 if v_0_0_0.Op != OpRISCV64FABSD {
11219 break
11220 }
11221 x := v_0_0_0.Args[0]
11222 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
11223 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
11224 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
11225 v1.AddArg(x)
11226 v0.AddArg(v1)
11227 b.resetWithControl(BlockRISCV64BNEZ, v0)
11228 return true
11229 }
11230 case BlockIf:
11231
11232
11233 for {
11234 cond := b.Controls[0]
11235 v0 := b.NewValue0(cond.Pos, OpRISCV64MOVBUreg, typ.UInt64)
11236 v0.AddArg(cond)
11237 b.resetWithControl(BlockRISCV64BNEZ, v0)
11238 return true
11239 }
11240 }
11241 return false
11242 }
11243
View as plain text