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 = valAndOffToAuxInt(makeValAndOff(int32(s), int32(t.Alignment())))
3117 v.AddArg3(dst, src, mem)
3118 return true
3119 }
3120
3121
3122
3123 for {
3124 s := auxIntToInt64(v.AuxInt)
3125 t := auxToType(v.Aux)
3126 dst := v_0
3127 src := v_1
3128 mem := v_2
3129 if !(s > 3*8*moveSize(t.Alignment(), config) && logLargeCopy(v, s)) {
3130 break
3131 }
3132 v.reset(OpRISCV64LoweredMoveLoop)
3133 v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s), int32(t.Alignment())))
3134 v.AddArg3(dst, src, mem)
3135 return true
3136 }
3137 return false
3138 }
3139 func rewriteValueRISCV64_OpNeq16(v *Value) bool {
3140 v_1 := v.Args[1]
3141 v_0 := v.Args[0]
3142 b := v.Block
3143 typ := &b.Func.Config.Types
3144
3145
3146 for {
3147 x := v_0
3148 y := v_1
3149 v.reset(OpNot)
3150 v0 := b.NewValue0(v.Pos, OpEq16, typ.Bool)
3151 v0.AddArg2(x, y)
3152 v.AddArg(v0)
3153 return true
3154 }
3155 }
3156 func rewriteValueRISCV64_OpNeq32(v *Value) bool {
3157 v_1 := v.Args[1]
3158 v_0 := v.Args[0]
3159 b := v.Block
3160 typ := &b.Func.Config.Types
3161
3162
3163 for {
3164 x := v_0
3165 y := v_1
3166 v.reset(OpNot)
3167 v0 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
3168 v0.AddArg2(x, y)
3169 v.AddArg(v0)
3170 return true
3171 }
3172 }
3173 func rewriteValueRISCV64_OpNeq64(v *Value) bool {
3174 v_1 := v.Args[1]
3175 v_0 := v.Args[0]
3176 b := v.Block
3177 typ := &b.Func.Config.Types
3178
3179
3180 for {
3181 x := v_0
3182 y := v_1
3183 v.reset(OpNot)
3184 v0 := b.NewValue0(v.Pos, OpEq64, typ.Bool)
3185 v0.AddArg2(x, y)
3186 v.AddArg(v0)
3187 return true
3188 }
3189 }
3190 func rewriteValueRISCV64_OpNeq8(v *Value) bool {
3191 v_1 := v.Args[1]
3192 v_0 := v.Args[0]
3193 b := v.Block
3194 typ := &b.Func.Config.Types
3195
3196
3197 for {
3198 x := v_0
3199 y := v_1
3200 v.reset(OpNot)
3201 v0 := b.NewValue0(v.Pos, OpEq8, typ.Bool)
3202 v0.AddArg2(x, y)
3203 v.AddArg(v0)
3204 return true
3205 }
3206 }
3207 func rewriteValueRISCV64_OpNeqB(v *Value) bool {
3208 v_1 := v.Args[1]
3209 v_0 := v.Args[0]
3210 b := v.Block
3211 typ := &b.Func.Config.Types
3212
3213
3214 for {
3215 x := v_0
3216 y := v_1
3217 v.reset(OpRISCV64SNEZ)
3218 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
3219 v0.AddArg2(x, y)
3220 v.AddArg(v0)
3221 return true
3222 }
3223 }
3224 func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
3225 v_1 := v.Args[1]
3226 v_0 := v.Args[0]
3227 b := v.Block
3228 typ := &b.Func.Config.Types
3229
3230
3231 for {
3232 x := v_0
3233 y := v_1
3234 v.reset(OpNot)
3235 v0 := b.NewValue0(v.Pos, OpEqPtr, typ.Bool)
3236 v0.AddArg2(x, y)
3237 v.AddArg(v0)
3238 return true
3239 }
3240 }
3241 func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
3242 v_0 := v.Args[0]
3243 b := v.Block
3244 typ := &b.Func.Config.Types
3245
3246
3247
3248 for {
3249 off := auxIntToInt64(v.AuxInt)
3250 ptr := v_0
3251 if ptr.Op != OpSP || !(is32Bit(off)) {
3252 break
3253 }
3254 v.reset(OpRISCV64MOVaddr)
3255 v.AuxInt = int32ToAuxInt(int32(off))
3256 v.AddArg(ptr)
3257 return true
3258 }
3259
3260
3261
3262 for {
3263 off := auxIntToInt64(v.AuxInt)
3264 ptr := v_0
3265 if !(is32Bit(off)) {
3266 break
3267 }
3268 v.reset(OpRISCV64ADDI)
3269 v.AuxInt = int64ToAuxInt(off)
3270 v.AddArg(ptr)
3271 return true
3272 }
3273
3274
3275 for {
3276 off := auxIntToInt64(v.AuxInt)
3277 ptr := v_0
3278 v.reset(OpRISCV64ADD)
3279 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
3280 v0.AuxInt = int64ToAuxInt(off)
3281 v.AddArg2(v0, ptr)
3282 return true
3283 }
3284 }
3285 func rewriteValueRISCV64_OpPopCount16(v *Value) bool {
3286 v_0 := v.Args[0]
3287 b := v.Block
3288 typ := &b.Func.Config.Types
3289
3290
3291 for {
3292 x := v_0
3293 v.reset(OpRISCV64CPOP)
3294 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3295 v0.AddArg(x)
3296 v.AddArg(v0)
3297 return true
3298 }
3299 }
3300 func rewriteValueRISCV64_OpPopCount8(v *Value) bool {
3301 v_0 := v.Args[0]
3302 b := v.Block
3303 typ := &b.Func.Config.Types
3304
3305
3306 for {
3307 x := v_0
3308 v.reset(OpRISCV64CPOP)
3309 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3310 v0.AddArg(x)
3311 v.AddArg(v0)
3312 return true
3313 }
3314 }
3315 func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
3316 v_1 := v.Args[1]
3317 v_0 := v.Args[0]
3318
3319
3320
3321 for {
3322 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3323 if v_0.Op != OpRISCV64MOVDconst {
3324 continue
3325 }
3326 t := v_0.Type
3327 val := auxIntToInt64(v_0.AuxInt)
3328 x := v_1
3329 if !(is32Bit(val) && !t.IsPtr()) {
3330 continue
3331 }
3332 v.reset(OpRISCV64ADDI)
3333 v.AuxInt = int64ToAuxInt(val)
3334 v.AddArg(x)
3335 return true
3336 }
3337 break
3338 }
3339
3340
3341 for {
3342 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3343 x := v_0
3344 if v_1.Op != OpRISCV64NEG {
3345 continue
3346 }
3347 y := v_1.Args[0]
3348 v.reset(OpRISCV64SUB)
3349 v.AddArg2(x, y)
3350 return true
3351 }
3352 break
3353 }
3354
3355
3356
3357 for {
3358 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3359 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 1 {
3360 continue
3361 }
3362 x := v_0.Args[0]
3363 y := v_1
3364 if !(buildcfg.GORISCV64 >= 22) {
3365 continue
3366 }
3367 v.reset(OpRISCV64SH1ADD)
3368 v.AddArg2(x, y)
3369 return true
3370 }
3371 break
3372 }
3373
3374
3375
3376 for {
3377 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3378 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 2 {
3379 continue
3380 }
3381 x := v_0.Args[0]
3382 y := v_1
3383 if !(buildcfg.GORISCV64 >= 22) {
3384 continue
3385 }
3386 v.reset(OpRISCV64SH2ADD)
3387 v.AddArg2(x, y)
3388 return true
3389 }
3390 break
3391 }
3392
3393
3394
3395 for {
3396 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3397 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 3 {
3398 continue
3399 }
3400 x := v_0.Args[0]
3401 y := v_1
3402 if !(buildcfg.GORISCV64 >= 22) {
3403 continue
3404 }
3405 v.reset(OpRISCV64SH3ADD)
3406 v.AddArg2(x, y)
3407 return true
3408 }
3409 break
3410 }
3411 return false
3412 }
3413 func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
3414 v_0 := v.Args[0]
3415
3416
3417
3418 for {
3419 c := auxIntToInt64(v.AuxInt)
3420 if v_0.Op != OpRISCV64MOVaddr {
3421 break
3422 }
3423 d := auxIntToInt32(v_0.AuxInt)
3424 s := auxToSym(v_0.Aux)
3425 x := v_0.Args[0]
3426 if !(is32Bit(c + int64(d))) {
3427 break
3428 }
3429 v.reset(OpRISCV64MOVaddr)
3430 v.AuxInt = int32ToAuxInt(int32(c) + d)
3431 v.Aux = symToAux(s)
3432 v.AddArg(x)
3433 return true
3434 }
3435
3436
3437 for {
3438 if auxIntToInt64(v.AuxInt) != 0 {
3439 break
3440 }
3441 x := v_0
3442 v.copyOf(x)
3443 return true
3444 }
3445
3446
3447
3448 for {
3449 x := auxIntToInt64(v.AuxInt)
3450 if v_0.Op != OpRISCV64MOVDconst {
3451 break
3452 }
3453 y := auxIntToInt64(v_0.AuxInt)
3454 if !(is32Bit(x + y)) {
3455 break
3456 }
3457 v.reset(OpRISCV64MOVDconst)
3458 v.AuxInt = int64ToAuxInt(x + y)
3459 return true
3460 }
3461
3462
3463
3464 for {
3465 x := auxIntToInt64(v.AuxInt)
3466 if v_0.Op != OpRISCV64ADDI {
3467 break
3468 }
3469 y := auxIntToInt64(v_0.AuxInt)
3470 z := v_0.Args[0]
3471 if !(is32Bit(x + y)) {
3472 break
3473 }
3474 v.reset(OpRISCV64ADDI)
3475 v.AuxInt = int64ToAuxInt(x + y)
3476 v.AddArg(z)
3477 return true
3478 }
3479 return false
3480 }
3481 func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
3482 v_1 := v.Args[1]
3483 v_0 := v.Args[0]
3484
3485
3486
3487 for {
3488 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3489 if v_0.Op != OpRISCV64MOVDconst {
3490 continue
3491 }
3492 val := auxIntToInt64(v_0.AuxInt)
3493 x := v_1
3494 if !(is32Bit(val)) {
3495 continue
3496 }
3497 v.reset(OpRISCV64ANDI)
3498 v.AuxInt = int64ToAuxInt(val)
3499 v.AddArg(x)
3500 return true
3501 }
3502 break
3503 }
3504
3505
3506 for {
3507 x := v_0
3508 if x != v_1 {
3509 break
3510 }
3511 v.copyOf(x)
3512 return true
3513 }
3514 return false
3515 }
3516 func rewriteValueRISCV64_OpRISCV64ANDI(v *Value) bool {
3517 v_0 := v.Args[0]
3518
3519
3520 for {
3521 if auxIntToInt64(v.AuxInt) != 0 {
3522 break
3523 }
3524 v.reset(OpRISCV64MOVDconst)
3525 v.AuxInt = int64ToAuxInt(0)
3526 return true
3527 }
3528
3529
3530 for {
3531 if auxIntToInt64(v.AuxInt) != -1 {
3532 break
3533 }
3534 x := v_0
3535 v.copyOf(x)
3536 return true
3537 }
3538
3539
3540 for {
3541 x := auxIntToInt64(v.AuxInt)
3542 if v_0.Op != OpRISCV64MOVDconst {
3543 break
3544 }
3545 y := auxIntToInt64(v_0.AuxInt)
3546 v.reset(OpRISCV64MOVDconst)
3547 v.AuxInt = int64ToAuxInt(x & y)
3548 return true
3549 }
3550
3551
3552 for {
3553 x := auxIntToInt64(v.AuxInt)
3554 if v_0.Op != OpRISCV64ANDI {
3555 break
3556 }
3557 y := auxIntToInt64(v_0.AuxInt)
3558 z := v_0.Args[0]
3559 v.reset(OpRISCV64ANDI)
3560 v.AuxInt = int64ToAuxInt(x & y)
3561 v.AddArg(z)
3562 return true
3563 }
3564 return false
3565 }
3566 func rewriteValueRISCV64_OpRISCV64CZEROEQZ(v *Value) bool {
3567 v_1 := v.Args[1]
3568 v_0 := v.Args[0]
3569
3570
3571 for {
3572 x := v_0
3573 if v_1.Op != OpRISCV64SNEZ {
3574 break
3575 }
3576 y := v_1.Args[0]
3577 v.reset(OpRISCV64CZEROEQZ)
3578 v.AddArg2(x, y)
3579 return true
3580 }
3581
3582
3583 for {
3584 x := v_0
3585 if v_1.Op != OpRISCV64SEQZ {
3586 break
3587 }
3588 y := v_1.Args[0]
3589 v.reset(OpRISCV64CZERONEZ)
3590 v.AddArg2(x, y)
3591 return true
3592 }
3593
3594
3595 for {
3596 x := v_0
3597 if v_1.Op != OpRISCV64NEG {
3598 break
3599 }
3600 y := v_1.Args[0]
3601 v.reset(OpRISCV64CZEROEQZ)
3602 v.AddArg2(x, y)
3603 return true
3604 }
3605
3606
3607 for {
3608 x := v_0
3609 if x != v_1 {
3610 break
3611 }
3612 v.copyOf(x)
3613 return true
3614 }
3615
3616
3617 for {
3618 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
3619 break
3620 }
3621 v.reset(OpRISCV64MOVDconst)
3622 v.AuxInt = int64ToAuxInt(0)
3623 return true
3624 }
3625 return false
3626 }
3627 func rewriteValueRISCV64_OpRISCV64CZERONEZ(v *Value) bool {
3628 v_1 := v.Args[1]
3629 v_0 := v.Args[0]
3630
3631
3632 for {
3633 x := v_0
3634 if v_1.Op != OpRISCV64SNEZ {
3635 break
3636 }
3637 y := v_1.Args[0]
3638 v.reset(OpRISCV64CZERONEZ)
3639 v.AddArg2(x, y)
3640 return true
3641 }
3642
3643
3644 for {
3645 x := v_0
3646 if v_1.Op != OpRISCV64SEQZ {
3647 break
3648 }
3649 y := v_1.Args[0]
3650 v.reset(OpRISCV64CZEROEQZ)
3651 v.AddArg2(x, y)
3652 return true
3653 }
3654
3655
3656 for {
3657 x := v_0
3658 if v_1.Op != OpRISCV64NEG {
3659 break
3660 }
3661 y := v_1.Args[0]
3662 v.reset(OpRISCV64CZERONEZ)
3663 v.AddArg2(x, y)
3664 return true
3665 }
3666
3667
3668 for {
3669 x := v_0
3670 if x != v_1 {
3671 break
3672 }
3673 v.reset(OpRISCV64MOVDconst)
3674 v.AuxInt = int64ToAuxInt(0)
3675 return true
3676 }
3677
3678
3679 for {
3680 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
3681 break
3682 }
3683 v.reset(OpRISCV64MOVDconst)
3684 v.AuxInt = int64ToAuxInt(0)
3685 return true
3686 }
3687 return false
3688 }
3689 func rewriteValueRISCV64_OpRISCV64FADDD(v *Value) bool {
3690 v_1 := v.Args[1]
3691 v_0 := v.Args[0]
3692
3693
3694
3695 for {
3696 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3697 a := v_0
3698 if v_1.Op != OpRISCV64FMULD {
3699 continue
3700 }
3701 y := v_1.Args[1]
3702 x := v_1.Args[0]
3703 if !(a.Block.Func.useFMA(v)) {
3704 continue
3705 }
3706 v.reset(OpRISCV64FMADDD)
3707 v.AddArg3(x, y, a)
3708 return true
3709 }
3710 break
3711 }
3712 return false
3713 }
3714 func rewriteValueRISCV64_OpRISCV64FADDS(v *Value) bool {
3715 v_1 := v.Args[1]
3716 v_0 := v.Args[0]
3717
3718
3719
3720 for {
3721 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3722 a := v_0
3723 if v_1.Op != OpRISCV64FMULS {
3724 continue
3725 }
3726 y := v_1.Args[1]
3727 x := v_1.Args[0]
3728 if !(a.Block.Func.useFMA(v)) {
3729 continue
3730 }
3731 v.reset(OpRISCV64FMADDS)
3732 v.AddArg3(x, y, a)
3733 return true
3734 }
3735 break
3736 }
3737 return false
3738 }
3739 func rewriteValueRISCV64_OpRISCV64FCVTSD(v *Value) bool {
3740 v_0 := v.Args[0]
3741
3742
3743 for {
3744 if v_0.Op != OpRISCV64FABSD {
3745 break
3746 }
3747 v_0_0 := v_0.Args[0]
3748 if v_0_0.Op != OpRISCV64FCVTDS {
3749 break
3750 }
3751 X := v_0_0.Args[0]
3752 v.reset(OpRISCV64FABSS)
3753 v.AddArg(X)
3754 return true
3755 }
3756
3757
3758 for {
3759 if v_0.Op != OpRISCV64FSQRTD {
3760 break
3761 }
3762 v_0_0 := v_0.Args[0]
3763 if v_0_0.Op != OpRISCV64FCVTDS {
3764 break
3765 }
3766 X := v_0_0.Args[0]
3767 v.reset(OpRISCV64FSQRTS)
3768 v.AddArg(X)
3769 return true
3770 }
3771 return false
3772 }
3773 func rewriteValueRISCV64_OpRISCV64FEQD(v *Value) bool {
3774 v_1 := v.Args[1]
3775 v_0 := v.Args[0]
3776 b := v.Block
3777 typ := &b.Func.Config.Types
3778
3779
3780 for {
3781 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3782 x := v_0
3783 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(-1) {
3784 continue
3785 }
3786 v.reset(OpRISCV64ANDI)
3787 v.AuxInt = int64ToAuxInt(0b00_0000_0001)
3788 v0 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3789 v0.AddArg(x)
3790 v.AddArg(v0)
3791 return true
3792 }
3793 break
3794 }
3795
3796
3797 for {
3798 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3799 x := v_0
3800 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(1) {
3801 continue
3802 }
3803 v.reset(OpRISCV64SNEZ)
3804 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3805 v0.AuxInt = int64ToAuxInt(0b00_1000_0000)
3806 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3807 v1.AddArg(x)
3808 v0.AddArg(v1)
3809 v.AddArg(v0)
3810 return true
3811 }
3812 break
3813 }
3814 return false
3815 }
3816 func rewriteValueRISCV64_OpRISCV64FLED(v *Value) bool {
3817 v_1 := v.Args[1]
3818 v_0 := v.Args[0]
3819 b := v.Block
3820 typ := &b.Func.Config.Types
3821
3822
3823 for {
3824 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != -math.MaxFloat64 {
3825 break
3826 }
3827 x := v_1
3828 v.reset(OpRISCV64SNEZ)
3829 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3830 v0.AuxInt = int64ToAuxInt(0b00_1111_1110)
3831 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3832 v1.AddArg(x)
3833 v0.AddArg(v1)
3834 v.AddArg(v0)
3835 return true
3836 }
3837
3838
3839 for {
3840 x := v_0
3841 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.MaxFloat64 {
3842 break
3843 }
3844 v.reset(OpRISCV64SNEZ)
3845 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3846 v0.AuxInt = int64ToAuxInt(0b00_0111_1111)
3847 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3848 v1.AddArg(x)
3849 v0.AddArg(v1)
3850 v.AddArg(v0)
3851 return true
3852 }
3853
3854
3855 for {
3856 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != +0x1p-1022 {
3857 break
3858 }
3859 x := v_1
3860 v.reset(OpRISCV64SNEZ)
3861 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3862 v0.AuxInt = int64ToAuxInt(0b00_1100_0000)
3863 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3864 v1.AddArg(x)
3865 v0.AddArg(v1)
3866 v.AddArg(v0)
3867 return true
3868 }
3869
3870
3871 for {
3872 x := v_0
3873 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != -0x1p-1022 {
3874 break
3875 }
3876 v.reset(OpRISCV64SNEZ)
3877 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3878 v0.AuxInt = int64ToAuxInt(0b00_0000_0011)
3879 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3880 v1.AddArg(x)
3881 v0.AddArg(v1)
3882 v.AddArg(v0)
3883 return true
3884 }
3885 return false
3886 }
3887 func rewriteValueRISCV64_OpRISCV64FLTD(v *Value) bool {
3888 v_1 := v.Args[1]
3889 v_0 := v.Args[0]
3890 b := v.Block
3891 typ := &b.Func.Config.Types
3892
3893
3894 for {
3895 x := v_0
3896 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != -math.MaxFloat64 {
3897 break
3898 }
3899 v.reset(OpRISCV64ANDI)
3900 v.AuxInt = int64ToAuxInt(0b00_0000_0001)
3901 v0 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3902 v0.AddArg(x)
3903 v.AddArg(v0)
3904 return true
3905 }
3906
3907
3908 for {
3909 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != math.MaxFloat64 {
3910 break
3911 }
3912 x := v_1
3913 v.reset(OpRISCV64SNEZ)
3914 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3915 v0.AuxInt = int64ToAuxInt(0b00_1000_0000)
3916 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3917 v1.AddArg(x)
3918 v0.AddArg(v1)
3919 v.AddArg(v0)
3920 return true
3921 }
3922
3923
3924 for {
3925 x := v_0
3926 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != +0x1p-1022 {
3927 break
3928 }
3929 v.reset(OpRISCV64SNEZ)
3930 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3931 v0.AuxInt = int64ToAuxInt(0b00_0011_1111)
3932 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3933 v1.AddArg(x)
3934 v0.AddArg(v1)
3935 v.AddArg(v0)
3936 return true
3937 }
3938
3939
3940 for {
3941 if v_0.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_0.AuxInt) != -0x1p-1022 {
3942 break
3943 }
3944 x := v_1
3945 v.reset(OpRISCV64SNEZ)
3946 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
3947 v0.AuxInt = int64ToAuxInt(0b00_1111_1100)
3948 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
3949 v1.AddArg(x)
3950 v0.AddArg(v1)
3951 v.AddArg(v0)
3952 return true
3953 }
3954 return false
3955 }
3956 func rewriteValueRISCV64_OpRISCV64FMADDD(v *Value) bool {
3957 v_2 := v.Args[2]
3958 v_1 := v.Args[1]
3959 v_0 := v.Args[0]
3960
3961
3962
3963 for {
3964 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3965 neg := v_0
3966 if neg.Op != OpRISCV64FNEGD {
3967 continue
3968 }
3969 x := neg.Args[0]
3970 y := v_1
3971 z := v_2
3972 if !(neg.Uses == 1) {
3973 continue
3974 }
3975 v.reset(OpRISCV64FNMSUBD)
3976 v.AddArg3(x, y, z)
3977 return true
3978 }
3979 break
3980 }
3981
3982
3983
3984 for {
3985 x := v_0
3986 y := v_1
3987 neg := v_2
3988 if neg.Op != OpRISCV64FNEGD {
3989 break
3990 }
3991 z := neg.Args[0]
3992 if !(neg.Uses == 1) {
3993 break
3994 }
3995 v.reset(OpRISCV64FMSUBD)
3996 v.AddArg3(x, y, z)
3997 return true
3998 }
3999 return false
4000 }
4001 func rewriteValueRISCV64_OpRISCV64FMADDS(v *Value) bool {
4002 v_2 := v.Args[2]
4003 v_1 := v.Args[1]
4004 v_0 := v.Args[0]
4005
4006
4007
4008 for {
4009 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4010 neg := v_0
4011 if neg.Op != OpRISCV64FNEGS {
4012 continue
4013 }
4014 x := neg.Args[0]
4015 y := v_1
4016 z := v_2
4017 if !(neg.Uses == 1) {
4018 continue
4019 }
4020 v.reset(OpRISCV64FNMSUBS)
4021 v.AddArg3(x, y, z)
4022 return true
4023 }
4024 break
4025 }
4026
4027
4028
4029 for {
4030 x := v_0
4031 y := v_1
4032 neg := v_2
4033 if neg.Op != OpRISCV64FNEGS {
4034 break
4035 }
4036 z := neg.Args[0]
4037 if !(neg.Uses == 1) {
4038 break
4039 }
4040 v.reset(OpRISCV64FMSUBS)
4041 v.AddArg3(x, y, z)
4042 return true
4043 }
4044 return false
4045 }
4046 func rewriteValueRISCV64_OpRISCV64FMOVDload(v *Value) bool {
4047 v_1 := v.Args[1]
4048 v_0 := v.Args[0]
4049 b := v.Block
4050 config := b.Func.Config
4051
4052
4053
4054 for {
4055 off1 := auxIntToInt32(v.AuxInt)
4056 sym1 := auxToSym(v.Aux)
4057 if v_0.Op != OpRISCV64MOVaddr {
4058 break
4059 }
4060 off2 := auxIntToInt32(v_0.AuxInt)
4061 sym2 := auxToSym(v_0.Aux)
4062 base := v_0.Args[0]
4063 mem := v_1
4064 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4065 break
4066 }
4067 v.reset(OpRISCV64FMOVDload)
4068 v.AuxInt = int32ToAuxInt(off1 + off2)
4069 v.Aux = symToAux(mergeSym(sym1, sym2))
4070 v.AddArg2(base, mem)
4071 return true
4072 }
4073
4074
4075
4076 for {
4077 off1 := auxIntToInt32(v.AuxInt)
4078 sym := auxToSym(v.Aux)
4079 if v_0.Op != OpRISCV64ADDI {
4080 break
4081 }
4082 off2 := auxIntToInt64(v_0.AuxInt)
4083 base := v_0.Args[0]
4084 mem := v_1
4085 if !(is32Bit(int64(off1) + off2)) {
4086 break
4087 }
4088 v.reset(OpRISCV64FMOVDload)
4089 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4090 v.Aux = symToAux(sym)
4091 v.AddArg2(base, mem)
4092 return true
4093 }
4094
4095
4096
4097 for {
4098 off := auxIntToInt32(v.AuxInt)
4099 sym := auxToSym(v.Aux)
4100 ptr1 := v_0
4101 if v_1.Op != OpRISCV64MOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
4102 break
4103 }
4104 x := v_1.Args[1]
4105 ptr2 := v_1.Args[0]
4106 if !(isSamePtr(ptr1, ptr2)) {
4107 break
4108 }
4109 v.reset(OpRISCV64FMVDX)
4110 v.AddArg(x)
4111 return true
4112 }
4113 return false
4114 }
4115 func rewriteValueRISCV64_OpRISCV64FMOVDstore(v *Value) bool {
4116 v_2 := v.Args[2]
4117 v_1 := v.Args[1]
4118 v_0 := v.Args[0]
4119 b := v.Block
4120 config := b.Func.Config
4121
4122
4123
4124 for {
4125 off1 := auxIntToInt32(v.AuxInt)
4126 sym1 := auxToSym(v.Aux)
4127 if v_0.Op != OpRISCV64MOVaddr {
4128 break
4129 }
4130 off2 := auxIntToInt32(v_0.AuxInt)
4131 sym2 := auxToSym(v_0.Aux)
4132 base := v_0.Args[0]
4133 val := v_1
4134 mem := v_2
4135 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4136 break
4137 }
4138 v.reset(OpRISCV64FMOVDstore)
4139 v.AuxInt = int32ToAuxInt(off1 + off2)
4140 v.Aux = symToAux(mergeSym(sym1, sym2))
4141 v.AddArg3(base, val, mem)
4142 return true
4143 }
4144
4145
4146
4147 for {
4148 off1 := auxIntToInt32(v.AuxInt)
4149 sym := auxToSym(v.Aux)
4150 if v_0.Op != OpRISCV64ADDI {
4151 break
4152 }
4153 off2 := auxIntToInt64(v_0.AuxInt)
4154 base := v_0.Args[0]
4155 val := v_1
4156 mem := v_2
4157 if !(is32Bit(int64(off1) + off2)) {
4158 break
4159 }
4160 v.reset(OpRISCV64FMOVDstore)
4161 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4162 v.Aux = symToAux(sym)
4163 v.AddArg3(base, val, mem)
4164 return true
4165 }
4166 return false
4167 }
4168 func rewriteValueRISCV64_OpRISCV64FMOVWload(v *Value) bool {
4169 v_1 := v.Args[1]
4170 v_0 := v.Args[0]
4171 b := v.Block
4172 config := b.Func.Config
4173
4174
4175
4176 for {
4177 off1 := auxIntToInt32(v.AuxInt)
4178 sym1 := auxToSym(v.Aux)
4179 if v_0.Op != OpRISCV64MOVaddr {
4180 break
4181 }
4182 off2 := auxIntToInt32(v_0.AuxInt)
4183 sym2 := auxToSym(v_0.Aux)
4184 base := v_0.Args[0]
4185 mem := v_1
4186 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4187 break
4188 }
4189 v.reset(OpRISCV64FMOVWload)
4190 v.AuxInt = int32ToAuxInt(off1 + off2)
4191 v.Aux = symToAux(mergeSym(sym1, sym2))
4192 v.AddArg2(base, mem)
4193 return true
4194 }
4195
4196
4197
4198 for {
4199 off1 := auxIntToInt32(v.AuxInt)
4200 sym := auxToSym(v.Aux)
4201 if v_0.Op != OpRISCV64ADDI {
4202 break
4203 }
4204 off2 := auxIntToInt64(v_0.AuxInt)
4205 base := v_0.Args[0]
4206 mem := v_1
4207 if !(is32Bit(int64(off1) + off2)) {
4208 break
4209 }
4210 v.reset(OpRISCV64FMOVWload)
4211 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4212 v.Aux = symToAux(sym)
4213 v.AddArg2(base, mem)
4214 return true
4215 }
4216
4217
4218
4219 for {
4220 off := auxIntToInt32(v.AuxInt)
4221 sym := auxToSym(v.Aux)
4222 ptr1 := v_0
4223 if v_1.Op != OpRISCV64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
4224 break
4225 }
4226 x := v_1.Args[1]
4227 ptr2 := v_1.Args[0]
4228 if !(isSamePtr(ptr1, ptr2)) {
4229 break
4230 }
4231 v.reset(OpRISCV64FMVSX)
4232 v.AddArg(x)
4233 return true
4234 }
4235 return false
4236 }
4237 func rewriteValueRISCV64_OpRISCV64FMOVWstore(v *Value) bool {
4238 v_2 := v.Args[2]
4239 v_1 := v.Args[1]
4240 v_0 := v.Args[0]
4241 b := v.Block
4242 config := b.Func.Config
4243
4244
4245
4246 for {
4247 off1 := auxIntToInt32(v.AuxInt)
4248 sym1 := auxToSym(v.Aux)
4249 if v_0.Op != OpRISCV64MOVaddr {
4250 break
4251 }
4252 off2 := auxIntToInt32(v_0.AuxInt)
4253 sym2 := auxToSym(v_0.Aux)
4254 base := v_0.Args[0]
4255 val := v_1
4256 mem := v_2
4257 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4258 break
4259 }
4260 v.reset(OpRISCV64FMOVWstore)
4261 v.AuxInt = int32ToAuxInt(off1 + off2)
4262 v.Aux = symToAux(mergeSym(sym1, sym2))
4263 v.AddArg3(base, val, mem)
4264 return true
4265 }
4266
4267
4268
4269 for {
4270 off1 := auxIntToInt32(v.AuxInt)
4271 sym := auxToSym(v.Aux)
4272 if v_0.Op != OpRISCV64ADDI {
4273 break
4274 }
4275 off2 := auxIntToInt64(v_0.AuxInt)
4276 base := v_0.Args[0]
4277 val := v_1
4278 mem := v_2
4279 if !(is32Bit(int64(off1) + off2)) {
4280 break
4281 }
4282 v.reset(OpRISCV64FMOVWstore)
4283 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4284 v.Aux = symToAux(sym)
4285 v.AddArg3(base, val, mem)
4286 return true
4287 }
4288 return false
4289 }
4290 func rewriteValueRISCV64_OpRISCV64FMSUBD(v *Value) bool {
4291 v_2 := v.Args[2]
4292 v_1 := v.Args[1]
4293 v_0 := v.Args[0]
4294
4295
4296
4297 for {
4298 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4299 neg := v_0
4300 if neg.Op != OpRISCV64FNEGD {
4301 continue
4302 }
4303 x := neg.Args[0]
4304 y := v_1
4305 z := v_2
4306 if !(neg.Uses == 1) {
4307 continue
4308 }
4309 v.reset(OpRISCV64FNMADDD)
4310 v.AddArg3(x, y, z)
4311 return true
4312 }
4313 break
4314 }
4315
4316
4317
4318 for {
4319 x := v_0
4320 y := v_1
4321 neg := v_2
4322 if neg.Op != OpRISCV64FNEGD {
4323 break
4324 }
4325 z := neg.Args[0]
4326 if !(neg.Uses == 1) {
4327 break
4328 }
4329 v.reset(OpRISCV64FMADDD)
4330 v.AddArg3(x, y, z)
4331 return true
4332 }
4333 return false
4334 }
4335 func rewriteValueRISCV64_OpRISCV64FMSUBS(v *Value) bool {
4336 v_2 := v.Args[2]
4337 v_1 := v.Args[1]
4338 v_0 := v.Args[0]
4339
4340
4341
4342 for {
4343 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4344 neg := v_0
4345 if neg.Op != OpRISCV64FNEGS {
4346 continue
4347 }
4348 x := neg.Args[0]
4349 y := v_1
4350 z := v_2
4351 if !(neg.Uses == 1) {
4352 continue
4353 }
4354 v.reset(OpRISCV64FNMADDS)
4355 v.AddArg3(x, y, z)
4356 return true
4357 }
4358 break
4359 }
4360
4361
4362
4363 for {
4364 x := v_0
4365 y := v_1
4366 neg := v_2
4367 if neg.Op != OpRISCV64FNEGS {
4368 break
4369 }
4370 z := neg.Args[0]
4371 if !(neg.Uses == 1) {
4372 break
4373 }
4374 v.reset(OpRISCV64FMADDS)
4375 v.AddArg3(x, y, z)
4376 return true
4377 }
4378 return false
4379 }
4380 func rewriteValueRISCV64_OpRISCV64FNED(v *Value) bool {
4381 v_1 := v.Args[1]
4382 v_0 := v.Args[0]
4383 b := v.Block
4384 typ := &b.Func.Config.Types
4385
4386
4387 for {
4388 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4389 x := v_0
4390 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(-1) {
4391 continue
4392 }
4393 v.reset(OpRISCV64SEQZ)
4394 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
4395 v0.AuxInt = int64ToAuxInt(0b00_0000_0001)
4396 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
4397 v1.AddArg(x)
4398 v0.AddArg(v1)
4399 v.AddArg(v0)
4400 return true
4401 }
4402 break
4403 }
4404
4405
4406 for {
4407 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4408 x := v_0
4409 if v_1.Op != OpRISCV64FMOVDconst || auxIntToFloat64(v_1.AuxInt) != math.Inf(1) {
4410 continue
4411 }
4412 v.reset(OpRISCV64SEQZ)
4413 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
4414 v0.AuxInt = int64ToAuxInt(0b00_1000_0000)
4415 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
4416 v1.AddArg(x)
4417 v0.AddArg(v1)
4418 v.AddArg(v0)
4419 return true
4420 }
4421 break
4422 }
4423 return false
4424 }
4425 func rewriteValueRISCV64_OpRISCV64FNMADDD(v *Value) bool {
4426 v_2 := v.Args[2]
4427 v_1 := v.Args[1]
4428 v_0 := v.Args[0]
4429
4430
4431
4432 for {
4433 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4434 neg := v_0
4435 if neg.Op != OpRISCV64FNEGD {
4436 continue
4437 }
4438 x := neg.Args[0]
4439 y := v_1
4440 z := v_2
4441 if !(neg.Uses == 1) {
4442 continue
4443 }
4444 v.reset(OpRISCV64FMSUBD)
4445 v.AddArg3(x, y, z)
4446 return true
4447 }
4448 break
4449 }
4450
4451
4452
4453 for {
4454 x := v_0
4455 y := v_1
4456 neg := v_2
4457 if neg.Op != OpRISCV64FNEGD {
4458 break
4459 }
4460 z := neg.Args[0]
4461 if !(neg.Uses == 1) {
4462 break
4463 }
4464 v.reset(OpRISCV64FNMSUBD)
4465 v.AddArg3(x, y, z)
4466 return true
4467 }
4468 return false
4469 }
4470 func rewriteValueRISCV64_OpRISCV64FNMADDS(v *Value) bool {
4471 v_2 := v.Args[2]
4472 v_1 := v.Args[1]
4473 v_0 := v.Args[0]
4474
4475
4476
4477 for {
4478 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4479 neg := v_0
4480 if neg.Op != OpRISCV64FNEGS {
4481 continue
4482 }
4483 x := neg.Args[0]
4484 y := v_1
4485 z := v_2
4486 if !(neg.Uses == 1) {
4487 continue
4488 }
4489 v.reset(OpRISCV64FMSUBS)
4490 v.AddArg3(x, y, z)
4491 return true
4492 }
4493 break
4494 }
4495
4496
4497
4498 for {
4499 x := v_0
4500 y := v_1
4501 neg := v_2
4502 if neg.Op != OpRISCV64FNEGS {
4503 break
4504 }
4505 z := neg.Args[0]
4506 if !(neg.Uses == 1) {
4507 break
4508 }
4509 v.reset(OpRISCV64FNMSUBS)
4510 v.AddArg3(x, y, z)
4511 return true
4512 }
4513 return false
4514 }
4515 func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *Value) bool {
4516 v_2 := v.Args[2]
4517 v_1 := v.Args[1]
4518 v_0 := v.Args[0]
4519
4520
4521
4522 for {
4523 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4524 neg := v_0
4525 if neg.Op != OpRISCV64FNEGD {
4526 continue
4527 }
4528 x := neg.Args[0]
4529 y := v_1
4530 z := v_2
4531 if !(neg.Uses == 1) {
4532 continue
4533 }
4534 v.reset(OpRISCV64FMADDD)
4535 v.AddArg3(x, y, z)
4536 return true
4537 }
4538 break
4539 }
4540
4541
4542
4543 for {
4544 x := v_0
4545 y := v_1
4546 neg := v_2
4547 if neg.Op != OpRISCV64FNEGD {
4548 break
4549 }
4550 z := neg.Args[0]
4551 if !(neg.Uses == 1) {
4552 break
4553 }
4554 v.reset(OpRISCV64FNMADDD)
4555 v.AddArg3(x, y, z)
4556 return true
4557 }
4558 return false
4559 }
4560 func rewriteValueRISCV64_OpRISCV64FNMSUBS(v *Value) bool {
4561 v_2 := v.Args[2]
4562 v_1 := v.Args[1]
4563 v_0 := v.Args[0]
4564
4565
4566
4567 for {
4568 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4569 neg := v_0
4570 if neg.Op != OpRISCV64FNEGS {
4571 continue
4572 }
4573 x := neg.Args[0]
4574 y := v_1
4575 z := v_2
4576 if !(neg.Uses == 1) {
4577 continue
4578 }
4579 v.reset(OpRISCV64FMADDS)
4580 v.AddArg3(x, y, z)
4581 return true
4582 }
4583 break
4584 }
4585
4586
4587
4588 for {
4589 x := v_0
4590 y := v_1
4591 neg := v_2
4592 if neg.Op != OpRISCV64FNEGS {
4593 break
4594 }
4595 z := neg.Args[0]
4596 if !(neg.Uses == 1) {
4597 break
4598 }
4599 v.reset(OpRISCV64FNMADDS)
4600 v.AddArg3(x, y, z)
4601 return true
4602 }
4603 return false
4604 }
4605 func rewriteValueRISCV64_OpRISCV64FSUBD(v *Value) bool {
4606 v_1 := v.Args[1]
4607 v_0 := v.Args[0]
4608
4609
4610
4611 for {
4612 a := v_0
4613 if v_1.Op != OpRISCV64FMULD {
4614 break
4615 }
4616 y := v_1.Args[1]
4617 x := v_1.Args[0]
4618 if !(a.Block.Func.useFMA(v)) {
4619 break
4620 }
4621 v.reset(OpRISCV64FNMSUBD)
4622 v.AddArg3(x, y, a)
4623 return true
4624 }
4625
4626
4627
4628 for {
4629 if v_0.Op != OpRISCV64FMULD {
4630 break
4631 }
4632 y := v_0.Args[1]
4633 x := v_0.Args[0]
4634 a := v_1
4635 if !(a.Block.Func.useFMA(v)) {
4636 break
4637 }
4638 v.reset(OpRISCV64FMSUBD)
4639 v.AddArg3(x, y, a)
4640 return true
4641 }
4642 return false
4643 }
4644 func rewriteValueRISCV64_OpRISCV64FSUBS(v *Value) bool {
4645 v_1 := v.Args[1]
4646 v_0 := v.Args[0]
4647
4648
4649
4650 for {
4651 a := v_0
4652 if v_1.Op != OpRISCV64FMULS {
4653 break
4654 }
4655 y := v_1.Args[1]
4656 x := v_1.Args[0]
4657 if !(a.Block.Func.useFMA(v)) {
4658 break
4659 }
4660 v.reset(OpRISCV64FNMSUBS)
4661 v.AddArg3(x, y, a)
4662 return true
4663 }
4664
4665
4666
4667 for {
4668 if v_0.Op != OpRISCV64FMULS {
4669 break
4670 }
4671 y := v_0.Args[1]
4672 x := v_0.Args[0]
4673 a := v_1
4674 if !(a.Block.Func.useFMA(v)) {
4675 break
4676 }
4677 v.reset(OpRISCV64FMSUBS)
4678 v.AddArg3(x, y, a)
4679 return true
4680 }
4681 return false
4682 }
4683 func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsCR(v *Value) bool {
4684 v_1 := v.Args[1]
4685 v_0 := v.Args[0]
4686
4687
4688 for {
4689 kind := auxIntToInt64(v.AuxInt)
4690 p := auxToPanicBoundsC(v.Aux)
4691 if v_0.Op != OpRISCV64MOVDconst {
4692 break
4693 }
4694 c := auxIntToInt64(v_0.AuxInt)
4695 mem := v_1
4696 v.reset(OpRISCV64LoweredPanicBoundsCC)
4697 v.AuxInt = int64ToAuxInt(kind)
4698 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: p.C, Cy: c})
4699 v.AddArg(mem)
4700 return true
4701 }
4702 return false
4703 }
4704 func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRC(v *Value) bool {
4705 v_1 := v.Args[1]
4706 v_0 := v.Args[0]
4707
4708
4709 for {
4710 kind := auxIntToInt64(v.AuxInt)
4711 p := auxToPanicBoundsC(v.Aux)
4712 if v_0.Op != OpRISCV64MOVDconst {
4713 break
4714 }
4715 c := auxIntToInt64(v_0.AuxInt)
4716 mem := v_1
4717 v.reset(OpRISCV64LoweredPanicBoundsCC)
4718 v.AuxInt = int64ToAuxInt(kind)
4719 v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: c, Cy: p.C})
4720 v.AddArg(mem)
4721 return true
4722 }
4723 return false
4724 }
4725 func rewriteValueRISCV64_OpRISCV64LoweredPanicBoundsRR(v *Value) bool {
4726 v_2 := v.Args[2]
4727 v_1 := v.Args[1]
4728 v_0 := v.Args[0]
4729
4730
4731 for {
4732 kind := auxIntToInt64(v.AuxInt)
4733 x := v_0
4734 if v_1.Op != OpRISCV64MOVDconst {
4735 break
4736 }
4737 c := auxIntToInt64(v_1.AuxInt)
4738 mem := v_2
4739 v.reset(OpRISCV64LoweredPanicBoundsRC)
4740 v.AuxInt = int64ToAuxInt(kind)
4741 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
4742 v.AddArg2(x, mem)
4743 return true
4744 }
4745
4746
4747 for {
4748 kind := auxIntToInt64(v.AuxInt)
4749 if v_0.Op != OpRISCV64MOVDconst {
4750 break
4751 }
4752 c := auxIntToInt64(v_0.AuxInt)
4753 y := v_1
4754 mem := v_2
4755 v.reset(OpRISCV64LoweredPanicBoundsCR)
4756 v.AuxInt = int64ToAuxInt(kind)
4757 v.Aux = panicBoundsCToAux(PanicBoundsC{C: c})
4758 v.AddArg2(y, mem)
4759 return true
4760 }
4761 return false
4762 }
4763 func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
4764 v_1 := v.Args[1]
4765 v_0 := v.Args[0]
4766 b := v.Block
4767 config := b.Func.Config
4768
4769
4770
4771 for {
4772 off1 := auxIntToInt32(v.AuxInt)
4773 sym1 := auxToSym(v.Aux)
4774 if v_0.Op != OpRISCV64MOVaddr {
4775 break
4776 }
4777 off2 := auxIntToInt32(v_0.AuxInt)
4778 sym2 := auxToSym(v_0.Aux)
4779 base := v_0.Args[0]
4780 mem := v_1
4781 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4782 break
4783 }
4784 v.reset(OpRISCV64MOVBUload)
4785 v.AuxInt = int32ToAuxInt(off1 + off2)
4786 v.Aux = symToAux(mergeSym(sym1, sym2))
4787 v.AddArg2(base, mem)
4788 return true
4789 }
4790
4791
4792
4793 for {
4794 off1 := auxIntToInt32(v.AuxInt)
4795 sym := auxToSym(v.Aux)
4796 if v_0.Op != OpRISCV64ADDI {
4797 break
4798 }
4799 off2 := auxIntToInt64(v_0.AuxInt)
4800 base := v_0.Args[0]
4801 mem := v_1
4802 if !(is32Bit(int64(off1) + off2)) {
4803 break
4804 }
4805 v.reset(OpRISCV64MOVBUload)
4806 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4807 v.Aux = symToAux(sym)
4808 v.AddArg2(base, mem)
4809 return true
4810 }
4811
4812
4813
4814 for {
4815 off := auxIntToInt32(v.AuxInt)
4816 sym := auxToSym(v.Aux)
4817 ptr1 := v_0
4818 if v_1.Op != OpRISCV64MOVBstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
4819 break
4820 }
4821 x := v_1.Args[1]
4822 ptr2 := v_1.Args[0]
4823 if !(isSamePtr(ptr1, ptr2)) {
4824 break
4825 }
4826 v.reset(OpRISCV64MOVBUreg)
4827 v.AddArg(x)
4828 return true
4829 }
4830 return false
4831 }
4832 func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
4833 v_0 := v.Args[0]
4834 b := v.Block
4835
4836
4837 for {
4838 x := v_0
4839 if x.Op != OpRISCV64FLES {
4840 break
4841 }
4842 v.copyOf(x)
4843 return true
4844 }
4845
4846
4847 for {
4848 x := v_0
4849 if x.Op != OpRISCV64FLTS {
4850 break
4851 }
4852 v.copyOf(x)
4853 return true
4854 }
4855
4856
4857 for {
4858 x := v_0
4859 if x.Op != OpRISCV64FEQS {
4860 break
4861 }
4862 v.copyOf(x)
4863 return true
4864 }
4865
4866
4867 for {
4868 x := v_0
4869 if x.Op != OpRISCV64FNES {
4870 break
4871 }
4872 v.copyOf(x)
4873 return true
4874 }
4875
4876
4877 for {
4878 x := v_0
4879 if x.Op != OpRISCV64FLED {
4880 break
4881 }
4882 v.copyOf(x)
4883 return true
4884 }
4885
4886
4887 for {
4888 x := v_0
4889 if x.Op != OpRISCV64FLTD {
4890 break
4891 }
4892 v.copyOf(x)
4893 return true
4894 }
4895
4896
4897 for {
4898 x := v_0
4899 if x.Op != OpRISCV64FEQD {
4900 break
4901 }
4902 v.copyOf(x)
4903 return true
4904 }
4905
4906
4907 for {
4908 x := v_0
4909 if x.Op != OpRISCV64FNED {
4910 break
4911 }
4912 v.copyOf(x)
4913 return true
4914 }
4915
4916
4917 for {
4918 x := v_0
4919 if x.Op != OpRISCV64SEQZ {
4920 break
4921 }
4922 v.copyOf(x)
4923 return true
4924 }
4925
4926
4927 for {
4928 x := v_0
4929 if x.Op != OpRISCV64SNEZ {
4930 break
4931 }
4932 v.copyOf(x)
4933 return true
4934 }
4935
4936
4937 for {
4938 x := v_0
4939 if x.Op != OpRISCV64SLT {
4940 break
4941 }
4942 v.copyOf(x)
4943 return true
4944 }
4945
4946
4947 for {
4948 x := v_0
4949 if x.Op != OpRISCV64SLTU {
4950 break
4951 }
4952 v.copyOf(x)
4953 return true
4954 }
4955
4956
4957
4958 for {
4959 x := v_0
4960 if x.Op != OpRISCV64ANDI {
4961 break
4962 }
4963 c := auxIntToInt64(x.AuxInt)
4964 if !(c >= 0 && int64(uint8(c)) == c) {
4965 break
4966 }
4967 v.copyOf(x)
4968 return true
4969 }
4970
4971
4972
4973 for {
4974 if v_0.Op != OpRISCV64ANDI {
4975 break
4976 }
4977 c := auxIntToInt64(v_0.AuxInt)
4978 x := v_0.Args[0]
4979 if !(c < 0) {
4980 break
4981 }
4982 v.reset(OpRISCV64ANDI)
4983 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
4984 v.AddArg(x)
4985 return true
4986 }
4987
4988
4989 for {
4990 if v_0.Op != OpRISCV64MOVDconst {
4991 break
4992 }
4993 c := auxIntToInt64(v_0.AuxInt)
4994 v.reset(OpRISCV64MOVDconst)
4995 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
4996 return true
4997 }
4998
4999
5000 for {
5001 x := v_0
5002 if x.Op != OpRISCV64MOVBUload {
5003 break
5004 }
5005 v.reset(OpRISCV64MOVDreg)
5006 v.AddArg(x)
5007 return true
5008 }
5009
5010
5011 for {
5012 x := v_0
5013 if x.Op != OpSelect0 {
5014 break
5015 }
5016 x_0 := x.Args[0]
5017 if x_0.Op != OpRISCV64LoweredAtomicLoad8 {
5018 break
5019 }
5020 v.reset(OpRISCV64MOVDreg)
5021 v.AddArg(x)
5022 return true
5023 }
5024
5025
5026 for {
5027 x := v_0
5028 if x.Op != OpSelect0 {
5029 break
5030 }
5031 x_0 := x.Args[0]
5032 if x_0.Op != OpRISCV64LoweredAtomicCas32 {
5033 break
5034 }
5035 v.reset(OpRISCV64MOVDreg)
5036 v.AddArg(x)
5037 return true
5038 }
5039
5040
5041 for {
5042 x := v_0
5043 if x.Op != OpSelect0 {
5044 break
5045 }
5046 x_0 := x.Args[0]
5047 if x_0.Op != OpRISCV64LoweredAtomicCas64 {
5048 break
5049 }
5050 v.reset(OpRISCV64MOVDreg)
5051 v.AddArg(x)
5052 return true
5053 }
5054
5055
5056 for {
5057 x := v_0
5058 if x.Op != OpRISCV64MOVBUreg {
5059 break
5060 }
5061 v.reset(OpRISCV64MOVDreg)
5062 v.AddArg(x)
5063 return true
5064 }
5065
5066
5067
5068 for {
5069 t := v.Type
5070 x := v_0
5071 if x.Op != OpRISCV64MOVBload {
5072 break
5073 }
5074 off := auxIntToInt32(x.AuxInt)
5075 sym := auxToSym(x.Aux)
5076 mem := x.Args[1]
5077 ptr := x.Args[0]
5078 if !(x.Uses == 1 && clobber(x)) {
5079 break
5080 }
5081 b = x.Block
5082 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBUload, t)
5083 v.copyOf(v0)
5084 v0.AuxInt = int32ToAuxInt(off)
5085 v0.Aux = symToAux(sym)
5086 v0.AddArg2(ptr, mem)
5087 return true
5088 }
5089 return false
5090 }
5091 func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
5092 v_1 := v.Args[1]
5093 v_0 := v.Args[0]
5094 b := v.Block
5095 config := b.Func.Config
5096
5097
5098
5099 for {
5100 off1 := auxIntToInt32(v.AuxInt)
5101 sym1 := auxToSym(v.Aux)
5102 if v_0.Op != OpRISCV64MOVaddr {
5103 break
5104 }
5105 off2 := auxIntToInt32(v_0.AuxInt)
5106 sym2 := auxToSym(v_0.Aux)
5107 base := v_0.Args[0]
5108 mem := v_1
5109 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5110 break
5111 }
5112 v.reset(OpRISCV64MOVBload)
5113 v.AuxInt = int32ToAuxInt(off1 + off2)
5114 v.Aux = symToAux(mergeSym(sym1, sym2))
5115 v.AddArg2(base, mem)
5116 return true
5117 }
5118
5119
5120
5121 for {
5122 off1 := auxIntToInt32(v.AuxInt)
5123 sym := auxToSym(v.Aux)
5124 if v_0.Op != OpRISCV64ADDI {
5125 break
5126 }
5127 off2 := auxIntToInt64(v_0.AuxInt)
5128 base := v_0.Args[0]
5129 mem := v_1
5130 if !(is32Bit(int64(off1) + off2)) {
5131 break
5132 }
5133 v.reset(OpRISCV64MOVBload)
5134 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5135 v.Aux = symToAux(sym)
5136 v.AddArg2(base, mem)
5137 return true
5138 }
5139
5140
5141
5142 for {
5143 off := auxIntToInt32(v.AuxInt)
5144 sym := auxToSym(v.Aux)
5145 ptr1 := v_0
5146 if v_1.Op != OpRISCV64MOVBstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5147 break
5148 }
5149 x := v_1.Args[1]
5150 ptr2 := v_1.Args[0]
5151 if !(isSamePtr(ptr1, ptr2)) {
5152 break
5153 }
5154 v.reset(OpRISCV64MOVBreg)
5155 v.AddArg(x)
5156 return true
5157 }
5158 return false
5159 }
5160 func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
5161 v_0 := v.Args[0]
5162 b := v.Block
5163
5164
5165
5166 for {
5167 x := v_0
5168 if x.Op != OpRISCV64ANDI {
5169 break
5170 }
5171 c := auxIntToInt64(x.AuxInt)
5172 if !(c >= 0 && int64(int8(c)) == c) {
5173 break
5174 }
5175 v.copyOf(x)
5176 return true
5177 }
5178
5179
5180 for {
5181 if v_0.Op != OpRISCV64MOVDconst {
5182 break
5183 }
5184 c := auxIntToInt64(v_0.AuxInt)
5185 v.reset(OpRISCV64MOVDconst)
5186 v.AuxInt = int64ToAuxInt(int64(int8(c)))
5187 return true
5188 }
5189
5190
5191 for {
5192 x := v_0
5193 if x.Op != OpRISCV64MOVBload {
5194 break
5195 }
5196 v.reset(OpRISCV64MOVDreg)
5197 v.AddArg(x)
5198 return true
5199 }
5200
5201
5202 for {
5203 x := v_0
5204 if x.Op != OpRISCV64MOVBreg {
5205 break
5206 }
5207 v.reset(OpRISCV64MOVDreg)
5208 v.AddArg(x)
5209 return true
5210 }
5211
5212
5213
5214 for {
5215 t := v.Type
5216 x := v_0
5217 if x.Op != OpRISCV64MOVBUload {
5218 break
5219 }
5220 off := auxIntToInt32(x.AuxInt)
5221 sym := auxToSym(x.Aux)
5222 mem := x.Args[1]
5223 ptr := x.Args[0]
5224 if !(x.Uses == 1 && clobber(x)) {
5225 break
5226 }
5227 b = x.Block
5228 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBload, t)
5229 v.copyOf(v0)
5230 v0.AuxInt = int32ToAuxInt(off)
5231 v0.Aux = symToAux(sym)
5232 v0.AddArg2(ptr, mem)
5233 return true
5234 }
5235 return false
5236 }
5237 func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
5238 v_2 := v.Args[2]
5239 v_1 := v.Args[1]
5240 v_0 := v.Args[0]
5241 b := v.Block
5242 config := b.Func.Config
5243
5244
5245
5246 for {
5247 off1 := auxIntToInt32(v.AuxInt)
5248 sym1 := auxToSym(v.Aux)
5249 if v_0.Op != OpRISCV64MOVaddr {
5250 break
5251 }
5252 off2 := auxIntToInt32(v_0.AuxInt)
5253 sym2 := auxToSym(v_0.Aux)
5254 base := v_0.Args[0]
5255 val := v_1
5256 mem := v_2
5257 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5258 break
5259 }
5260 v.reset(OpRISCV64MOVBstore)
5261 v.AuxInt = int32ToAuxInt(off1 + off2)
5262 v.Aux = symToAux(mergeSym(sym1, sym2))
5263 v.AddArg3(base, val, mem)
5264 return true
5265 }
5266
5267
5268
5269 for {
5270 off1 := auxIntToInt32(v.AuxInt)
5271 sym := auxToSym(v.Aux)
5272 if v_0.Op != OpRISCV64ADDI {
5273 break
5274 }
5275 off2 := auxIntToInt64(v_0.AuxInt)
5276 base := v_0.Args[0]
5277 val := v_1
5278 mem := v_2
5279 if !(is32Bit(int64(off1) + off2)) {
5280 break
5281 }
5282 v.reset(OpRISCV64MOVBstore)
5283 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5284 v.Aux = symToAux(sym)
5285 v.AddArg3(base, val, mem)
5286 return true
5287 }
5288
5289
5290 for {
5291 off := auxIntToInt32(v.AuxInt)
5292 sym := auxToSym(v.Aux)
5293 ptr := v_0
5294 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5295 break
5296 }
5297 mem := v_2
5298 v.reset(OpRISCV64MOVBstorezero)
5299 v.AuxInt = int32ToAuxInt(off)
5300 v.Aux = symToAux(sym)
5301 v.AddArg2(ptr, mem)
5302 return true
5303 }
5304
5305
5306 for {
5307 off := auxIntToInt32(v.AuxInt)
5308 sym := auxToSym(v.Aux)
5309 ptr := v_0
5310 if v_1.Op != OpRISCV64MOVBreg {
5311 break
5312 }
5313 x := v_1.Args[0]
5314 mem := v_2
5315 v.reset(OpRISCV64MOVBstore)
5316 v.AuxInt = int32ToAuxInt(off)
5317 v.Aux = symToAux(sym)
5318 v.AddArg3(ptr, x, mem)
5319 return true
5320 }
5321
5322
5323 for {
5324 off := auxIntToInt32(v.AuxInt)
5325 sym := auxToSym(v.Aux)
5326 ptr := v_0
5327 if v_1.Op != OpRISCV64MOVHreg {
5328 break
5329 }
5330 x := v_1.Args[0]
5331 mem := v_2
5332 v.reset(OpRISCV64MOVBstore)
5333 v.AuxInt = int32ToAuxInt(off)
5334 v.Aux = symToAux(sym)
5335 v.AddArg3(ptr, x, mem)
5336 return true
5337 }
5338
5339
5340 for {
5341 off := auxIntToInt32(v.AuxInt)
5342 sym := auxToSym(v.Aux)
5343 ptr := v_0
5344 if v_1.Op != OpRISCV64MOVWreg {
5345 break
5346 }
5347 x := v_1.Args[0]
5348 mem := v_2
5349 v.reset(OpRISCV64MOVBstore)
5350 v.AuxInt = int32ToAuxInt(off)
5351 v.Aux = symToAux(sym)
5352 v.AddArg3(ptr, x, mem)
5353 return true
5354 }
5355
5356
5357 for {
5358 off := auxIntToInt32(v.AuxInt)
5359 sym := auxToSym(v.Aux)
5360 ptr := v_0
5361 if v_1.Op != OpRISCV64MOVBUreg {
5362 break
5363 }
5364 x := v_1.Args[0]
5365 mem := v_2
5366 v.reset(OpRISCV64MOVBstore)
5367 v.AuxInt = int32ToAuxInt(off)
5368 v.Aux = symToAux(sym)
5369 v.AddArg3(ptr, x, mem)
5370 return true
5371 }
5372
5373
5374 for {
5375 off := auxIntToInt32(v.AuxInt)
5376 sym := auxToSym(v.Aux)
5377 ptr := v_0
5378 if v_1.Op != OpRISCV64MOVHUreg {
5379 break
5380 }
5381 x := v_1.Args[0]
5382 mem := v_2
5383 v.reset(OpRISCV64MOVBstore)
5384 v.AuxInt = int32ToAuxInt(off)
5385 v.Aux = symToAux(sym)
5386 v.AddArg3(ptr, x, mem)
5387 return true
5388 }
5389
5390
5391 for {
5392 off := auxIntToInt32(v.AuxInt)
5393 sym := auxToSym(v.Aux)
5394 ptr := v_0
5395 if v_1.Op != OpRISCV64MOVWUreg {
5396 break
5397 }
5398 x := v_1.Args[0]
5399 mem := v_2
5400 v.reset(OpRISCV64MOVBstore)
5401 v.AuxInt = int32ToAuxInt(off)
5402 v.Aux = symToAux(sym)
5403 v.AddArg3(ptr, x, mem)
5404 return true
5405 }
5406 return false
5407 }
5408 func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
5409 v_1 := v.Args[1]
5410 v_0 := v.Args[0]
5411 b := v.Block
5412 config := b.Func.Config
5413
5414
5415
5416 for {
5417 off1 := auxIntToInt32(v.AuxInt)
5418 sym1 := auxToSym(v.Aux)
5419 if v_0.Op != OpRISCV64MOVaddr {
5420 break
5421 }
5422 off2 := auxIntToInt32(v_0.AuxInt)
5423 sym2 := auxToSym(v_0.Aux)
5424 base := v_0.Args[0]
5425 mem := v_1
5426 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5427 break
5428 }
5429 v.reset(OpRISCV64MOVBstorezero)
5430 v.AuxInt = int32ToAuxInt(off1 + off2)
5431 v.Aux = symToAux(mergeSym(sym1, sym2))
5432 v.AddArg2(base, mem)
5433 return true
5434 }
5435
5436
5437
5438 for {
5439 off1 := auxIntToInt32(v.AuxInt)
5440 sym := auxToSym(v.Aux)
5441 if v_0.Op != OpRISCV64ADDI {
5442 break
5443 }
5444 off2 := auxIntToInt64(v_0.AuxInt)
5445 base := v_0.Args[0]
5446 mem := v_1
5447 if !(is32Bit(int64(off1) + off2)) {
5448 break
5449 }
5450 v.reset(OpRISCV64MOVBstorezero)
5451 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5452 v.Aux = symToAux(sym)
5453 v.AddArg2(base, mem)
5454 return true
5455 }
5456 return false
5457 }
5458 func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
5459 v_1 := v.Args[1]
5460 v_0 := v.Args[0]
5461 b := v.Block
5462 config := b.Func.Config
5463
5464
5465
5466 for {
5467 off1 := auxIntToInt32(v.AuxInt)
5468 sym1 := auxToSym(v.Aux)
5469 if v_0.Op != OpRISCV64MOVaddr {
5470 break
5471 }
5472 off2 := auxIntToInt32(v_0.AuxInt)
5473 sym2 := auxToSym(v_0.Aux)
5474 base := v_0.Args[0]
5475 mem := v_1
5476 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5477 break
5478 }
5479 v.reset(OpRISCV64MOVDload)
5480 v.AuxInt = int32ToAuxInt(off1 + off2)
5481 v.Aux = symToAux(mergeSym(sym1, sym2))
5482 v.AddArg2(base, mem)
5483 return true
5484 }
5485
5486
5487
5488 for {
5489 off1 := auxIntToInt32(v.AuxInt)
5490 sym := auxToSym(v.Aux)
5491 if v_0.Op != OpRISCV64ADDI {
5492 break
5493 }
5494 off2 := auxIntToInt64(v_0.AuxInt)
5495 base := v_0.Args[0]
5496 mem := v_1
5497 if !(is32Bit(int64(off1) + off2)) {
5498 break
5499 }
5500 v.reset(OpRISCV64MOVDload)
5501 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5502 v.Aux = symToAux(sym)
5503 v.AddArg2(base, mem)
5504 return true
5505 }
5506
5507
5508
5509 for {
5510 off := auxIntToInt32(v.AuxInt)
5511 sym := auxToSym(v.Aux)
5512 ptr1 := v_0
5513 if v_1.Op != OpRISCV64MOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5514 break
5515 }
5516 x := v_1.Args[1]
5517 ptr2 := v_1.Args[0]
5518 if !(isSamePtr(ptr1, ptr2)) {
5519 break
5520 }
5521 v.reset(OpRISCV64MOVDreg)
5522 v.AddArg(x)
5523 return true
5524 }
5525
5526
5527
5528 for {
5529 off := auxIntToInt32(v.AuxInt)
5530 sym := auxToSym(v.Aux)
5531 ptr1 := v_0
5532 if v_1.Op != OpRISCV64FMOVDstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5533 break
5534 }
5535 x := v_1.Args[1]
5536 ptr2 := v_1.Args[0]
5537 if !(isSamePtr(ptr1, ptr2)) {
5538 break
5539 }
5540 v.reset(OpRISCV64FMVXD)
5541 v.AddArg(x)
5542 return true
5543 }
5544 return false
5545 }
5546 func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
5547 v_0 := v.Args[0]
5548
5549
5550 for {
5551 if v_0.Op != OpRISCV64MOVDconst {
5552 break
5553 }
5554 c := auxIntToInt64(v_0.AuxInt)
5555 v.reset(OpRISCV64MOVDconst)
5556 v.AuxInt = int64ToAuxInt(c)
5557 return true
5558 }
5559 return false
5560 }
5561 func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
5562 v_0 := v.Args[0]
5563
5564
5565
5566 for {
5567 x := v_0
5568 if !(x.Uses == 1) {
5569 break
5570 }
5571 v.reset(OpRISCV64MOVDnop)
5572 v.AddArg(x)
5573 return true
5574 }
5575 return false
5576 }
5577 func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
5578 v_2 := v.Args[2]
5579 v_1 := v.Args[1]
5580 v_0 := v.Args[0]
5581 b := v.Block
5582 config := b.Func.Config
5583
5584
5585
5586 for {
5587 off1 := auxIntToInt32(v.AuxInt)
5588 sym1 := auxToSym(v.Aux)
5589 if v_0.Op != OpRISCV64MOVaddr {
5590 break
5591 }
5592 off2 := auxIntToInt32(v_0.AuxInt)
5593 sym2 := auxToSym(v_0.Aux)
5594 base := v_0.Args[0]
5595 val := v_1
5596 mem := v_2
5597 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5598 break
5599 }
5600 v.reset(OpRISCV64MOVDstore)
5601 v.AuxInt = int32ToAuxInt(off1 + off2)
5602 v.Aux = symToAux(mergeSym(sym1, sym2))
5603 v.AddArg3(base, val, mem)
5604 return true
5605 }
5606
5607
5608
5609 for {
5610 off1 := auxIntToInt32(v.AuxInt)
5611 sym := auxToSym(v.Aux)
5612 if v_0.Op != OpRISCV64ADDI {
5613 break
5614 }
5615 off2 := auxIntToInt64(v_0.AuxInt)
5616 base := v_0.Args[0]
5617 val := v_1
5618 mem := v_2
5619 if !(is32Bit(int64(off1) + off2)) {
5620 break
5621 }
5622 v.reset(OpRISCV64MOVDstore)
5623 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5624 v.Aux = symToAux(sym)
5625 v.AddArg3(base, val, mem)
5626 return true
5627 }
5628
5629
5630 for {
5631 off := auxIntToInt32(v.AuxInt)
5632 sym := auxToSym(v.Aux)
5633 ptr := v_0
5634 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5635 break
5636 }
5637 mem := v_2
5638 v.reset(OpRISCV64MOVDstorezero)
5639 v.AuxInt = int32ToAuxInt(off)
5640 v.Aux = symToAux(sym)
5641 v.AddArg2(ptr, mem)
5642 return true
5643 }
5644 return false
5645 }
5646 func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool {
5647 v_1 := v.Args[1]
5648 v_0 := v.Args[0]
5649 b := v.Block
5650 config := b.Func.Config
5651
5652
5653
5654 for {
5655 off1 := auxIntToInt32(v.AuxInt)
5656 sym1 := auxToSym(v.Aux)
5657 if v_0.Op != OpRISCV64MOVaddr {
5658 break
5659 }
5660 off2 := auxIntToInt32(v_0.AuxInt)
5661 sym2 := auxToSym(v_0.Aux)
5662 base := v_0.Args[0]
5663 mem := v_1
5664 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5665 break
5666 }
5667 v.reset(OpRISCV64MOVDstorezero)
5668 v.AuxInt = int32ToAuxInt(off1 + off2)
5669 v.Aux = symToAux(mergeSym(sym1, sym2))
5670 v.AddArg2(base, mem)
5671 return true
5672 }
5673
5674
5675
5676 for {
5677 off1 := auxIntToInt32(v.AuxInt)
5678 sym := auxToSym(v.Aux)
5679 if v_0.Op != OpRISCV64ADDI {
5680 break
5681 }
5682 off2 := auxIntToInt64(v_0.AuxInt)
5683 base := v_0.Args[0]
5684 mem := v_1
5685 if !(is32Bit(int64(off1) + off2)) {
5686 break
5687 }
5688 v.reset(OpRISCV64MOVDstorezero)
5689 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5690 v.Aux = symToAux(sym)
5691 v.AddArg2(base, mem)
5692 return true
5693 }
5694 return false
5695 }
5696 func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
5697 v_1 := v.Args[1]
5698 v_0 := v.Args[0]
5699 b := v.Block
5700 config := b.Func.Config
5701
5702
5703
5704 for {
5705 off1 := auxIntToInt32(v.AuxInt)
5706 sym1 := auxToSym(v.Aux)
5707 if v_0.Op != OpRISCV64MOVaddr {
5708 break
5709 }
5710 off2 := auxIntToInt32(v_0.AuxInt)
5711 sym2 := auxToSym(v_0.Aux)
5712 base := v_0.Args[0]
5713 mem := v_1
5714 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5715 break
5716 }
5717 v.reset(OpRISCV64MOVHUload)
5718 v.AuxInt = int32ToAuxInt(off1 + off2)
5719 v.Aux = symToAux(mergeSym(sym1, sym2))
5720 v.AddArg2(base, mem)
5721 return true
5722 }
5723
5724
5725
5726 for {
5727 off1 := auxIntToInt32(v.AuxInt)
5728 sym := auxToSym(v.Aux)
5729 if v_0.Op != OpRISCV64ADDI {
5730 break
5731 }
5732 off2 := auxIntToInt64(v_0.AuxInt)
5733 base := v_0.Args[0]
5734 mem := v_1
5735 if !(is32Bit(int64(off1) + off2)) {
5736 break
5737 }
5738 v.reset(OpRISCV64MOVHUload)
5739 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5740 v.Aux = symToAux(sym)
5741 v.AddArg2(base, mem)
5742 return true
5743 }
5744
5745
5746
5747 for {
5748 off := auxIntToInt32(v.AuxInt)
5749 sym := auxToSym(v.Aux)
5750 ptr1 := v_0
5751 if v_1.Op != OpRISCV64MOVHstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5752 break
5753 }
5754 x := v_1.Args[1]
5755 ptr2 := v_1.Args[0]
5756 if !(isSamePtr(ptr1, ptr2)) {
5757 break
5758 }
5759 v.reset(OpRISCV64MOVHUreg)
5760 v.AddArg(x)
5761 return true
5762 }
5763 return false
5764 }
5765 func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
5766 v_0 := v.Args[0]
5767 b := v.Block
5768
5769
5770
5771 for {
5772 x := v_0
5773 if x.Op != OpRISCV64ANDI {
5774 break
5775 }
5776 c := auxIntToInt64(x.AuxInt)
5777 if !(c >= 0 && int64(uint16(c)) == c) {
5778 break
5779 }
5780 v.copyOf(x)
5781 return true
5782 }
5783
5784
5785
5786 for {
5787 if v_0.Op != OpRISCV64ANDI {
5788 break
5789 }
5790 c := auxIntToInt64(v_0.AuxInt)
5791 x := v_0.Args[0]
5792 if !(c < 0) {
5793 break
5794 }
5795 v.reset(OpRISCV64ANDI)
5796 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
5797 v.AddArg(x)
5798 return true
5799 }
5800
5801
5802 for {
5803 if v_0.Op != OpRISCV64MOVDconst {
5804 break
5805 }
5806 c := auxIntToInt64(v_0.AuxInt)
5807 v.reset(OpRISCV64MOVDconst)
5808 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
5809 return true
5810 }
5811
5812
5813 for {
5814 x := v_0
5815 if x.Op != OpRISCV64MOVBUload {
5816 break
5817 }
5818 v.reset(OpRISCV64MOVDreg)
5819 v.AddArg(x)
5820 return true
5821 }
5822
5823
5824 for {
5825 x := v_0
5826 if x.Op != OpRISCV64MOVHUload {
5827 break
5828 }
5829 v.reset(OpRISCV64MOVDreg)
5830 v.AddArg(x)
5831 return true
5832 }
5833
5834
5835 for {
5836 x := v_0
5837 if x.Op != OpRISCV64MOVBUreg {
5838 break
5839 }
5840 v.reset(OpRISCV64MOVDreg)
5841 v.AddArg(x)
5842 return true
5843 }
5844
5845
5846 for {
5847 x := v_0
5848 if x.Op != OpRISCV64MOVHUreg {
5849 break
5850 }
5851 v.reset(OpRISCV64MOVDreg)
5852 v.AddArg(x)
5853 return true
5854 }
5855
5856
5857
5858 for {
5859 t := v.Type
5860 x := v_0
5861 if x.Op != OpRISCV64MOVHload {
5862 break
5863 }
5864 off := auxIntToInt32(x.AuxInt)
5865 sym := auxToSym(x.Aux)
5866 mem := x.Args[1]
5867 ptr := x.Args[0]
5868 if !(x.Uses == 1 && clobber(x)) {
5869 break
5870 }
5871 b = x.Block
5872 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHUload, t)
5873 v.copyOf(v0)
5874 v0.AuxInt = int32ToAuxInt(off)
5875 v0.Aux = symToAux(sym)
5876 v0.AddArg2(ptr, mem)
5877 return true
5878 }
5879 return false
5880 }
5881 func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
5882 v_1 := v.Args[1]
5883 v_0 := v.Args[0]
5884 b := v.Block
5885 config := b.Func.Config
5886
5887
5888
5889 for {
5890 off1 := auxIntToInt32(v.AuxInt)
5891 sym1 := auxToSym(v.Aux)
5892 if v_0.Op != OpRISCV64MOVaddr {
5893 break
5894 }
5895 off2 := auxIntToInt32(v_0.AuxInt)
5896 sym2 := auxToSym(v_0.Aux)
5897 base := v_0.Args[0]
5898 mem := v_1
5899 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5900 break
5901 }
5902 v.reset(OpRISCV64MOVHload)
5903 v.AuxInt = int32ToAuxInt(off1 + off2)
5904 v.Aux = symToAux(mergeSym(sym1, sym2))
5905 v.AddArg2(base, mem)
5906 return true
5907 }
5908
5909
5910
5911 for {
5912 off1 := auxIntToInt32(v.AuxInt)
5913 sym := auxToSym(v.Aux)
5914 if v_0.Op != OpRISCV64ADDI {
5915 break
5916 }
5917 off2 := auxIntToInt64(v_0.AuxInt)
5918 base := v_0.Args[0]
5919 mem := v_1
5920 if !(is32Bit(int64(off1) + off2)) {
5921 break
5922 }
5923 v.reset(OpRISCV64MOVHload)
5924 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5925 v.Aux = symToAux(sym)
5926 v.AddArg2(base, mem)
5927 return true
5928 }
5929
5930
5931
5932 for {
5933 off := auxIntToInt32(v.AuxInt)
5934 sym := auxToSym(v.Aux)
5935 ptr1 := v_0
5936 if v_1.Op != OpRISCV64MOVHstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
5937 break
5938 }
5939 x := v_1.Args[1]
5940 ptr2 := v_1.Args[0]
5941 if !(isSamePtr(ptr1, ptr2)) {
5942 break
5943 }
5944 v.reset(OpRISCV64MOVHreg)
5945 v.AddArg(x)
5946 return true
5947 }
5948 return false
5949 }
5950 func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
5951 v_0 := v.Args[0]
5952 b := v.Block
5953
5954
5955
5956 for {
5957 x := v_0
5958 if x.Op != OpRISCV64ANDI {
5959 break
5960 }
5961 c := auxIntToInt64(x.AuxInt)
5962 if !(c >= 0 && int64(int16(c)) == c) {
5963 break
5964 }
5965 v.copyOf(x)
5966 return true
5967 }
5968
5969
5970 for {
5971 if v_0.Op != OpRISCV64MOVDconst {
5972 break
5973 }
5974 c := auxIntToInt64(v_0.AuxInt)
5975 v.reset(OpRISCV64MOVDconst)
5976 v.AuxInt = int64ToAuxInt(int64(int16(c)))
5977 return true
5978 }
5979
5980
5981 for {
5982 x := v_0
5983 if x.Op != OpRISCV64MOVBload {
5984 break
5985 }
5986 v.reset(OpRISCV64MOVDreg)
5987 v.AddArg(x)
5988 return true
5989 }
5990
5991
5992 for {
5993 x := v_0
5994 if x.Op != OpRISCV64MOVBUload {
5995 break
5996 }
5997 v.reset(OpRISCV64MOVDreg)
5998 v.AddArg(x)
5999 return true
6000 }
6001
6002
6003 for {
6004 x := v_0
6005 if x.Op != OpRISCV64MOVHload {
6006 break
6007 }
6008 v.reset(OpRISCV64MOVDreg)
6009 v.AddArg(x)
6010 return true
6011 }
6012
6013
6014 for {
6015 x := v_0
6016 if x.Op != OpRISCV64MOVBreg {
6017 break
6018 }
6019 v.reset(OpRISCV64MOVDreg)
6020 v.AddArg(x)
6021 return true
6022 }
6023
6024
6025 for {
6026 x := v_0
6027 if x.Op != OpRISCV64MOVBUreg {
6028 break
6029 }
6030 v.reset(OpRISCV64MOVDreg)
6031 v.AddArg(x)
6032 return true
6033 }
6034
6035
6036 for {
6037 x := v_0
6038 if x.Op != OpRISCV64MOVHreg {
6039 break
6040 }
6041 v.reset(OpRISCV64MOVDreg)
6042 v.AddArg(x)
6043 return true
6044 }
6045
6046
6047
6048 for {
6049 t := v.Type
6050 x := v_0
6051 if x.Op != OpRISCV64MOVHUload {
6052 break
6053 }
6054 off := auxIntToInt32(x.AuxInt)
6055 sym := auxToSym(x.Aux)
6056 mem := x.Args[1]
6057 ptr := x.Args[0]
6058 if !(x.Uses == 1 && clobber(x)) {
6059 break
6060 }
6061 b = x.Block
6062 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHload, t)
6063 v.copyOf(v0)
6064 v0.AuxInt = int32ToAuxInt(off)
6065 v0.Aux = symToAux(sym)
6066 v0.AddArg2(ptr, mem)
6067 return true
6068 }
6069 return false
6070 }
6071 func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
6072 v_2 := v.Args[2]
6073 v_1 := v.Args[1]
6074 v_0 := v.Args[0]
6075 b := v.Block
6076 config := b.Func.Config
6077
6078
6079
6080 for {
6081 off1 := auxIntToInt32(v.AuxInt)
6082 sym1 := auxToSym(v.Aux)
6083 if v_0.Op != OpRISCV64MOVaddr {
6084 break
6085 }
6086 off2 := auxIntToInt32(v_0.AuxInt)
6087 sym2 := auxToSym(v_0.Aux)
6088 base := v_0.Args[0]
6089 val := v_1
6090 mem := v_2
6091 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6092 break
6093 }
6094 v.reset(OpRISCV64MOVHstore)
6095 v.AuxInt = int32ToAuxInt(off1 + off2)
6096 v.Aux = symToAux(mergeSym(sym1, sym2))
6097 v.AddArg3(base, val, mem)
6098 return true
6099 }
6100
6101
6102
6103 for {
6104 off1 := auxIntToInt32(v.AuxInt)
6105 sym := auxToSym(v.Aux)
6106 if v_0.Op != OpRISCV64ADDI {
6107 break
6108 }
6109 off2 := auxIntToInt64(v_0.AuxInt)
6110 base := v_0.Args[0]
6111 val := v_1
6112 mem := v_2
6113 if !(is32Bit(int64(off1) + off2)) {
6114 break
6115 }
6116 v.reset(OpRISCV64MOVHstore)
6117 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6118 v.Aux = symToAux(sym)
6119 v.AddArg3(base, val, mem)
6120 return true
6121 }
6122
6123
6124 for {
6125 off := auxIntToInt32(v.AuxInt)
6126 sym := auxToSym(v.Aux)
6127 ptr := v_0
6128 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6129 break
6130 }
6131 mem := v_2
6132 v.reset(OpRISCV64MOVHstorezero)
6133 v.AuxInt = int32ToAuxInt(off)
6134 v.Aux = symToAux(sym)
6135 v.AddArg2(ptr, mem)
6136 return true
6137 }
6138
6139
6140 for {
6141 off := auxIntToInt32(v.AuxInt)
6142 sym := auxToSym(v.Aux)
6143 ptr := v_0
6144 if v_1.Op != OpRISCV64MOVHreg {
6145 break
6146 }
6147 x := v_1.Args[0]
6148 mem := v_2
6149 v.reset(OpRISCV64MOVHstore)
6150 v.AuxInt = int32ToAuxInt(off)
6151 v.Aux = symToAux(sym)
6152 v.AddArg3(ptr, x, mem)
6153 return true
6154 }
6155
6156
6157 for {
6158 off := auxIntToInt32(v.AuxInt)
6159 sym := auxToSym(v.Aux)
6160 ptr := v_0
6161 if v_1.Op != OpRISCV64MOVWreg {
6162 break
6163 }
6164 x := v_1.Args[0]
6165 mem := v_2
6166 v.reset(OpRISCV64MOVHstore)
6167 v.AuxInt = int32ToAuxInt(off)
6168 v.Aux = symToAux(sym)
6169 v.AddArg3(ptr, x, mem)
6170 return true
6171 }
6172
6173
6174 for {
6175 off := auxIntToInt32(v.AuxInt)
6176 sym := auxToSym(v.Aux)
6177 ptr := v_0
6178 if v_1.Op != OpRISCV64MOVHUreg {
6179 break
6180 }
6181 x := v_1.Args[0]
6182 mem := v_2
6183 v.reset(OpRISCV64MOVHstore)
6184 v.AuxInt = int32ToAuxInt(off)
6185 v.Aux = symToAux(sym)
6186 v.AddArg3(ptr, x, mem)
6187 return true
6188 }
6189
6190
6191 for {
6192 off := auxIntToInt32(v.AuxInt)
6193 sym := auxToSym(v.Aux)
6194 ptr := v_0
6195 if v_1.Op != OpRISCV64MOVWUreg {
6196 break
6197 }
6198 x := v_1.Args[0]
6199 mem := v_2
6200 v.reset(OpRISCV64MOVHstore)
6201 v.AuxInt = int32ToAuxInt(off)
6202 v.Aux = symToAux(sym)
6203 v.AddArg3(ptr, x, mem)
6204 return true
6205 }
6206 return false
6207 }
6208 func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool {
6209 v_1 := v.Args[1]
6210 v_0 := v.Args[0]
6211 b := v.Block
6212 config := b.Func.Config
6213
6214
6215
6216 for {
6217 off1 := auxIntToInt32(v.AuxInt)
6218 sym1 := auxToSym(v.Aux)
6219 if v_0.Op != OpRISCV64MOVaddr {
6220 break
6221 }
6222 off2 := auxIntToInt32(v_0.AuxInt)
6223 sym2 := auxToSym(v_0.Aux)
6224 base := v_0.Args[0]
6225 mem := v_1
6226 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6227 break
6228 }
6229 v.reset(OpRISCV64MOVHstorezero)
6230 v.AuxInt = int32ToAuxInt(off1 + off2)
6231 v.Aux = symToAux(mergeSym(sym1, sym2))
6232 v.AddArg2(base, mem)
6233 return true
6234 }
6235
6236
6237
6238 for {
6239 off1 := auxIntToInt32(v.AuxInt)
6240 sym := auxToSym(v.Aux)
6241 if v_0.Op != OpRISCV64ADDI {
6242 break
6243 }
6244 off2 := auxIntToInt64(v_0.AuxInt)
6245 base := v_0.Args[0]
6246 mem := v_1
6247 if !(is32Bit(int64(off1) + off2)) {
6248 break
6249 }
6250 v.reset(OpRISCV64MOVHstorezero)
6251 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6252 v.Aux = symToAux(sym)
6253 v.AddArg2(base, mem)
6254 return true
6255 }
6256 return false
6257 }
6258 func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
6259 v_1 := v.Args[1]
6260 v_0 := v.Args[0]
6261 b := v.Block
6262 config := b.Func.Config
6263 typ := &b.Func.Config.Types
6264
6265
6266
6267 for {
6268 off1 := auxIntToInt32(v.AuxInt)
6269 sym1 := auxToSym(v.Aux)
6270 if v_0.Op != OpRISCV64MOVaddr {
6271 break
6272 }
6273 off2 := auxIntToInt32(v_0.AuxInt)
6274 sym2 := auxToSym(v_0.Aux)
6275 base := v_0.Args[0]
6276 mem := v_1
6277 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6278 break
6279 }
6280 v.reset(OpRISCV64MOVWUload)
6281 v.AuxInt = int32ToAuxInt(off1 + off2)
6282 v.Aux = symToAux(mergeSym(sym1, sym2))
6283 v.AddArg2(base, mem)
6284 return true
6285 }
6286
6287
6288
6289 for {
6290 off1 := auxIntToInt32(v.AuxInt)
6291 sym := auxToSym(v.Aux)
6292 if v_0.Op != OpRISCV64ADDI {
6293 break
6294 }
6295 off2 := auxIntToInt64(v_0.AuxInt)
6296 base := v_0.Args[0]
6297 mem := v_1
6298 if !(is32Bit(int64(off1) + off2)) {
6299 break
6300 }
6301 v.reset(OpRISCV64MOVWUload)
6302 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6303 v.Aux = symToAux(sym)
6304 v.AddArg2(base, mem)
6305 return true
6306 }
6307
6308
6309
6310 for {
6311 off := auxIntToInt32(v.AuxInt)
6312 sym := auxToSym(v.Aux)
6313 ptr1 := v_0
6314 if v_1.Op != OpRISCV64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6315 break
6316 }
6317 x := v_1.Args[1]
6318 ptr2 := v_1.Args[0]
6319 if !(isSamePtr(ptr1, ptr2)) {
6320 break
6321 }
6322 v.reset(OpRISCV64MOVWUreg)
6323 v.AddArg(x)
6324 return true
6325 }
6326
6327
6328
6329 for {
6330 off := auxIntToInt32(v.AuxInt)
6331 sym := auxToSym(v.Aux)
6332 ptr1 := v_0
6333 if v_1.Op != OpRISCV64FMOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6334 break
6335 }
6336 x := v_1.Args[1]
6337 ptr2 := v_1.Args[0]
6338 if !(isSamePtr(ptr1, ptr2)) {
6339 break
6340 }
6341 v.reset(OpRISCV64MOVWUreg)
6342 v0 := b.NewValue0(v_1.Pos, OpRISCV64FMVXS, typ.Int32)
6343 v0.AddArg(x)
6344 v.AddArg(v0)
6345 return true
6346 }
6347 return false
6348 }
6349 func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
6350 v_0 := v.Args[0]
6351 b := v.Block
6352 typ := &b.Func.Config.Types
6353
6354
6355
6356 for {
6357 x := v_0
6358 if x.Op != OpRISCV64ANDI {
6359 break
6360 }
6361 c := auxIntToInt64(x.AuxInt)
6362 if !(c >= 0 && int64(uint32(c)) == c) {
6363 break
6364 }
6365 v.copyOf(x)
6366 return true
6367 }
6368
6369
6370
6371 for {
6372 if v_0.Op != OpRISCV64ANDI {
6373 break
6374 }
6375 c := auxIntToInt64(v_0.AuxInt)
6376 x := v_0.Args[0]
6377 if !(c < 0) {
6378 break
6379 }
6380 v.reset(OpRISCV64AND)
6381 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6382 v0.AuxInt = int64ToAuxInt(int64(uint32(c)))
6383 v.AddArg2(v0, x)
6384 return true
6385 }
6386
6387
6388 for {
6389 if v_0.Op != OpRISCV64MOVDconst {
6390 break
6391 }
6392 c := auxIntToInt64(v_0.AuxInt)
6393 v.reset(OpRISCV64MOVDconst)
6394 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
6395 return true
6396 }
6397
6398
6399 for {
6400 x := v_0
6401 if x.Op != OpRISCV64MOVBUload {
6402 break
6403 }
6404 v.reset(OpRISCV64MOVDreg)
6405 v.AddArg(x)
6406 return true
6407 }
6408
6409
6410 for {
6411 x := v_0
6412 if x.Op != OpRISCV64MOVHUload {
6413 break
6414 }
6415 v.reset(OpRISCV64MOVDreg)
6416 v.AddArg(x)
6417 return true
6418 }
6419
6420
6421 for {
6422 x := v_0
6423 if x.Op != OpRISCV64MOVWUload {
6424 break
6425 }
6426 v.reset(OpRISCV64MOVDreg)
6427 v.AddArg(x)
6428 return true
6429 }
6430
6431
6432 for {
6433 x := v_0
6434 if x.Op != OpRISCV64MOVBUreg {
6435 break
6436 }
6437 v.reset(OpRISCV64MOVDreg)
6438 v.AddArg(x)
6439 return true
6440 }
6441
6442
6443 for {
6444 x := v_0
6445 if x.Op != OpRISCV64MOVHUreg {
6446 break
6447 }
6448 v.reset(OpRISCV64MOVDreg)
6449 v.AddArg(x)
6450 return true
6451 }
6452
6453
6454 for {
6455 x := v_0
6456 if x.Op != OpRISCV64MOVWUreg {
6457 break
6458 }
6459 v.reset(OpRISCV64MOVDreg)
6460 v.AddArg(x)
6461 return true
6462 }
6463
6464
6465
6466 for {
6467 t := v.Type
6468 x := v_0
6469 if x.Op != OpRISCV64MOVWload {
6470 break
6471 }
6472 off := auxIntToInt32(x.AuxInt)
6473 sym := auxToSym(x.Aux)
6474 mem := x.Args[1]
6475 ptr := x.Args[0]
6476 if !(x.Uses == 1 && clobber(x)) {
6477 break
6478 }
6479 b = x.Block
6480 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWUload, t)
6481 v.copyOf(v0)
6482 v0.AuxInt = int32ToAuxInt(off)
6483 v0.Aux = symToAux(sym)
6484 v0.AddArg2(ptr, mem)
6485 return true
6486 }
6487 return false
6488 }
6489 func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
6490 v_1 := v.Args[1]
6491 v_0 := v.Args[0]
6492 b := v.Block
6493 config := b.Func.Config
6494
6495
6496
6497 for {
6498 off1 := auxIntToInt32(v.AuxInt)
6499 sym1 := auxToSym(v.Aux)
6500 if v_0.Op != OpRISCV64MOVaddr {
6501 break
6502 }
6503 off2 := auxIntToInt32(v_0.AuxInt)
6504 sym2 := auxToSym(v_0.Aux)
6505 base := v_0.Args[0]
6506 mem := v_1
6507 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6508 break
6509 }
6510 v.reset(OpRISCV64MOVWload)
6511 v.AuxInt = int32ToAuxInt(off1 + off2)
6512 v.Aux = symToAux(mergeSym(sym1, sym2))
6513 v.AddArg2(base, mem)
6514 return true
6515 }
6516
6517
6518
6519 for {
6520 off1 := auxIntToInt32(v.AuxInt)
6521 sym := auxToSym(v.Aux)
6522 if v_0.Op != OpRISCV64ADDI {
6523 break
6524 }
6525 off2 := auxIntToInt64(v_0.AuxInt)
6526 base := v_0.Args[0]
6527 mem := v_1
6528 if !(is32Bit(int64(off1) + off2)) {
6529 break
6530 }
6531 v.reset(OpRISCV64MOVWload)
6532 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6533 v.Aux = symToAux(sym)
6534 v.AddArg2(base, mem)
6535 return true
6536 }
6537
6538
6539
6540 for {
6541 off := auxIntToInt32(v.AuxInt)
6542 sym := auxToSym(v.Aux)
6543 ptr1 := v_0
6544 if v_1.Op != OpRISCV64MOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6545 break
6546 }
6547 x := v_1.Args[1]
6548 ptr2 := v_1.Args[0]
6549 if !(isSamePtr(ptr1, ptr2)) {
6550 break
6551 }
6552 v.reset(OpRISCV64MOVWreg)
6553 v.AddArg(x)
6554 return true
6555 }
6556
6557
6558
6559 for {
6560 off := auxIntToInt32(v.AuxInt)
6561 sym := auxToSym(v.Aux)
6562 ptr1 := v_0
6563 if v_1.Op != OpRISCV64FMOVWstore || auxIntToInt32(v_1.AuxInt) != off || auxToSym(v_1.Aux) != sym {
6564 break
6565 }
6566 x := v_1.Args[1]
6567 ptr2 := v_1.Args[0]
6568 if !(isSamePtr(ptr1, ptr2)) {
6569 break
6570 }
6571 v.reset(OpRISCV64FMVXS)
6572 v.AddArg(x)
6573 return true
6574 }
6575 return false
6576 }
6577 func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
6578 v_0 := v.Args[0]
6579 b := v.Block
6580
6581
6582
6583 for {
6584 x := v_0
6585 if x.Op != OpRISCV64ANDI {
6586 break
6587 }
6588 c := auxIntToInt64(x.AuxInt)
6589 if !(c >= 0 && int64(int32(c)) == c) {
6590 break
6591 }
6592 v.copyOf(x)
6593 return true
6594 }
6595
6596
6597 for {
6598 if v_0.Op != OpRISCV64NEG {
6599 break
6600 }
6601 x := v_0.Args[0]
6602 v.reset(OpRISCV64NEGW)
6603 v.AddArg(x)
6604 return true
6605 }
6606
6607
6608 for {
6609 if v_0.Op != OpRISCV64MOVDconst {
6610 break
6611 }
6612 c := auxIntToInt64(v_0.AuxInt)
6613 v.reset(OpRISCV64MOVDconst)
6614 v.AuxInt = int64ToAuxInt(int64(int32(c)))
6615 return true
6616 }
6617
6618
6619 for {
6620 x := v_0
6621 if x.Op != OpRISCV64MOVBload {
6622 break
6623 }
6624 v.reset(OpRISCV64MOVDreg)
6625 v.AddArg(x)
6626 return true
6627 }
6628
6629
6630 for {
6631 x := v_0
6632 if x.Op != OpRISCV64MOVBUload {
6633 break
6634 }
6635 v.reset(OpRISCV64MOVDreg)
6636 v.AddArg(x)
6637 return true
6638 }
6639
6640
6641 for {
6642 x := v_0
6643 if x.Op != OpRISCV64MOVHload {
6644 break
6645 }
6646 v.reset(OpRISCV64MOVDreg)
6647 v.AddArg(x)
6648 return true
6649 }
6650
6651
6652 for {
6653 x := v_0
6654 if x.Op != OpRISCV64MOVHUload {
6655 break
6656 }
6657 v.reset(OpRISCV64MOVDreg)
6658 v.AddArg(x)
6659 return true
6660 }
6661
6662
6663 for {
6664 x := v_0
6665 if x.Op != OpRISCV64MOVWload {
6666 break
6667 }
6668 v.reset(OpRISCV64MOVDreg)
6669 v.AddArg(x)
6670 return true
6671 }
6672
6673
6674
6675 for {
6676 x := v_0
6677 if x.Op != OpRISCV64ADDIW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6678 break
6679 }
6680 v.reset(OpRISCV64MOVDreg)
6681 v.AddArg(x)
6682 return true
6683 }
6684
6685
6686
6687 for {
6688 x := v_0
6689 if x.Op != OpRISCV64SUBW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6690 break
6691 }
6692 v.reset(OpRISCV64MOVDreg)
6693 v.AddArg(x)
6694 return true
6695 }
6696
6697
6698
6699 for {
6700 x := v_0
6701 if x.Op != OpRISCV64NEGW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6702 break
6703 }
6704 v.reset(OpRISCV64MOVDreg)
6705 v.AddArg(x)
6706 return true
6707 }
6708
6709
6710
6711 for {
6712 x := v_0
6713 if x.Op != OpRISCV64MULW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6714 break
6715 }
6716 v.reset(OpRISCV64MOVDreg)
6717 v.AddArg(x)
6718 return true
6719 }
6720
6721
6722
6723 for {
6724 x := v_0
6725 if x.Op != OpRISCV64DIVW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6726 break
6727 }
6728 v.reset(OpRISCV64MOVDreg)
6729 v.AddArg(x)
6730 return true
6731 }
6732
6733
6734
6735 for {
6736 x := v_0
6737 if x.Op != OpRISCV64DIVUW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6738 break
6739 }
6740 v.reset(OpRISCV64MOVDreg)
6741 v.AddArg(x)
6742 return true
6743 }
6744
6745
6746
6747 for {
6748 x := v_0
6749 if x.Op != OpRISCV64REMW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6750 break
6751 }
6752 v.reset(OpRISCV64MOVDreg)
6753 v.AddArg(x)
6754 return true
6755 }
6756
6757
6758
6759 for {
6760 x := v_0
6761 if x.Op != OpRISCV64REMUW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6762 break
6763 }
6764 v.reset(OpRISCV64MOVDreg)
6765 v.AddArg(x)
6766 return true
6767 }
6768
6769
6770
6771 for {
6772 x := v_0
6773 if x.Op != OpRISCV64ROLW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6774 break
6775 }
6776 v.reset(OpRISCV64MOVDreg)
6777 v.AddArg(x)
6778 return true
6779 }
6780
6781
6782
6783 for {
6784 x := v_0
6785 if x.Op != OpRISCV64RORW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6786 break
6787 }
6788 v.reset(OpRISCV64MOVDreg)
6789 v.AddArg(x)
6790 return true
6791 }
6792
6793
6794
6795 for {
6796 x := v_0
6797 if x.Op != OpRISCV64RORIW || !(x.Type.Size() == 8 || (x.Type.Size() == 4 && x.Type.IsSigned())) {
6798 break
6799 }
6800 v.reset(OpRISCV64MOVDreg)
6801 v.AddArg(x)
6802 return true
6803 }
6804
6805
6806 for {
6807 x := v_0
6808 if x.Op != OpRISCV64MOVBreg {
6809 break
6810 }
6811 v.reset(OpRISCV64MOVDreg)
6812 v.AddArg(x)
6813 return true
6814 }
6815
6816
6817 for {
6818 x := v_0
6819 if x.Op != OpRISCV64MOVBUreg {
6820 break
6821 }
6822 v.reset(OpRISCV64MOVDreg)
6823 v.AddArg(x)
6824 return true
6825 }
6826
6827
6828 for {
6829 x := v_0
6830 if x.Op != OpRISCV64MOVHreg {
6831 break
6832 }
6833 v.reset(OpRISCV64MOVDreg)
6834 v.AddArg(x)
6835 return true
6836 }
6837
6838
6839 for {
6840 x := v_0
6841 if x.Op != OpRISCV64MOVWreg {
6842 break
6843 }
6844 v.reset(OpRISCV64MOVDreg)
6845 v.AddArg(x)
6846 return true
6847 }
6848
6849
6850
6851 for {
6852 t := v.Type
6853 x := v_0
6854 if x.Op != OpRISCV64MOVWUload {
6855 break
6856 }
6857 off := auxIntToInt32(x.AuxInt)
6858 sym := auxToSym(x.Aux)
6859 mem := x.Args[1]
6860 ptr := x.Args[0]
6861 if !(x.Uses == 1 && clobber(x)) {
6862 break
6863 }
6864 b = x.Block
6865 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWload, t)
6866 v.copyOf(v0)
6867 v0.AuxInt = int32ToAuxInt(off)
6868 v0.Aux = symToAux(sym)
6869 v0.AddArg2(ptr, mem)
6870 return true
6871 }
6872 return false
6873 }
6874 func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
6875 v_2 := v.Args[2]
6876 v_1 := v.Args[1]
6877 v_0 := v.Args[0]
6878 b := v.Block
6879 config := b.Func.Config
6880
6881
6882
6883 for {
6884 off1 := auxIntToInt32(v.AuxInt)
6885 sym1 := auxToSym(v.Aux)
6886 if v_0.Op != OpRISCV64MOVaddr {
6887 break
6888 }
6889 off2 := auxIntToInt32(v_0.AuxInt)
6890 sym2 := auxToSym(v_0.Aux)
6891 base := v_0.Args[0]
6892 val := v_1
6893 mem := v_2
6894 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6895 break
6896 }
6897 v.reset(OpRISCV64MOVWstore)
6898 v.AuxInt = int32ToAuxInt(off1 + off2)
6899 v.Aux = symToAux(mergeSym(sym1, sym2))
6900 v.AddArg3(base, val, mem)
6901 return true
6902 }
6903
6904
6905
6906 for {
6907 off1 := auxIntToInt32(v.AuxInt)
6908 sym := auxToSym(v.Aux)
6909 if v_0.Op != OpRISCV64ADDI {
6910 break
6911 }
6912 off2 := auxIntToInt64(v_0.AuxInt)
6913 base := v_0.Args[0]
6914 val := v_1
6915 mem := v_2
6916 if !(is32Bit(int64(off1) + off2)) {
6917 break
6918 }
6919 v.reset(OpRISCV64MOVWstore)
6920 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6921 v.Aux = symToAux(sym)
6922 v.AddArg3(base, val, mem)
6923 return true
6924 }
6925
6926
6927 for {
6928 off := auxIntToInt32(v.AuxInt)
6929 sym := auxToSym(v.Aux)
6930 ptr := v_0
6931 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6932 break
6933 }
6934 mem := v_2
6935 v.reset(OpRISCV64MOVWstorezero)
6936 v.AuxInt = int32ToAuxInt(off)
6937 v.Aux = symToAux(sym)
6938 v.AddArg2(ptr, mem)
6939 return true
6940 }
6941
6942
6943 for {
6944 off := auxIntToInt32(v.AuxInt)
6945 sym := auxToSym(v.Aux)
6946 ptr := v_0
6947 if v_1.Op != OpRISCV64MOVWreg {
6948 break
6949 }
6950 x := v_1.Args[0]
6951 mem := v_2
6952 v.reset(OpRISCV64MOVWstore)
6953 v.AuxInt = int32ToAuxInt(off)
6954 v.Aux = symToAux(sym)
6955 v.AddArg3(ptr, x, mem)
6956 return true
6957 }
6958
6959
6960 for {
6961 off := auxIntToInt32(v.AuxInt)
6962 sym := auxToSym(v.Aux)
6963 ptr := v_0
6964 if v_1.Op != OpRISCV64MOVWUreg {
6965 break
6966 }
6967 x := v_1.Args[0]
6968 mem := v_2
6969 v.reset(OpRISCV64MOVWstore)
6970 v.AuxInt = int32ToAuxInt(off)
6971 v.Aux = symToAux(sym)
6972 v.AddArg3(ptr, x, mem)
6973 return true
6974 }
6975 return false
6976 }
6977 func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
6978 v_1 := v.Args[1]
6979 v_0 := v.Args[0]
6980 b := v.Block
6981 config := b.Func.Config
6982
6983
6984
6985 for {
6986 off1 := auxIntToInt32(v.AuxInt)
6987 sym1 := auxToSym(v.Aux)
6988 if v_0.Op != OpRISCV64MOVaddr {
6989 break
6990 }
6991 off2 := auxIntToInt32(v_0.AuxInt)
6992 sym2 := auxToSym(v_0.Aux)
6993 base := v_0.Args[0]
6994 mem := v_1
6995 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6996 break
6997 }
6998 v.reset(OpRISCV64MOVWstorezero)
6999 v.AuxInt = int32ToAuxInt(off1 + off2)
7000 v.Aux = symToAux(mergeSym(sym1, sym2))
7001 v.AddArg2(base, mem)
7002 return true
7003 }
7004
7005
7006
7007 for {
7008 off1 := auxIntToInt32(v.AuxInt)
7009 sym := auxToSym(v.Aux)
7010 if v_0.Op != OpRISCV64ADDI {
7011 break
7012 }
7013 off2 := auxIntToInt64(v_0.AuxInt)
7014 base := v_0.Args[0]
7015 mem := v_1
7016 if !(is32Bit(int64(off1) + off2)) {
7017 break
7018 }
7019 v.reset(OpRISCV64MOVWstorezero)
7020 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
7021 v.Aux = symToAux(sym)
7022 v.AddArg2(base, mem)
7023 return true
7024 }
7025 return false
7026 }
7027 func rewriteValueRISCV64_OpRISCV64NEG(v *Value) bool {
7028 v_0 := v.Args[0]
7029 b := v.Block
7030
7031
7032 for {
7033 if v_0.Op != OpRISCV64SUB {
7034 break
7035 }
7036 y := v_0.Args[1]
7037 x := v_0.Args[0]
7038 v.reset(OpRISCV64SUB)
7039 v.AddArg2(y, x)
7040 return true
7041 }
7042
7043
7044
7045 for {
7046 t := v.Type
7047 s := v_0
7048 if s.Op != OpRISCV64ADDI {
7049 break
7050 }
7051 val := auxIntToInt64(s.AuxInt)
7052 s_0 := s.Args[0]
7053 if s_0.Op != OpRISCV64SUB {
7054 break
7055 }
7056 y := s_0.Args[1]
7057 x := s_0.Args[0]
7058 if !(s.Uses == 1 && is32Bit(-val)) {
7059 break
7060 }
7061 v.reset(OpRISCV64ADDI)
7062 v.AuxInt = int64ToAuxInt(-val)
7063 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, t)
7064 v0.AddArg2(y, x)
7065 v.AddArg(v0)
7066 return true
7067 }
7068
7069
7070 for {
7071 if v_0.Op != OpRISCV64NEG {
7072 break
7073 }
7074 x := v_0.Args[0]
7075 v.copyOf(x)
7076 return true
7077 }
7078
7079
7080
7081 for {
7082 s := v_0
7083 if s.Op != OpRISCV64ADDI {
7084 break
7085 }
7086 val := auxIntToInt64(s.AuxInt)
7087 s_0 := s.Args[0]
7088 if s_0.Op != OpRISCV64NEG {
7089 break
7090 }
7091 x := s_0.Args[0]
7092 if !(s.Uses == 1 && is32Bit(-val)) {
7093 break
7094 }
7095 v.reset(OpRISCV64ADDI)
7096 v.AuxInt = int64ToAuxInt(-val)
7097 v.AddArg(x)
7098 return true
7099 }
7100
7101
7102 for {
7103 if v_0.Op != OpRISCV64MOVDconst {
7104 break
7105 }
7106 x := auxIntToInt64(v_0.AuxInt)
7107 v.reset(OpRISCV64MOVDconst)
7108 v.AuxInt = int64ToAuxInt(-x)
7109 return true
7110 }
7111 return false
7112 }
7113 func rewriteValueRISCV64_OpRISCV64NEGW(v *Value) bool {
7114 v_0 := v.Args[0]
7115
7116
7117 for {
7118 if v_0.Op != OpRISCV64MOVDconst {
7119 break
7120 }
7121 x := auxIntToInt64(v_0.AuxInt)
7122 v.reset(OpRISCV64MOVDconst)
7123 v.AuxInt = int64ToAuxInt(int64(int32(-x)))
7124 return true
7125 }
7126 return false
7127 }
7128 func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
7129 v_1 := v.Args[1]
7130 v_0 := v.Args[0]
7131 b := v.Block
7132 typ := &b.Func.Config.Types
7133
7134
7135
7136 for {
7137 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7138 if v_0.Op != OpRISCV64MOVDconst {
7139 continue
7140 }
7141 val := auxIntToInt64(v_0.AuxInt)
7142 x := v_1
7143 if !(is32Bit(val)) {
7144 continue
7145 }
7146 v.reset(OpRISCV64ORI)
7147 v.AuxInt = int64ToAuxInt(val)
7148 v.AddArg(x)
7149 return true
7150 }
7151 break
7152 }
7153
7154
7155 for {
7156 x := v_0
7157 if x != v_1 {
7158 break
7159 }
7160 v.copyOf(x)
7161 return true
7162 }
7163
7164
7165 for {
7166 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7167 if v_0.Op != OpRISCV64CZEROEQZ {
7168 continue
7169 }
7170 t := v_0.Type
7171 cond := v_0.Args[1]
7172 x := v_0.Args[0]
7173 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7174 continue
7175 }
7176 _ = v_1.Args[1]
7177 v_1_0 := v_1.Args[0]
7178 if v_1_0.Op != OpRISCV64ADD {
7179 continue
7180 }
7181 _ = v_1_0.Args[1]
7182 v_1_0_0 := v_1_0.Args[0]
7183 v_1_0_1 := v_1_0.Args[1]
7184 for _i1 := 0; _i1 <= 1; _i1, v_1_0_0, v_1_0_1 = _i1+1, v_1_0_1, v_1_0_0 {
7185 if x != v_1_0_0 {
7186 continue
7187 }
7188 y := v_1_0_1
7189 if cond != v_1.Args[1] {
7190 continue
7191 }
7192 v.reset(OpRISCV64ADD)
7193 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7194 v0.AddArg2(y, cond)
7195 v.AddArg2(x, v0)
7196 return true
7197 }
7198 }
7199 break
7200 }
7201
7202
7203 for {
7204 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7205 if v_0.Op != OpRISCV64CZEROEQZ {
7206 continue
7207 }
7208 t := v_0.Type
7209 cond := v_0.Args[1]
7210 x := v_0.Args[0]
7211 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7212 continue
7213 }
7214 _ = v_1.Args[1]
7215 v_1_0 := v_1.Args[0]
7216 if v_1_0.Op != OpRISCV64SUB {
7217 continue
7218 }
7219 y := v_1_0.Args[1]
7220 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7221 continue
7222 }
7223 v.reset(OpRISCV64SUB)
7224 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7225 v0.AddArg2(y, cond)
7226 v.AddArg2(x, v0)
7227 return true
7228 }
7229 break
7230 }
7231
7232
7233 for {
7234 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7235 if v_0.Op != OpRISCV64CZEROEQZ {
7236 continue
7237 }
7238 t := v_0.Type
7239 cond := v_0.Args[1]
7240 x := v_0.Args[0]
7241 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7242 continue
7243 }
7244 _ = v_1.Args[1]
7245 v_1_0 := v_1.Args[0]
7246 if v_1_0.Op != OpRISCV64OR {
7247 continue
7248 }
7249 _ = v_1_0.Args[1]
7250 v_1_0_0 := v_1_0.Args[0]
7251 v_1_0_1 := v_1_0.Args[1]
7252 for _i1 := 0; _i1 <= 1; _i1, v_1_0_0, v_1_0_1 = _i1+1, v_1_0_1, v_1_0_0 {
7253 if x != v_1_0_0 {
7254 continue
7255 }
7256 y := v_1_0_1
7257 if cond != v_1.Args[1] {
7258 continue
7259 }
7260 v.reset(OpRISCV64OR)
7261 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7262 v0.AddArg2(y, cond)
7263 v.AddArg2(x, v0)
7264 return true
7265 }
7266 }
7267 break
7268 }
7269
7270
7271 for {
7272 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7273 if v_0.Op != OpRISCV64CZEROEQZ {
7274 continue
7275 }
7276 t := v_0.Type
7277 cond := v_0.Args[1]
7278 x := v_0.Args[0]
7279 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7280 continue
7281 }
7282 _ = v_1.Args[1]
7283 v_1_0 := v_1.Args[0]
7284 if v_1_0.Op != OpRISCV64XOR {
7285 continue
7286 }
7287 _ = v_1_0.Args[1]
7288 v_1_0_0 := v_1_0.Args[0]
7289 v_1_0_1 := v_1_0.Args[1]
7290 for _i1 := 0; _i1 <= 1; _i1, v_1_0_0, v_1_0_1 = _i1+1, v_1_0_1, v_1_0_0 {
7291 if x != v_1_0_0 {
7292 continue
7293 }
7294 y := v_1_0_1
7295 if cond != v_1.Args[1] {
7296 continue
7297 }
7298 v.reset(OpRISCV64XOR)
7299 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7300 v0.AddArg2(y, cond)
7301 v.AddArg2(x, v0)
7302 return true
7303 }
7304 }
7305 break
7306 }
7307
7308
7309 for {
7310 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7311 if v_0.Op != OpRISCV64CZEROEQZ {
7312 continue
7313 }
7314 t := v_0.Type
7315 cond := v_0.Args[1]
7316 x := v_0.Args[0]
7317 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7318 continue
7319 }
7320 _ = v_1.Args[1]
7321 v_1_0 := v_1.Args[0]
7322 if v_1_0.Op != OpRISCV64SUBW {
7323 continue
7324 }
7325 y := v_1_0.Args[1]
7326 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7327 continue
7328 }
7329 v.reset(OpRISCV64SUBW)
7330 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7331 v0.AddArg2(y, cond)
7332 v.AddArg2(x, v0)
7333 return true
7334 }
7335 break
7336 }
7337
7338
7339 for {
7340 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7341 if v_0.Op != OpRISCV64CZEROEQZ {
7342 continue
7343 }
7344 t := v_0.Type
7345 cond := v_0.Args[1]
7346 v_0_0 := v_0.Args[0]
7347 if v_0_0.Op != OpRISCV64ADD {
7348 continue
7349 }
7350 _ = v_0_0.Args[1]
7351 v_0_0_0 := v_0_0.Args[0]
7352 v_0_0_1 := v_0_0.Args[1]
7353 for _i1 := 0; _i1 <= 1; _i1, v_0_0_0, v_0_0_1 = _i1+1, v_0_0_1, v_0_0_0 {
7354 x := v_0_0_0
7355 y := v_0_0_1
7356 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7357 continue
7358 }
7359 _ = v_1.Args[1]
7360 if x != v_1.Args[0] || cond != v_1.Args[1] {
7361 continue
7362 }
7363 v.reset(OpRISCV64ADD)
7364 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7365 v0.AddArg2(y, cond)
7366 v.AddArg2(x, v0)
7367 return true
7368 }
7369 }
7370 break
7371 }
7372
7373
7374 for {
7375 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7376 if v_0.Op != OpRISCV64CZEROEQZ {
7377 continue
7378 }
7379 t := v_0.Type
7380 cond := v_0.Args[1]
7381 v_0_0 := v_0.Args[0]
7382 if v_0_0.Op != OpRISCV64SUB {
7383 continue
7384 }
7385 y := v_0_0.Args[1]
7386 x := v_0_0.Args[0]
7387 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7388 continue
7389 }
7390 _ = v_1.Args[1]
7391 if x != v_1.Args[0] || cond != v_1.Args[1] {
7392 continue
7393 }
7394 v.reset(OpRISCV64SUB)
7395 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7396 v0.AddArg2(y, cond)
7397 v.AddArg2(x, v0)
7398 return true
7399 }
7400 break
7401 }
7402
7403
7404 for {
7405 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7406 if v_0.Op != OpRISCV64CZEROEQZ {
7407 continue
7408 }
7409 t := v_0.Type
7410 cond := v_0.Args[1]
7411 v_0_0 := v_0.Args[0]
7412 if v_0_0.Op != OpRISCV64OR {
7413 continue
7414 }
7415 _ = v_0_0.Args[1]
7416 v_0_0_0 := v_0_0.Args[0]
7417 v_0_0_1 := v_0_0.Args[1]
7418 for _i1 := 0; _i1 <= 1; _i1, v_0_0_0, v_0_0_1 = _i1+1, v_0_0_1, v_0_0_0 {
7419 x := v_0_0_0
7420 y := v_0_0_1
7421 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7422 continue
7423 }
7424 _ = v_1.Args[1]
7425 if x != v_1.Args[0] || cond != v_1.Args[1] {
7426 continue
7427 }
7428 v.reset(OpRISCV64OR)
7429 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7430 v0.AddArg2(y, cond)
7431 v.AddArg2(x, v0)
7432 return true
7433 }
7434 }
7435 break
7436 }
7437
7438
7439 for {
7440 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7441 if v_0.Op != OpRISCV64CZEROEQZ {
7442 continue
7443 }
7444 t := v_0.Type
7445 cond := v_0.Args[1]
7446 v_0_0 := v_0.Args[0]
7447 if v_0_0.Op != OpRISCV64XOR {
7448 continue
7449 }
7450 _ = v_0_0.Args[1]
7451 v_0_0_0 := v_0_0.Args[0]
7452 v_0_0_1 := v_0_0.Args[1]
7453 for _i1 := 0; _i1 <= 1; _i1, v_0_0_0, v_0_0_1 = _i1+1, v_0_0_1, v_0_0_0 {
7454 x := v_0_0_0
7455 y := v_0_0_1
7456 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7457 continue
7458 }
7459 _ = v_1.Args[1]
7460 if x != v_1.Args[0] || cond != v_1.Args[1] {
7461 continue
7462 }
7463 v.reset(OpRISCV64XOR)
7464 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7465 v0.AddArg2(y, cond)
7466 v.AddArg2(x, v0)
7467 return true
7468 }
7469 }
7470 break
7471 }
7472
7473
7474 for {
7475 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7476 if v_0.Op != OpRISCV64CZEROEQZ {
7477 continue
7478 }
7479 t := v_0.Type
7480 cond := v_0.Args[1]
7481 v_0_0 := v_0.Args[0]
7482 if v_0_0.Op != OpRISCV64SUBW {
7483 continue
7484 }
7485 y := v_0_0.Args[1]
7486 x := v_0_0.Args[0]
7487 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7488 continue
7489 }
7490 _ = v_1.Args[1]
7491 if x != v_1.Args[0] || cond != v_1.Args[1] {
7492 continue
7493 }
7494 v.reset(OpRISCV64SUBW)
7495 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7496 v0.AddArg2(y, cond)
7497 v.AddArg2(x, v0)
7498 return true
7499 }
7500 break
7501 }
7502
7503
7504 for {
7505 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7506 x := v_0
7507 if x.Op != OpRISCV64CZEROEQZ {
7508 continue
7509 }
7510 cond := x.Args[1]
7511 z := x.Args[0]
7512 if v_1.Op != OpRISCV64CZERONEZ {
7513 continue
7514 }
7515 _ = v_1.Args[1]
7516 y := v_1.Args[0]
7517 if y.Op != OpRISCV64AND {
7518 continue
7519 }
7520 y_0 := y.Args[0]
7521 y_1 := y.Args[1]
7522 for _i1 := 0; _i1 <= 1; _i1, y_0, y_1 = _i1+1, y_1, y_0 {
7523 if z != y_0 || cond != v_1.Args[1] {
7524 continue
7525 }
7526 v.reset(OpRISCV64OR)
7527 v.AddArg2(y, x)
7528 return true
7529 }
7530 }
7531 break
7532 }
7533
7534
7535 for {
7536 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7537 if v_0.Op != OpRISCV64CZEROEQZ {
7538 continue
7539 }
7540 cond := v_0.Args[1]
7541 x := v_0.Args[0]
7542 if x.Op != OpRISCV64AND {
7543 continue
7544 }
7545 x_0 := x.Args[0]
7546 x_1 := x.Args[1]
7547 for _i1 := 0; _i1 <= 1; _i1, x_0, x_1 = _i1+1, x_1, x_0 {
7548 z := x_0
7549 y := v_1
7550 if y.Op != OpRISCV64CZERONEZ {
7551 continue
7552 }
7553 _ = y.Args[1]
7554 if z != y.Args[0] || cond != y.Args[1] {
7555 continue
7556 }
7557 v.reset(OpRISCV64OR)
7558 v.AddArg2(x, y)
7559 return true
7560 }
7561 }
7562 break
7563 }
7564
7565
7566 for {
7567 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7568 x := v_0
7569 if x.Op != OpRISCV64CZEROEQZ {
7570 continue
7571 }
7572 cond := x.Args[1]
7573 z := x.Args[0]
7574 if v_1.Op != OpRISCV64CZERONEZ {
7575 continue
7576 }
7577 _ = v_1.Args[1]
7578 y := v_1.Args[0]
7579 if y.Op != OpRISCV64ANDI {
7580 continue
7581 }
7582 if z != y.Args[0] || cond != v_1.Args[1] {
7583 continue
7584 }
7585 v.reset(OpRISCV64OR)
7586 v.AddArg2(y, x)
7587 return true
7588 }
7589 break
7590 }
7591
7592
7593 for {
7594 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7595 if v_0.Op != OpRISCV64CZEROEQZ {
7596 continue
7597 }
7598 cond := v_0.Args[1]
7599 x := v_0.Args[0]
7600 if x.Op != OpRISCV64ANDI {
7601 continue
7602 }
7603 z := x.Args[0]
7604 y := v_1
7605 if y.Op != OpRISCV64CZERONEZ {
7606 continue
7607 }
7608 _ = y.Args[1]
7609 if z != y.Args[0] || cond != y.Args[1] {
7610 continue
7611 }
7612 v.reset(OpRISCV64OR)
7613 v.AddArg2(x, y)
7614 return true
7615 }
7616 break
7617 }
7618
7619
7620 for {
7621 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7622 if v_0.Op != OpRISCV64CZEROEQZ {
7623 continue
7624 }
7625 t := v_0.Type
7626 cond := v_0.Args[1]
7627 x := v_0.Args[0]
7628 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7629 continue
7630 }
7631 _ = v_1.Args[1]
7632 v_1_0 := v_1.Args[0]
7633 if v_1_0.Op != OpRISCV64ADDI {
7634 continue
7635 }
7636 c := auxIntToInt64(v_1_0.AuxInt)
7637 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7638 continue
7639 }
7640 v.reset(OpRISCV64ADD)
7641 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7642 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7643 v1.AuxInt = int64ToAuxInt(c)
7644 v0.AddArg2(v1, cond)
7645 v.AddArg2(x, v0)
7646 return true
7647 }
7648 break
7649 }
7650
7651
7652 for {
7653 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7654 if v_0.Op != OpRISCV64CZEROEQZ {
7655 continue
7656 }
7657 t := v_0.Type
7658 cond := v_0.Args[1]
7659 x := v_0.Args[0]
7660 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7661 continue
7662 }
7663 _ = v_1.Args[1]
7664 v_1_0 := v_1.Args[0]
7665 if v_1_0.Op != OpRISCV64ORI {
7666 continue
7667 }
7668 c := auxIntToInt64(v_1_0.AuxInt)
7669 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7670 continue
7671 }
7672 v.reset(OpRISCV64OR)
7673 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7674 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7675 v1.AuxInt = int64ToAuxInt(c)
7676 v0.AddArg2(v1, cond)
7677 v.AddArg2(x, v0)
7678 return true
7679 }
7680 break
7681 }
7682
7683
7684 for {
7685 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7686 if v_0.Op != OpRISCV64CZEROEQZ {
7687 continue
7688 }
7689 t := v_0.Type
7690 cond := v_0.Args[1]
7691 x := v_0.Args[0]
7692 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7693 continue
7694 }
7695 _ = v_1.Args[1]
7696 v_1_0 := v_1.Args[0]
7697 if v_1_0.Op != OpRISCV64XORI {
7698 continue
7699 }
7700 c := auxIntToInt64(v_1_0.AuxInt)
7701 if x != v_1_0.Args[0] || cond != v_1.Args[1] {
7702 continue
7703 }
7704 v.reset(OpRISCV64XOR)
7705 v0 := b.NewValue0(v.Pos, OpRISCV64CZERONEZ, t)
7706 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7707 v1.AuxInt = int64ToAuxInt(c)
7708 v0.AddArg2(v1, cond)
7709 v.AddArg2(x, v0)
7710 return true
7711 }
7712 break
7713 }
7714
7715
7716 for {
7717 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7718 if v_0.Op != OpRISCV64CZEROEQZ {
7719 continue
7720 }
7721 t := v_0.Type
7722 cond := v_0.Args[1]
7723 v_0_0 := v_0.Args[0]
7724 if v_0_0.Op != OpRISCV64ADDI {
7725 continue
7726 }
7727 c := auxIntToInt64(v_0_0.AuxInt)
7728 x := v_0_0.Args[0]
7729 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7730 continue
7731 }
7732 _ = v_1.Args[1]
7733 if x != v_1.Args[0] || cond != v_1.Args[1] {
7734 continue
7735 }
7736 v.reset(OpRISCV64ADD)
7737 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7738 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7739 v1.AuxInt = int64ToAuxInt(c)
7740 v0.AddArg2(v1, cond)
7741 v.AddArg2(x, v0)
7742 return true
7743 }
7744 break
7745 }
7746
7747
7748 for {
7749 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7750 if v_0.Op != OpRISCV64CZEROEQZ {
7751 continue
7752 }
7753 t := v_0.Type
7754 cond := v_0.Args[1]
7755 v_0_0 := v_0.Args[0]
7756 if v_0_0.Op != OpRISCV64ORI {
7757 continue
7758 }
7759 c := auxIntToInt64(v_0_0.AuxInt)
7760 x := v_0_0.Args[0]
7761 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7762 continue
7763 }
7764 _ = v_1.Args[1]
7765 if x != v_1.Args[0] || cond != v_1.Args[1] {
7766 continue
7767 }
7768 v.reset(OpRISCV64OR)
7769 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7770 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7771 v1.AuxInt = int64ToAuxInt(c)
7772 v0.AddArg2(v1, cond)
7773 v.AddArg2(x, v0)
7774 return true
7775 }
7776 break
7777 }
7778
7779
7780 for {
7781 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7782 if v_0.Op != OpRISCV64CZEROEQZ {
7783 continue
7784 }
7785 t := v_0.Type
7786 cond := v_0.Args[1]
7787 v_0_0 := v_0.Args[0]
7788 if v_0_0.Op != OpRISCV64XORI {
7789 continue
7790 }
7791 c := auxIntToInt64(v_0_0.AuxInt)
7792 x := v_0_0.Args[0]
7793 if v_1.Op != OpRISCV64CZERONEZ || v_1.Type != t {
7794 continue
7795 }
7796 _ = v_1.Args[1]
7797 if x != v_1.Args[0] || cond != v_1.Args[1] {
7798 continue
7799 }
7800 v.reset(OpRISCV64XOR)
7801 v0 := b.NewValue0(v.Pos, OpRISCV64CZEROEQZ, t)
7802 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7803 v1.AuxInt = int64ToAuxInt(c)
7804 v0.AddArg2(v1, cond)
7805 v.AddArg2(x, v0)
7806 return true
7807 }
7808 break
7809 }
7810 return false
7811 }
7812 func rewriteValueRISCV64_OpRISCV64ORI(v *Value) bool {
7813 v_0 := v.Args[0]
7814
7815
7816 for {
7817 if auxIntToInt64(v.AuxInt) != 0 {
7818 break
7819 }
7820 x := v_0
7821 v.copyOf(x)
7822 return true
7823 }
7824
7825
7826 for {
7827 if auxIntToInt64(v.AuxInt) != -1 {
7828 break
7829 }
7830 v.reset(OpRISCV64MOVDconst)
7831 v.AuxInt = int64ToAuxInt(-1)
7832 return true
7833 }
7834
7835
7836 for {
7837 x := auxIntToInt64(v.AuxInt)
7838 if v_0.Op != OpRISCV64MOVDconst {
7839 break
7840 }
7841 y := auxIntToInt64(v_0.AuxInt)
7842 v.reset(OpRISCV64MOVDconst)
7843 v.AuxInt = int64ToAuxInt(x | y)
7844 return true
7845 }
7846
7847
7848 for {
7849 x := auxIntToInt64(v.AuxInt)
7850 if v_0.Op != OpRISCV64ORI {
7851 break
7852 }
7853 y := auxIntToInt64(v_0.AuxInt)
7854 z := v_0.Args[0]
7855 v.reset(OpRISCV64ORI)
7856 v.AuxInt = int64ToAuxInt(x | y)
7857 v.AddArg(z)
7858 return true
7859 }
7860 return false
7861 }
7862 func rewriteValueRISCV64_OpRISCV64ORN(v *Value) bool {
7863 v_1 := v.Args[1]
7864 v_0 := v.Args[0]
7865
7866
7867 for {
7868 x := v_0
7869 if x != v_1 {
7870 break
7871 }
7872 v.reset(OpRISCV64MOVDconst)
7873 v.AuxInt = int64ToAuxInt(-1)
7874 return true
7875 }
7876 return false
7877 }
7878 func rewriteValueRISCV64_OpRISCV64ROL(v *Value) bool {
7879 v_1 := v.Args[1]
7880 v_0 := v.Args[0]
7881
7882
7883 for {
7884 x := v_0
7885 if v_1.Op != OpRISCV64MOVDconst {
7886 break
7887 }
7888 val := auxIntToInt64(v_1.AuxInt)
7889 v.reset(OpRISCV64RORI)
7890 v.AuxInt = int64ToAuxInt(-val & 63)
7891 v.AddArg(x)
7892 return true
7893 }
7894
7895
7896 for {
7897 x := v_0
7898 if v_1.Op != OpRISCV64NEG {
7899 break
7900 }
7901 y := v_1.Args[0]
7902 v.reset(OpRISCV64ROR)
7903 v.AddArg2(x, y)
7904 return true
7905 }
7906 return false
7907 }
7908 func rewriteValueRISCV64_OpRISCV64ROLW(v *Value) bool {
7909 v_1 := v.Args[1]
7910 v_0 := v.Args[0]
7911
7912
7913 for {
7914 x := v_0
7915 if v_1.Op != OpRISCV64MOVDconst {
7916 break
7917 }
7918 val := auxIntToInt64(v_1.AuxInt)
7919 v.reset(OpRISCV64RORIW)
7920 v.AuxInt = int64ToAuxInt(-val & 31)
7921 v.AddArg(x)
7922 return true
7923 }
7924
7925
7926 for {
7927 x := v_0
7928 if v_1.Op != OpRISCV64NEG {
7929 break
7930 }
7931 y := v_1.Args[0]
7932 v.reset(OpRISCV64RORW)
7933 v.AddArg2(x, y)
7934 return true
7935 }
7936 return false
7937 }
7938 func rewriteValueRISCV64_OpRISCV64ROR(v *Value) bool {
7939 v_1 := v.Args[1]
7940 v_0 := v.Args[0]
7941
7942
7943 for {
7944 x := v_0
7945 if v_1.Op != OpRISCV64MOVDconst {
7946 break
7947 }
7948 val := auxIntToInt64(v_1.AuxInt)
7949 v.reset(OpRISCV64RORI)
7950 v.AuxInt = int64ToAuxInt(val & 63)
7951 v.AddArg(x)
7952 return true
7953 }
7954 return false
7955 }
7956 func rewriteValueRISCV64_OpRISCV64RORW(v *Value) bool {
7957 v_1 := v.Args[1]
7958 v_0 := v.Args[0]
7959
7960
7961 for {
7962 x := v_0
7963 if v_1.Op != OpRISCV64MOVDconst {
7964 break
7965 }
7966 val := auxIntToInt64(v_1.AuxInt)
7967 v.reset(OpRISCV64RORIW)
7968 v.AuxInt = int64ToAuxInt(val & 31)
7969 v.AddArg(x)
7970 return true
7971 }
7972 return false
7973 }
7974 func rewriteValueRISCV64_OpRISCV64SEQZ(v *Value) bool {
7975 v_0 := v.Args[0]
7976 b := v.Block
7977 typ := &b.Func.Config.Types
7978
7979
7980 for {
7981 if v_0.Op != OpRISCV64NEG {
7982 break
7983 }
7984 x := v_0.Args[0]
7985 v.reset(OpRISCV64SEQZ)
7986 v.AddArg(x)
7987 return true
7988 }
7989
7990
7991 for {
7992 if v_0.Op != OpRISCV64SEQZ {
7993 break
7994 }
7995 x := v_0.Args[0]
7996 v.reset(OpRISCV64SNEZ)
7997 v.AddArg(x)
7998 return true
7999 }
8000
8001
8002 for {
8003 if v_0.Op != OpRISCV64SNEZ {
8004 break
8005 }
8006 x := v_0.Args[0]
8007 v.reset(OpRISCV64SEQZ)
8008 v.AddArg(x)
8009 return true
8010 }
8011
8012
8013 for {
8014 if v_0.Op != OpRISCV64ANDI {
8015 break
8016 }
8017 c := auxIntToInt64(v_0.AuxInt)
8018 v_0_0 := v_0.Args[0]
8019 if v_0_0.Op != OpRISCV64FCLASSD {
8020 break
8021 }
8022 v_0_0_0 := v_0_0.Args[0]
8023 if v_0_0_0.Op != OpRISCV64FNEGD {
8024 break
8025 }
8026 x := v_0_0_0.Args[0]
8027 v.reset(OpRISCV64SEQZ)
8028 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8029 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
8030 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8031 v1.AddArg(x)
8032 v0.AddArg(v1)
8033 v.AddArg(v0)
8034 return true
8035 }
8036
8037
8038 for {
8039 if v_0.Op != OpRISCV64ANDI {
8040 break
8041 }
8042 c := auxIntToInt64(v_0.AuxInt)
8043 v_0_0 := v_0.Args[0]
8044 if v_0_0.Op != OpRISCV64FCLASSD {
8045 break
8046 }
8047 v_0_0_0 := v_0_0.Args[0]
8048 if v_0_0_0.Op != OpRISCV64FABSD {
8049 break
8050 }
8051 x := v_0_0_0.Args[0]
8052 v.reset(OpRISCV64SEQZ)
8053 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8054 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
8055 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8056 v1.AddArg(x)
8057 v0.AddArg(v1)
8058 v.AddArg(v0)
8059 return true
8060 }
8061 return false
8062 }
8063 func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
8064 v_1 := v.Args[1]
8065 v_0 := v.Args[0]
8066
8067
8068 for {
8069 x := v_0
8070 if v_1.Op != OpRISCV64MOVDconst {
8071 break
8072 }
8073 val := auxIntToInt64(v_1.AuxInt)
8074 v.reset(OpRISCV64SLLI)
8075 v.AuxInt = int64ToAuxInt(val & 63)
8076 v.AddArg(x)
8077 return true
8078 }
8079 return false
8080 }
8081 func rewriteValueRISCV64_OpRISCV64SLLI(v *Value) bool {
8082 v_0 := v.Args[0]
8083
8084
8085
8086 for {
8087 x := auxIntToInt64(v.AuxInt)
8088 if v_0.Op != OpRISCV64MOVDconst {
8089 break
8090 }
8091 y := auxIntToInt64(v_0.AuxInt)
8092 if !(is32Bit(y << uint32(x))) {
8093 break
8094 }
8095 v.reset(OpRISCV64MOVDconst)
8096 v.AuxInt = int64ToAuxInt(y << uint32(x))
8097 return true
8098 }
8099
8100
8101
8102 for {
8103 t := v.Type
8104 c := auxIntToInt64(v.AuxInt)
8105 if v_0.Op != OpRISCV64ADD {
8106 break
8107 }
8108 x := v_0.Args[1]
8109 if x != v_0.Args[0] || !(c < t.Size()*8-1) {
8110 break
8111 }
8112 v.reset(OpRISCV64SLLI)
8113 v.AuxInt = int64ToAuxInt(c + 1)
8114 v.AddArg(x)
8115 return true
8116 }
8117
8118
8119
8120 for {
8121 t := v.Type
8122 c := auxIntToInt64(v.AuxInt)
8123 if v_0.Op != OpRISCV64ADD {
8124 break
8125 }
8126 x := v_0.Args[1]
8127 if x != v_0.Args[0] || !(c >= t.Size()*8-1) {
8128 break
8129 }
8130 v.reset(OpRISCV64MOVDconst)
8131 v.AuxInt = int64ToAuxInt(0)
8132 return true
8133 }
8134 return false
8135 }
8136 func rewriteValueRISCV64_OpRISCV64SLLW(v *Value) bool {
8137 v_1 := v.Args[1]
8138 v_0 := v.Args[0]
8139
8140
8141 for {
8142 x := v_0
8143 if v_1.Op != OpRISCV64MOVDconst {
8144 break
8145 }
8146 val := auxIntToInt64(v_1.AuxInt)
8147 v.reset(OpRISCV64SLLIW)
8148 v.AuxInt = int64ToAuxInt(val & 31)
8149 v.AddArg(x)
8150 return true
8151 }
8152 return false
8153 }
8154 func rewriteValueRISCV64_OpRISCV64SLT(v *Value) bool {
8155 v_1 := v.Args[1]
8156 v_0 := v.Args[0]
8157
8158
8159
8160 for {
8161 x := v_0
8162 if v_1.Op != OpRISCV64MOVDconst {
8163 break
8164 }
8165 val := auxIntToInt64(v_1.AuxInt)
8166 if !(is12Bit(val)) {
8167 break
8168 }
8169 v.reset(OpRISCV64SLTI)
8170 v.AuxInt = int64ToAuxInt(val)
8171 v.AddArg(x)
8172 return true
8173 }
8174
8175
8176 for {
8177 x := v_0
8178 if x != v_1 {
8179 break
8180 }
8181 v.reset(OpRISCV64MOVDconst)
8182 v.AuxInt = int64ToAuxInt(0)
8183 return true
8184 }
8185 return false
8186 }
8187 func rewriteValueRISCV64_OpRISCV64SLTI(v *Value) bool {
8188 v_0 := v.Args[0]
8189
8190
8191 for {
8192 x := auxIntToInt64(v.AuxInt)
8193 if v_0.Op != OpRISCV64MOVDconst {
8194 break
8195 }
8196 y := auxIntToInt64(v_0.AuxInt)
8197 v.reset(OpRISCV64MOVDconst)
8198 v.AuxInt = int64ToAuxInt(b2i(int64(y) < int64(x)))
8199 return true
8200 }
8201
8202
8203
8204 for {
8205 x := auxIntToInt64(v.AuxInt)
8206 if v_0.Op != OpRISCV64ANDI {
8207 break
8208 }
8209 y := auxIntToInt64(v_0.AuxInt)
8210 if !(y >= 0 && int64(y) < int64(x)) {
8211 break
8212 }
8213 v.reset(OpRISCV64MOVDconst)
8214 v.AuxInt = int64ToAuxInt(1)
8215 return true
8216 }
8217 return false
8218 }
8219 func rewriteValueRISCV64_OpRISCV64SLTIU(v *Value) bool {
8220 v_0 := v.Args[0]
8221
8222
8223 for {
8224 x := auxIntToInt64(v.AuxInt)
8225 if v_0.Op != OpRISCV64MOVDconst {
8226 break
8227 }
8228 y := auxIntToInt64(v_0.AuxInt)
8229 v.reset(OpRISCV64MOVDconst)
8230 v.AuxInt = int64ToAuxInt(b2i(uint64(y) < uint64(x)))
8231 return true
8232 }
8233
8234
8235
8236 for {
8237 x := auxIntToInt64(v.AuxInt)
8238 if v_0.Op != OpRISCV64ANDI {
8239 break
8240 }
8241 y := auxIntToInt64(v_0.AuxInt)
8242 if !(y >= 0 && uint64(y) < uint64(x)) {
8243 break
8244 }
8245 v.reset(OpRISCV64MOVDconst)
8246 v.AuxInt = int64ToAuxInt(1)
8247 return true
8248 }
8249
8250
8251
8252 for {
8253 x := auxIntToInt64(v.AuxInt)
8254 if v_0.Op != OpRISCV64ORI {
8255 break
8256 }
8257 y := auxIntToInt64(v_0.AuxInt)
8258 if !(y >= 0 && uint64(y) >= uint64(x)) {
8259 break
8260 }
8261 v.reset(OpRISCV64MOVDconst)
8262 v.AuxInt = int64ToAuxInt(0)
8263 return true
8264 }
8265 return false
8266 }
8267 func rewriteValueRISCV64_OpRISCV64SLTU(v *Value) bool {
8268 v_1 := v.Args[1]
8269 v_0 := v.Args[0]
8270
8271
8272
8273 for {
8274 x := v_0
8275 if v_1.Op != OpRISCV64MOVDconst {
8276 break
8277 }
8278 val := auxIntToInt64(v_1.AuxInt)
8279 if !(is12Bit(val)) {
8280 break
8281 }
8282 v.reset(OpRISCV64SLTIU)
8283 v.AuxInt = int64ToAuxInt(val)
8284 v.AddArg(x)
8285 return true
8286 }
8287
8288
8289 for {
8290 x := v_0
8291 if x != v_1 {
8292 break
8293 }
8294 v.reset(OpRISCV64MOVDconst)
8295 v.AuxInt = int64ToAuxInt(0)
8296 return true
8297 }
8298 return false
8299 }
8300 func rewriteValueRISCV64_OpRISCV64SNEZ(v *Value) bool {
8301 v_0 := v.Args[0]
8302 b := v.Block
8303 typ := &b.Func.Config.Types
8304
8305
8306 for {
8307 if v_0.Op != OpRISCV64NEG {
8308 break
8309 }
8310 x := v_0.Args[0]
8311 v.reset(OpRISCV64SNEZ)
8312 v.AddArg(x)
8313 return true
8314 }
8315
8316
8317 for {
8318 if v_0.Op != OpRISCV64SEQZ {
8319 break
8320 }
8321 x := v_0.Args[0]
8322 v.reset(OpRISCV64SEQZ)
8323 v.AddArg(x)
8324 return true
8325 }
8326
8327
8328 for {
8329 if v_0.Op != OpRISCV64SNEZ {
8330 break
8331 }
8332 x := v_0.Args[0]
8333 v.reset(OpRISCV64SNEZ)
8334 v.AddArg(x)
8335 return true
8336 }
8337
8338
8339 for {
8340 if v_0.Op != OpRISCV64ANDI {
8341 break
8342 }
8343 c := auxIntToInt64(v_0.AuxInt)
8344 v_0_0 := v_0.Args[0]
8345 if v_0_0.Op != OpRISCV64FCLASSD {
8346 break
8347 }
8348 v_0_0_0 := v_0_0.Args[0]
8349 if v_0_0_0.Op != OpRISCV64FNEGD {
8350 break
8351 }
8352 x := v_0_0_0.Args[0]
8353 v.reset(OpRISCV64SNEZ)
8354 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8355 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
8356 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8357 v1.AddArg(x)
8358 v0.AddArg(v1)
8359 v.AddArg(v0)
8360 return true
8361 }
8362
8363
8364 for {
8365 if v_0.Op != OpRISCV64ANDI {
8366 break
8367 }
8368 c := auxIntToInt64(v_0.AuxInt)
8369 v_0_0 := v_0.Args[0]
8370 if v_0_0.Op != OpRISCV64FCLASSD {
8371 break
8372 }
8373 v_0_0_0 := v_0_0.Args[0]
8374 if v_0_0_0.Op != OpRISCV64FABSD {
8375 break
8376 }
8377 x := v_0_0_0.Args[0]
8378 v.reset(OpRISCV64SNEZ)
8379 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Int64)
8380 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
8381 v1 := b.NewValue0(v.Pos, OpRISCV64FCLASSD, typ.Int64)
8382 v1.AddArg(x)
8383 v0.AddArg(v1)
8384 v.AddArg(v0)
8385 return true
8386 }
8387 return false
8388 }
8389 func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
8390 v_1 := v.Args[1]
8391 v_0 := v.Args[0]
8392
8393
8394 for {
8395 x := v_0
8396 if v_1.Op != OpRISCV64MOVDconst {
8397 break
8398 }
8399 val := auxIntToInt64(v_1.AuxInt)
8400 v.reset(OpRISCV64SRAI)
8401 v.AuxInt = int64ToAuxInt(val & 63)
8402 v.AddArg(x)
8403 return true
8404 }
8405 return false
8406 }
8407 func rewriteValueRISCV64_OpRISCV64SRAI(v *Value) bool {
8408 v_0 := v.Args[0]
8409 b := v.Block
8410
8411
8412
8413 for {
8414 x := auxIntToInt64(v.AuxInt)
8415 if v_0.Op != OpRISCV64MOVWreg {
8416 break
8417 }
8418 y := v_0.Args[0]
8419 if !(x >= 0 && x <= 31) {
8420 break
8421 }
8422 v.reset(OpRISCV64SRAIW)
8423 v.AuxInt = int64ToAuxInt(x)
8424 v.AddArg(y)
8425 return true
8426 }
8427
8428
8429
8430 for {
8431 t := v.Type
8432 x := auxIntToInt64(v.AuxInt)
8433 if v_0.Op != OpRISCV64MOVBreg {
8434 break
8435 }
8436 y := v_0.Args[0]
8437 if !(x >= 8) {
8438 break
8439 }
8440 v.reset(OpRISCV64SRAI)
8441 v.AuxInt = int64ToAuxInt(63)
8442 v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
8443 v0.AuxInt = int64ToAuxInt(56)
8444 v0.AddArg(y)
8445 v.AddArg(v0)
8446 return true
8447 }
8448
8449
8450
8451 for {
8452 t := v.Type
8453 x := auxIntToInt64(v.AuxInt)
8454 if v_0.Op != OpRISCV64MOVHreg {
8455 break
8456 }
8457 y := v_0.Args[0]
8458 if !(x >= 16) {
8459 break
8460 }
8461 v.reset(OpRISCV64SRAI)
8462 v.AuxInt = int64ToAuxInt(63)
8463 v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
8464 v0.AuxInt = int64ToAuxInt(48)
8465 v0.AddArg(y)
8466 v.AddArg(v0)
8467 return true
8468 }
8469
8470
8471
8472 for {
8473 x := auxIntToInt64(v.AuxInt)
8474 if v_0.Op != OpRISCV64MOVWreg {
8475 break
8476 }
8477 y := v_0.Args[0]
8478 if !(x >= 32) {
8479 break
8480 }
8481 v.reset(OpRISCV64SRAIW)
8482 v.AuxInt = int64ToAuxInt(31)
8483 v.AddArg(y)
8484 return true
8485 }
8486
8487
8488 for {
8489 x := auxIntToInt64(v.AuxInt)
8490 if v_0.Op != OpRISCV64MOVDconst {
8491 break
8492 }
8493 y := auxIntToInt64(v_0.AuxInt)
8494 v.reset(OpRISCV64MOVDconst)
8495 v.AuxInt = int64ToAuxInt(int64(y) >> uint32(x))
8496 return true
8497 }
8498 return false
8499 }
8500 func rewriteValueRISCV64_OpRISCV64SRAW(v *Value) bool {
8501 v_1 := v.Args[1]
8502 v_0 := v.Args[0]
8503
8504
8505 for {
8506 x := v_0
8507 if v_1.Op != OpRISCV64MOVDconst {
8508 break
8509 }
8510 val := auxIntToInt64(v_1.AuxInt)
8511 v.reset(OpRISCV64SRAIW)
8512 v.AuxInt = int64ToAuxInt(val & 31)
8513 v.AddArg(x)
8514 return true
8515 }
8516 return false
8517 }
8518 func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
8519 v_1 := v.Args[1]
8520 v_0 := v.Args[0]
8521
8522
8523 for {
8524 x := v_0
8525 if v_1.Op != OpRISCV64MOVDconst {
8526 break
8527 }
8528 val := auxIntToInt64(v_1.AuxInt)
8529 v.reset(OpRISCV64SRLI)
8530 v.AuxInt = int64ToAuxInt(val & 63)
8531 v.AddArg(x)
8532 return true
8533 }
8534 return false
8535 }
8536 func rewriteValueRISCV64_OpRISCV64SRLI(v *Value) bool {
8537 v_0 := v.Args[0]
8538
8539
8540
8541 for {
8542 x := auxIntToInt64(v.AuxInt)
8543 if v_0.Op != OpRISCV64MOVWUreg {
8544 break
8545 }
8546 y := v_0.Args[0]
8547 if !(x >= 0 && x <= 31) {
8548 break
8549 }
8550 v.reset(OpRISCV64SRLIW)
8551 v.AuxInt = int64ToAuxInt(x)
8552 v.AddArg(y)
8553 return true
8554 }
8555
8556
8557
8558 for {
8559 x := auxIntToInt64(v.AuxInt)
8560 if v_0.Op != OpRISCV64MOVBUreg {
8561 break
8562 }
8563 if !(x >= 8) {
8564 break
8565 }
8566 v.reset(OpRISCV64MOVDconst)
8567 v.AuxInt = int64ToAuxInt(0)
8568 return true
8569 }
8570
8571
8572
8573 for {
8574 x := auxIntToInt64(v.AuxInt)
8575 if v_0.Op != OpRISCV64MOVHUreg {
8576 break
8577 }
8578 if !(x >= 16) {
8579 break
8580 }
8581 v.reset(OpRISCV64MOVDconst)
8582 v.AuxInt = int64ToAuxInt(0)
8583 return true
8584 }
8585
8586
8587
8588 for {
8589 x := auxIntToInt64(v.AuxInt)
8590 if v_0.Op != OpRISCV64MOVWUreg {
8591 break
8592 }
8593 if !(x >= 32) {
8594 break
8595 }
8596 v.reset(OpRISCV64MOVDconst)
8597 v.AuxInt = int64ToAuxInt(0)
8598 return true
8599 }
8600
8601
8602 for {
8603 x := auxIntToInt64(v.AuxInt)
8604 if v_0.Op != OpRISCV64MOVDconst {
8605 break
8606 }
8607 y := auxIntToInt64(v_0.AuxInt)
8608 v.reset(OpRISCV64MOVDconst)
8609 v.AuxInt = int64ToAuxInt(int64(uint64(y) >> uint32(x)))
8610 return true
8611 }
8612 return false
8613 }
8614 func rewriteValueRISCV64_OpRISCV64SRLW(v *Value) bool {
8615 v_1 := v.Args[1]
8616 v_0 := v.Args[0]
8617
8618
8619 for {
8620 x := v_0
8621 if v_1.Op != OpRISCV64MOVDconst {
8622 break
8623 }
8624 val := auxIntToInt64(v_1.AuxInt)
8625 v.reset(OpRISCV64SRLIW)
8626 v.AuxInt = int64ToAuxInt(val & 31)
8627 v.AddArg(x)
8628 return true
8629 }
8630 return false
8631 }
8632 func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
8633 v_1 := v.Args[1]
8634 v_0 := v.Args[0]
8635 b := v.Block
8636
8637
8638 for {
8639 x := v_0
8640 if v_1.Op != OpRISCV64NEG {
8641 break
8642 }
8643 y := v_1.Args[0]
8644 v.reset(OpRISCV64ADD)
8645 v.AddArg2(x, y)
8646 return true
8647 }
8648
8649
8650 for {
8651 x := v_0
8652 if x != v_1 {
8653 break
8654 }
8655 v.reset(OpRISCV64MOVDconst)
8656 v.AuxInt = int64ToAuxInt(0)
8657 return true
8658 }
8659
8660
8661
8662 for {
8663 x := v_0
8664 if v_1.Op != OpRISCV64MOVDconst {
8665 break
8666 }
8667 val := auxIntToInt64(v_1.AuxInt)
8668 if !(is32Bit(-val)) {
8669 break
8670 }
8671 v.reset(OpRISCV64ADDI)
8672 v.AuxInt = int64ToAuxInt(-val)
8673 v.AddArg(x)
8674 return true
8675 }
8676
8677
8678
8679 for {
8680 t := v.Type
8681 if v_0.Op != OpRISCV64MOVDconst {
8682 break
8683 }
8684 val := auxIntToInt64(v_0.AuxInt)
8685 y := v_1
8686 if !(is32Bit(-val)) {
8687 break
8688 }
8689 v.reset(OpRISCV64NEG)
8690 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, t)
8691 v0.AuxInt = int64ToAuxInt(-val)
8692 v0.AddArg(y)
8693 v.AddArg(v0)
8694 return true
8695 }
8696
8697
8698 for {
8699 x := v_0
8700 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
8701 break
8702 }
8703 v.copyOf(x)
8704 return true
8705 }
8706
8707
8708 for {
8709 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
8710 break
8711 }
8712 x := v_1
8713 v.reset(OpRISCV64NEG)
8714 v.AddArg(x)
8715 return true
8716 }
8717 return false
8718 }
8719 func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
8720 v_1 := v.Args[1]
8721 v_0 := v.Args[0]
8722
8723
8724 for {
8725 x := v_0
8726 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
8727 break
8728 }
8729 v.reset(OpRISCV64ADDIW)
8730 v.AuxInt = int64ToAuxInt(0)
8731 v.AddArg(x)
8732 return true
8733 }
8734
8735
8736 for {
8737 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
8738 break
8739 }
8740 x := v_1
8741 v.reset(OpRISCV64NEGW)
8742 v.AddArg(x)
8743 return true
8744 }
8745 return false
8746 }
8747 func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
8748 v_1 := v.Args[1]
8749 v_0 := v.Args[0]
8750
8751
8752
8753 for {
8754 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
8755 if v_0.Op != OpRISCV64MOVDconst {
8756 continue
8757 }
8758 val := auxIntToInt64(v_0.AuxInt)
8759 x := v_1
8760 if !(is32Bit(val)) {
8761 continue
8762 }
8763 v.reset(OpRISCV64XORI)
8764 v.AuxInt = int64ToAuxInt(val)
8765 v.AddArg(x)
8766 return true
8767 }
8768 break
8769 }
8770
8771
8772 for {
8773 x := v_0
8774 if x != v_1 {
8775 break
8776 }
8777 v.reset(OpRISCV64MOVDconst)
8778 v.AuxInt = int64ToAuxInt(0)
8779 return true
8780 }
8781 return false
8782 }
8783 func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
8784 v_1 := v.Args[1]
8785 v_0 := v.Args[0]
8786 b := v.Block
8787 typ := &b.Func.Config.Types
8788
8789
8790 for {
8791 t := v.Type
8792 x := v_0
8793 y := v_1
8794 v.reset(OpRISCV64OR)
8795 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
8796 v1 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8797 v1.AuxInt = int64ToAuxInt(15)
8798 v1.AddArg(y)
8799 v0.AddArg2(x, v1)
8800 v2 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8801 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8802 v3.AddArg(x)
8803 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8804 v4.AuxInt = int64ToAuxInt(15)
8805 v5 := b.NewValue0(v.Pos, OpRISCV64NEG, y.Type)
8806 v5.AddArg(y)
8807 v4.AddArg(v5)
8808 v2.AddArg2(v3, v4)
8809 v.AddArg2(v0, v2)
8810 return true
8811 }
8812 }
8813 func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
8814 v_1 := v.Args[1]
8815 v_0 := v.Args[0]
8816 b := v.Block
8817 typ := &b.Func.Config.Types
8818
8819
8820 for {
8821 t := v.Type
8822 x := v_0
8823 y := v_1
8824 v.reset(OpRISCV64OR)
8825 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
8826 v1 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8827 v1.AuxInt = int64ToAuxInt(7)
8828 v1.AddArg(y)
8829 v0.AddArg2(x, v1)
8830 v2 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8831 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8832 v3.AddArg(x)
8833 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
8834 v4.AuxInt = int64ToAuxInt(7)
8835 v5 := b.NewValue0(v.Pos, OpRISCV64NEG, y.Type)
8836 v5.AddArg(y)
8837 v4.AddArg(v5)
8838 v2.AddArg2(v3, v4)
8839 v.AddArg2(v0, v2)
8840 return true
8841 }
8842 }
8843 func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
8844 v_1 := v.Args[1]
8845 v_0 := v.Args[0]
8846 b := v.Block
8847 typ := &b.Func.Config.Types
8848
8849
8850
8851 for {
8852 t := v.Type
8853 x := v_0
8854 y := v_1
8855 if !(!shiftIsBounded(v)) {
8856 break
8857 }
8858 v.reset(OpRISCV64AND)
8859 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8860 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8861 v1.AddArg(x)
8862 v0.AddArg2(v1, y)
8863 v2 := b.NewValue0(v.Pos, OpNeg16, t)
8864 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8865 v3.AuxInt = int64ToAuxInt(64)
8866 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8867 v4.AddArg(y)
8868 v3.AddArg(v4)
8869 v2.AddArg(v3)
8870 v.AddArg2(v0, v2)
8871 return true
8872 }
8873
8874
8875
8876 for {
8877 x := v_0
8878 y := v_1
8879 if !(shiftIsBounded(v)) {
8880 break
8881 }
8882 v.reset(OpRISCV64SRL)
8883 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8884 v0.AddArg(x)
8885 v.AddArg2(v0, y)
8886 return true
8887 }
8888 return false
8889 }
8890 func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
8891 v_1 := v.Args[1]
8892 v_0 := v.Args[0]
8893 b := v.Block
8894 typ := &b.Func.Config.Types
8895
8896
8897
8898 for {
8899 t := v.Type
8900 x := v_0
8901 y := v_1
8902 if !(!shiftIsBounded(v)) {
8903 break
8904 }
8905 v.reset(OpRISCV64AND)
8906 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8907 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8908 v1.AddArg(x)
8909 v0.AddArg2(v1, y)
8910 v2 := b.NewValue0(v.Pos, OpNeg16, t)
8911 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8912 v3.AuxInt = int64ToAuxInt(64)
8913 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
8914 v4.AddArg(y)
8915 v3.AddArg(v4)
8916 v2.AddArg(v3)
8917 v.AddArg2(v0, v2)
8918 return true
8919 }
8920
8921
8922
8923 for {
8924 x := v_0
8925 y := v_1
8926 if !(shiftIsBounded(v)) {
8927 break
8928 }
8929 v.reset(OpRISCV64SRL)
8930 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8931 v0.AddArg(x)
8932 v.AddArg2(v0, y)
8933 return true
8934 }
8935 return false
8936 }
8937 func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
8938 v_1 := v.Args[1]
8939 v_0 := v.Args[0]
8940 b := v.Block
8941 typ := &b.Func.Config.Types
8942
8943
8944
8945 for {
8946 t := v.Type
8947 x := v_0
8948 y := v_1
8949 if !(!shiftIsBounded(v)) {
8950 break
8951 }
8952 v.reset(OpRISCV64AND)
8953 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8954 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8955 v1.AddArg(x)
8956 v0.AddArg2(v1, y)
8957 v2 := b.NewValue0(v.Pos, OpNeg16, t)
8958 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8959 v3.AuxInt = int64ToAuxInt(64)
8960 v3.AddArg(y)
8961 v2.AddArg(v3)
8962 v.AddArg2(v0, v2)
8963 return true
8964 }
8965
8966
8967
8968 for {
8969 x := v_0
8970 y := v_1
8971 if !(shiftIsBounded(v)) {
8972 break
8973 }
8974 v.reset(OpRISCV64SRL)
8975 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8976 v0.AddArg(x)
8977 v.AddArg2(v0, y)
8978 return true
8979 }
8980 return false
8981 }
8982 func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
8983 v_1 := v.Args[1]
8984 v_0 := v.Args[0]
8985 b := v.Block
8986 typ := &b.Func.Config.Types
8987
8988
8989
8990 for {
8991 t := v.Type
8992 x := v_0
8993 y := v_1
8994 if !(!shiftIsBounded(v)) {
8995 break
8996 }
8997 v.reset(OpRISCV64AND)
8998 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8999 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9000 v1.AddArg(x)
9001 v0.AddArg2(v1, y)
9002 v2 := b.NewValue0(v.Pos, OpNeg16, t)
9003 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9004 v3.AuxInt = int64ToAuxInt(64)
9005 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9006 v4.AddArg(y)
9007 v3.AddArg(v4)
9008 v2.AddArg(v3)
9009 v.AddArg2(v0, v2)
9010 return true
9011 }
9012
9013
9014
9015 for {
9016 x := v_0
9017 y := v_1
9018 if !(shiftIsBounded(v)) {
9019 break
9020 }
9021 v.reset(OpRISCV64SRL)
9022 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9023 v0.AddArg(x)
9024 v.AddArg2(v0, y)
9025 return true
9026 }
9027 return false
9028 }
9029 func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
9030 v_1 := v.Args[1]
9031 v_0 := v.Args[0]
9032 b := v.Block
9033 typ := &b.Func.Config.Types
9034
9035
9036
9037 for {
9038 t := v.Type
9039 x := v_0
9040 y := v_1
9041 if !(!shiftIsBounded(v)) {
9042 break
9043 }
9044 v.reset(OpRISCV64SRA)
9045 v.Type = t
9046 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9047 v0.AddArg(x)
9048 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9049 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9050 v2.AuxInt = int64ToAuxInt(-1)
9051 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9052 v3.AuxInt = int64ToAuxInt(64)
9053 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9054 v4.AddArg(y)
9055 v3.AddArg(v4)
9056 v2.AddArg(v3)
9057 v1.AddArg2(y, v2)
9058 v.AddArg2(v0, v1)
9059 return true
9060 }
9061
9062
9063
9064 for {
9065 x := v_0
9066 y := v_1
9067 if !(shiftIsBounded(v)) {
9068 break
9069 }
9070 v.reset(OpRISCV64SRA)
9071 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9072 v0.AddArg(x)
9073 v.AddArg2(v0, y)
9074 return true
9075 }
9076 return false
9077 }
9078 func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
9079 v_1 := v.Args[1]
9080 v_0 := v.Args[0]
9081 b := v.Block
9082 typ := &b.Func.Config.Types
9083
9084
9085
9086 for {
9087 t := v.Type
9088 x := v_0
9089 y := v_1
9090 if !(!shiftIsBounded(v)) {
9091 break
9092 }
9093 v.reset(OpRISCV64SRA)
9094 v.Type = t
9095 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9096 v0.AddArg(x)
9097 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9098 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9099 v2.AuxInt = int64ToAuxInt(-1)
9100 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9101 v3.AuxInt = int64ToAuxInt(64)
9102 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9103 v4.AddArg(y)
9104 v3.AddArg(v4)
9105 v2.AddArg(v3)
9106 v1.AddArg2(y, v2)
9107 v.AddArg2(v0, v1)
9108 return true
9109 }
9110
9111
9112
9113 for {
9114 x := v_0
9115 y := v_1
9116 if !(shiftIsBounded(v)) {
9117 break
9118 }
9119 v.reset(OpRISCV64SRA)
9120 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9121 v0.AddArg(x)
9122 v.AddArg2(v0, y)
9123 return true
9124 }
9125 return false
9126 }
9127 func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
9128 v_1 := v.Args[1]
9129 v_0 := v.Args[0]
9130 b := v.Block
9131 typ := &b.Func.Config.Types
9132
9133
9134
9135 for {
9136 t := v.Type
9137 x := v_0
9138 y := v_1
9139 if !(!shiftIsBounded(v)) {
9140 break
9141 }
9142 v.reset(OpRISCV64SRA)
9143 v.Type = t
9144 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9145 v0.AddArg(x)
9146 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9147 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9148 v2.AuxInt = int64ToAuxInt(-1)
9149 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9150 v3.AuxInt = int64ToAuxInt(64)
9151 v3.AddArg(y)
9152 v2.AddArg(v3)
9153 v1.AddArg2(y, v2)
9154 v.AddArg2(v0, v1)
9155 return true
9156 }
9157
9158
9159
9160 for {
9161 x := v_0
9162 y := v_1
9163 if !(shiftIsBounded(v)) {
9164 break
9165 }
9166 v.reset(OpRISCV64SRA)
9167 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9168 v0.AddArg(x)
9169 v.AddArg2(v0, y)
9170 return true
9171 }
9172 return false
9173 }
9174 func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
9175 v_1 := v.Args[1]
9176 v_0 := v.Args[0]
9177 b := v.Block
9178 typ := &b.Func.Config.Types
9179
9180
9181
9182 for {
9183 t := v.Type
9184 x := v_0
9185 y := v_1
9186 if !(!shiftIsBounded(v)) {
9187 break
9188 }
9189 v.reset(OpRISCV64SRA)
9190 v.Type = t
9191 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9192 v0.AddArg(x)
9193 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9194 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9195 v2.AuxInt = int64ToAuxInt(-1)
9196 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9197 v3.AuxInt = int64ToAuxInt(64)
9198 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9199 v4.AddArg(y)
9200 v3.AddArg(v4)
9201 v2.AddArg(v3)
9202 v1.AddArg2(y, v2)
9203 v.AddArg2(v0, v1)
9204 return true
9205 }
9206
9207
9208
9209 for {
9210 x := v_0
9211 y := v_1
9212 if !(shiftIsBounded(v)) {
9213 break
9214 }
9215 v.reset(OpRISCV64SRA)
9216 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
9217 v0.AddArg(x)
9218 v.AddArg2(v0, y)
9219 return true
9220 }
9221 return false
9222 }
9223 func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
9224 v_1 := v.Args[1]
9225 v_0 := v.Args[0]
9226 b := v.Block
9227 typ := &b.Func.Config.Types
9228
9229
9230
9231 for {
9232 t := v.Type
9233 x := v_0
9234 y := v_1
9235 if !(!shiftIsBounded(v)) {
9236 break
9237 }
9238 v.reset(OpRISCV64AND)
9239 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9240 v0.AddArg2(x, y)
9241 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9242 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9243 v2.AuxInt = int64ToAuxInt(32)
9244 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9245 v3.AddArg(y)
9246 v2.AddArg(v3)
9247 v1.AddArg(v2)
9248 v.AddArg2(v0, v1)
9249 return true
9250 }
9251
9252
9253
9254 for {
9255 x := v_0
9256 y := v_1
9257 if !(shiftIsBounded(v)) {
9258 break
9259 }
9260 v.reset(OpRISCV64SRLW)
9261 v.AddArg2(x, y)
9262 return true
9263 }
9264 return false
9265 }
9266 func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
9267 v_1 := v.Args[1]
9268 v_0 := v.Args[0]
9269 b := v.Block
9270 typ := &b.Func.Config.Types
9271
9272
9273
9274 for {
9275 t := v.Type
9276 x := v_0
9277 y := v_1
9278 if !(!shiftIsBounded(v)) {
9279 break
9280 }
9281 v.reset(OpRISCV64AND)
9282 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9283 v0.AddArg2(x, y)
9284 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9285 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9286 v2.AuxInt = int64ToAuxInt(32)
9287 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9288 v3.AddArg(y)
9289 v2.AddArg(v3)
9290 v1.AddArg(v2)
9291 v.AddArg2(v0, v1)
9292 return true
9293 }
9294
9295
9296
9297 for {
9298 x := v_0
9299 y := v_1
9300 if !(shiftIsBounded(v)) {
9301 break
9302 }
9303 v.reset(OpRISCV64SRLW)
9304 v.AddArg2(x, y)
9305 return true
9306 }
9307 return false
9308 }
9309 func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
9310 v_1 := v.Args[1]
9311 v_0 := v.Args[0]
9312 b := v.Block
9313
9314
9315
9316 for {
9317 t := v.Type
9318 x := v_0
9319 y := v_1
9320 if !(!shiftIsBounded(v)) {
9321 break
9322 }
9323 v.reset(OpRISCV64AND)
9324 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9325 v0.AddArg2(x, y)
9326 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9327 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9328 v2.AuxInt = int64ToAuxInt(32)
9329 v2.AddArg(y)
9330 v1.AddArg(v2)
9331 v.AddArg2(v0, v1)
9332 return true
9333 }
9334
9335
9336
9337 for {
9338 x := v_0
9339 y := v_1
9340 if !(shiftIsBounded(v)) {
9341 break
9342 }
9343 v.reset(OpRISCV64SRLW)
9344 v.AddArg2(x, y)
9345 return true
9346 }
9347 return false
9348 }
9349 func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
9350 v_1 := v.Args[1]
9351 v_0 := v.Args[0]
9352 b := v.Block
9353 typ := &b.Func.Config.Types
9354
9355
9356
9357 for {
9358 t := v.Type
9359 x := v_0
9360 y := v_1
9361 if !(!shiftIsBounded(v)) {
9362 break
9363 }
9364 v.reset(OpRISCV64AND)
9365 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
9366 v0.AddArg2(x, y)
9367 v1 := b.NewValue0(v.Pos, OpNeg32, t)
9368 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9369 v2.AuxInt = int64ToAuxInt(32)
9370 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9371 v3.AddArg(y)
9372 v2.AddArg(v3)
9373 v1.AddArg(v2)
9374 v.AddArg2(v0, v1)
9375 return true
9376 }
9377
9378
9379
9380 for {
9381 x := v_0
9382 y := v_1
9383 if !(shiftIsBounded(v)) {
9384 break
9385 }
9386 v.reset(OpRISCV64SRLW)
9387 v.AddArg2(x, y)
9388 return true
9389 }
9390 return false
9391 }
9392 func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
9393 v_1 := v.Args[1]
9394 v_0 := v.Args[0]
9395 b := v.Block
9396 typ := &b.Func.Config.Types
9397
9398
9399
9400 for {
9401 t := v.Type
9402 x := v_0
9403 y := v_1
9404 if !(!shiftIsBounded(v)) {
9405 break
9406 }
9407 v.reset(OpRISCV64SRAW)
9408 v.Type = t
9409 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9410 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9411 v1.AuxInt = int64ToAuxInt(-1)
9412 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9413 v2.AuxInt = int64ToAuxInt(32)
9414 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9415 v3.AddArg(y)
9416 v2.AddArg(v3)
9417 v1.AddArg(v2)
9418 v0.AddArg2(y, v1)
9419 v.AddArg2(x, v0)
9420 return true
9421 }
9422
9423
9424
9425 for {
9426 x := v_0
9427 y := v_1
9428 if !(shiftIsBounded(v)) {
9429 break
9430 }
9431 v.reset(OpRISCV64SRAW)
9432 v.AddArg2(x, y)
9433 return true
9434 }
9435 return false
9436 }
9437 func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
9438 v_1 := v.Args[1]
9439 v_0 := v.Args[0]
9440 b := v.Block
9441 typ := &b.Func.Config.Types
9442
9443
9444
9445 for {
9446 t := v.Type
9447 x := v_0
9448 y := v_1
9449 if !(!shiftIsBounded(v)) {
9450 break
9451 }
9452 v.reset(OpRISCV64SRAW)
9453 v.Type = t
9454 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9455 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9456 v1.AuxInt = int64ToAuxInt(-1)
9457 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9458 v2.AuxInt = int64ToAuxInt(32)
9459 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9460 v3.AddArg(y)
9461 v2.AddArg(v3)
9462 v1.AddArg(v2)
9463 v0.AddArg2(y, v1)
9464 v.AddArg2(x, v0)
9465 return true
9466 }
9467
9468
9469
9470 for {
9471 x := v_0
9472 y := v_1
9473 if !(shiftIsBounded(v)) {
9474 break
9475 }
9476 v.reset(OpRISCV64SRAW)
9477 v.AddArg2(x, y)
9478 return true
9479 }
9480 return false
9481 }
9482 func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
9483 v_1 := v.Args[1]
9484 v_0 := v.Args[0]
9485 b := v.Block
9486
9487
9488
9489 for {
9490 t := v.Type
9491 x := v_0
9492 y := v_1
9493 if !(!shiftIsBounded(v)) {
9494 break
9495 }
9496 v.reset(OpRISCV64SRAW)
9497 v.Type = t
9498 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9499 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9500 v1.AuxInt = int64ToAuxInt(-1)
9501 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9502 v2.AuxInt = int64ToAuxInt(32)
9503 v2.AddArg(y)
9504 v1.AddArg(v2)
9505 v0.AddArg2(y, v1)
9506 v.AddArg2(x, v0)
9507 return true
9508 }
9509
9510
9511
9512 for {
9513 x := v_0
9514 y := v_1
9515 if !(shiftIsBounded(v)) {
9516 break
9517 }
9518 v.reset(OpRISCV64SRAW)
9519 v.AddArg2(x, y)
9520 return true
9521 }
9522 return false
9523 }
9524 func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
9525 v_1 := v.Args[1]
9526 v_0 := v.Args[0]
9527 b := v.Block
9528 typ := &b.Func.Config.Types
9529
9530
9531
9532 for {
9533 t := v.Type
9534 x := v_0
9535 y := v_1
9536 if !(!shiftIsBounded(v)) {
9537 break
9538 }
9539 v.reset(OpRISCV64SRAW)
9540 v.Type = t
9541 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9542 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9543 v1.AuxInt = int64ToAuxInt(-1)
9544 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9545 v2.AuxInt = int64ToAuxInt(32)
9546 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9547 v3.AddArg(y)
9548 v2.AddArg(v3)
9549 v1.AddArg(v2)
9550 v0.AddArg2(y, v1)
9551 v.AddArg2(x, v0)
9552 return true
9553 }
9554
9555
9556
9557 for {
9558 x := v_0
9559 y := v_1
9560 if !(shiftIsBounded(v)) {
9561 break
9562 }
9563 v.reset(OpRISCV64SRAW)
9564 v.AddArg2(x, y)
9565 return true
9566 }
9567 return false
9568 }
9569 func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
9570 v_1 := v.Args[1]
9571 v_0 := v.Args[0]
9572 b := v.Block
9573 typ := &b.Func.Config.Types
9574
9575
9576
9577 for {
9578 t := v.Type
9579 x := v_0
9580 y := v_1
9581 if !(!shiftIsBounded(v)) {
9582 break
9583 }
9584 v.reset(OpRISCV64AND)
9585 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9586 v0.AddArg2(x, y)
9587 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9588 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9589 v2.AuxInt = int64ToAuxInt(64)
9590 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9591 v3.AddArg(y)
9592 v2.AddArg(v3)
9593 v1.AddArg(v2)
9594 v.AddArg2(v0, v1)
9595 return true
9596 }
9597
9598
9599
9600 for {
9601 x := v_0
9602 y := v_1
9603 if !(shiftIsBounded(v)) {
9604 break
9605 }
9606 v.reset(OpRISCV64SRL)
9607 v.AddArg2(x, y)
9608 return true
9609 }
9610 return false
9611 }
9612 func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
9613 v_1 := v.Args[1]
9614 v_0 := v.Args[0]
9615 b := v.Block
9616 typ := &b.Func.Config.Types
9617
9618
9619
9620 for {
9621 t := v.Type
9622 x := v_0
9623 y := v_1
9624 if !(!shiftIsBounded(v)) {
9625 break
9626 }
9627 v.reset(OpRISCV64AND)
9628 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9629 v0.AddArg2(x, y)
9630 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9631 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9632 v2.AuxInt = int64ToAuxInt(64)
9633 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9634 v3.AddArg(y)
9635 v2.AddArg(v3)
9636 v1.AddArg(v2)
9637 v.AddArg2(v0, v1)
9638 return true
9639 }
9640
9641
9642
9643 for {
9644 x := v_0
9645 y := v_1
9646 if !(shiftIsBounded(v)) {
9647 break
9648 }
9649 v.reset(OpRISCV64SRL)
9650 v.AddArg2(x, y)
9651 return true
9652 }
9653 return false
9654 }
9655 func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
9656 v_1 := v.Args[1]
9657 v_0 := v.Args[0]
9658 b := v.Block
9659
9660
9661
9662 for {
9663 t := v.Type
9664 x := v_0
9665 y := v_1
9666 if !(!shiftIsBounded(v)) {
9667 break
9668 }
9669 v.reset(OpRISCV64AND)
9670 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9671 v0.AddArg2(x, y)
9672 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9673 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9674 v2.AuxInt = int64ToAuxInt(64)
9675 v2.AddArg(y)
9676 v1.AddArg(v2)
9677 v.AddArg2(v0, v1)
9678 return true
9679 }
9680
9681
9682
9683 for {
9684 x := v_0
9685 y := v_1
9686 if !(shiftIsBounded(v)) {
9687 break
9688 }
9689 v.reset(OpRISCV64SRL)
9690 v.AddArg2(x, y)
9691 return true
9692 }
9693 return false
9694 }
9695 func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
9696 v_1 := v.Args[1]
9697 v_0 := v.Args[0]
9698 b := v.Block
9699 typ := &b.Func.Config.Types
9700
9701
9702
9703 for {
9704 t := v.Type
9705 x := v_0
9706 y := v_1
9707 if !(!shiftIsBounded(v)) {
9708 break
9709 }
9710 v.reset(OpRISCV64AND)
9711 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9712 v0.AddArg2(x, y)
9713 v1 := b.NewValue0(v.Pos, OpNeg64, t)
9714 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9715 v2.AuxInt = int64ToAuxInt(64)
9716 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9717 v3.AddArg(y)
9718 v2.AddArg(v3)
9719 v1.AddArg(v2)
9720 v.AddArg2(v0, v1)
9721 return true
9722 }
9723
9724
9725
9726 for {
9727 x := v_0
9728 y := v_1
9729 if !(shiftIsBounded(v)) {
9730 break
9731 }
9732 v.reset(OpRISCV64SRL)
9733 v.AddArg2(x, y)
9734 return true
9735 }
9736 return false
9737 }
9738 func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
9739 v_1 := v.Args[1]
9740 v_0 := v.Args[0]
9741 b := v.Block
9742 typ := &b.Func.Config.Types
9743
9744
9745
9746 for {
9747 t := v.Type
9748 x := v_0
9749 y := v_1
9750 if !(!shiftIsBounded(v)) {
9751 break
9752 }
9753 v.reset(OpRISCV64SRA)
9754 v.Type = t
9755 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9756 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9757 v1.AuxInt = int64ToAuxInt(-1)
9758 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9759 v2.AuxInt = int64ToAuxInt(64)
9760 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9761 v3.AddArg(y)
9762 v2.AddArg(v3)
9763 v1.AddArg(v2)
9764 v0.AddArg2(y, v1)
9765 v.AddArg2(x, v0)
9766 return true
9767 }
9768
9769
9770
9771 for {
9772 x := v_0
9773 y := v_1
9774 if !(shiftIsBounded(v)) {
9775 break
9776 }
9777 v.reset(OpRISCV64SRA)
9778 v.AddArg2(x, y)
9779 return true
9780 }
9781 return false
9782 }
9783 func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
9784 v_1 := v.Args[1]
9785 v_0 := v.Args[0]
9786 b := v.Block
9787 typ := &b.Func.Config.Types
9788
9789
9790
9791 for {
9792 t := v.Type
9793 x := v_0
9794 y := v_1
9795 if !(!shiftIsBounded(v)) {
9796 break
9797 }
9798 v.reset(OpRISCV64SRA)
9799 v.Type = t
9800 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9801 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9802 v1.AuxInt = int64ToAuxInt(-1)
9803 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9804 v2.AuxInt = int64ToAuxInt(64)
9805 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9806 v3.AddArg(y)
9807 v2.AddArg(v3)
9808 v1.AddArg(v2)
9809 v0.AddArg2(y, v1)
9810 v.AddArg2(x, v0)
9811 return true
9812 }
9813
9814
9815
9816 for {
9817 x := v_0
9818 y := v_1
9819 if !(shiftIsBounded(v)) {
9820 break
9821 }
9822 v.reset(OpRISCV64SRA)
9823 v.AddArg2(x, y)
9824 return true
9825 }
9826 return false
9827 }
9828 func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
9829 v_1 := v.Args[1]
9830 v_0 := v.Args[0]
9831 b := v.Block
9832
9833
9834
9835 for {
9836 t := v.Type
9837 x := v_0
9838 y := v_1
9839 if !(!shiftIsBounded(v)) {
9840 break
9841 }
9842 v.reset(OpRISCV64SRA)
9843 v.Type = t
9844 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9845 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9846 v1.AuxInt = int64ToAuxInt(-1)
9847 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9848 v2.AuxInt = int64ToAuxInt(64)
9849 v2.AddArg(y)
9850 v1.AddArg(v2)
9851 v0.AddArg2(y, v1)
9852 v.AddArg2(x, v0)
9853 return true
9854 }
9855
9856
9857
9858 for {
9859 x := v_0
9860 y := v_1
9861 if !(shiftIsBounded(v)) {
9862 break
9863 }
9864 v.reset(OpRISCV64SRA)
9865 v.AddArg2(x, y)
9866 return true
9867 }
9868 return false
9869 }
9870 func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
9871 v_1 := v.Args[1]
9872 v_0 := v.Args[0]
9873 b := v.Block
9874 typ := &b.Func.Config.Types
9875
9876
9877
9878 for {
9879 t := v.Type
9880 x := v_0
9881 y := v_1
9882 if !(!shiftIsBounded(v)) {
9883 break
9884 }
9885 v.reset(OpRISCV64SRA)
9886 v.Type = t
9887 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
9888 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
9889 v1.AuxInt = int64ToAuxInt(-1)
9890 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
9891 v2.AuxInt = int64ToAuxInt(64)
9892 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9893 v3.AddArg(y)
9894 v2.AddArg(v3)
9895 v1.AddArg(v2)
9896 v0.AddArg2(y, v1)
9897 v.AddArg2(x, v0)
9898 return true
9899 }
9900
9901
9902
9903 for {
9904 x := v_0
9905 y := v_1
9906 if !(shiftIsBounded(v)) {
9907 break
9908 }
9909 v.reset(OpRISCV64SRA)
9910 v.AddArg2(x, y)
9911 return true
9912 }
9913 return false
9914 }
9915 func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
9916 v_1 := v.Args[1]
9917 v_0 := v.Args[0]
9918 b := v.Block
9919 typ := &b.Func.Config.Types
9920
9921
9922
9923 for {
9924 t := v.Type
9925 x := v_0
9926 y := v_1
9927 if !(!shiftIsBounded(v)) {
9928 break
9929 }
9930 v.reset(OpRISCV64AND)
9931 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9932 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9933 v1.AddArg(x)
9934 v0.AddArg2(v1, y)
9935 v2 := b.NewValue0(v.Pos, OpNeg8, t)
9936 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9937 v3.AuxInt = int64ToAuxInt(64)
9938 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
9939 v4.AddArg(y)
9940 v3.AddArg(v4)
9941 v2.AddArg(v3)
9942 v.AddArg2(v0, v2)
9943 return true
9944 }
9945
9946
9947
9948 for {
9949 x := v_0
9950 y := v_1
9951 if !(shiftIsBounded(v)) {
9952 break
9953 }
9954 v.reset(OpRISCV64SRL)
9955 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9956 v0.AddArg(x)
9957 v.AddArg2(v0, y)
9958 return true
9959 }
9960 return false
9961 }
9962 func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
9963 v_1 := v.Args[1]
9964 v_0 := v.Args[0]
9965 b := v.Block
9966 typ := &b.Func.Config.Types
9967
9968
9969
9970 for {
9971 t := v.Type
9972 x := v_0
9973 y := v_1
9974 if !(!shiftIsBounded(v)) {
9975 break
9976 }
9977 v.reset(OpRISCV64AND)
9978 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
9979 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
9980 v1.AddArg(x)
9981 v0.AddArg2(v1, y)
9982 v2 := b.NewValue0(v.Pos, OpNeg8, t)
9983 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
9984 v3.AuxInt = int64ToAuxInt(64)
9985 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
9986 v4.AddArg(y)
9987 v3.AddArg(v4)
9988 v2.AddArg(v3)
9989 v.AddArg2(v0, v2)
9990 return true
9991 }
9992
9993
9994
9995 for {
9996 x := v_0
9997 y := v_1
9998 if !(shiftIsBounded(v)) {
9999 break
10000 }
10001 v.reset(OpRISCV64SRL)
10002 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10003 v0.AddArg(x)
10004 v.AddArg2(v0, y)
10005 return true
10006 }
10007 return false
10008 }
10009 func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
10010 v_1 := v.Args[1]
10011 v_0 := v.Args[0]
10012 b := v.Block
10013 typ := &b.Func.Config.Types
10014
10015
10016
10017 for {
10018 t := v.Type
10019 x := v_0
10020 y := v_1
10021 if !(!shiftIsBounded(v)) {
10022 break
10023 }
10024 v.reset(OpRISCV64AND)
10025 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
10026 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10027 v1.AddArg(x)
10028 v0.AddArg2(v1, y)
10029 v2 := b.NewValue0(v.Pos, OpNeg8, t)
10030 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
10031 v3.AuxInt = int64ToAuxInt(64)
10032 v3.AddArg(y)
10033 v2.AddArg(v3)
10034 v.AddArg2(v0, v2)
10035 return true
10036 }
10037
10038
10039
10040 for {
10041 x := v_0
10042 y := v_1
10043 if !(shiftIsBounded(v)) {
10044 break
10045 }
10046 v.reset(OpRISCV64SRL)
10047 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10048 v0.AddArg(x)
10049 v.AddArg2(v0, y)
10050 return true
10051 }
10052 return false
10053 }
10054 func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
10055 v_1 := v.Args[1]
10056 v_0 := v.Args[0]
10057 b := v.Block
10058 typ := &b.Func.Config.Types
10059
10060
10061
10062 for {
10063 t := v.Type
10064 x := v_0
10065 y := v_1
10066 if !(!shiftIsBounded(v)) {
10067 break
10068 }
10069 v.reset(OpRISCV64AND)
10070 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
10071 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10072 v1.AddArg(x)
10073 v0.AddArg2(v1, y)
10074 v2 := b.NewValue0(v.Pos, OpNeg8, t)
10075 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
10076 v3.AuxInt = int64ToAuxInt(64)
10077 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10078 v4.AddArg(y)
10079 v3.AddArg(v4)
10080 v2.AddArg(v3)
10081 v.AddArg2(v0, v2)
10082 return true
10083 }
10084
10085
10086
10087 for {
10088 x := v_0
10089 y := v_1
10090 if !(shiftIsBounded(v)) {
10091 break
10092 }
10093 v.reset(OpRISCV64SRL)
10094 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10095 v0.AddArg(x)
10096 v.AddArg2(v0, y)
10097 return true
10098 }
10099 return false
10100 }
10101 func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
10102 v_1 := v.Args[1]
10103 v_0 := v.Args[0]
10104 b := v.Block
10105 typ := &b.Func.Config.Types
10106
10107
10108
10109 for {
10110 t := v.Type
10111 x := v_0
10112 y := v_1
10113 if !(!shiftIsBounded(v)) {
10114 break
10115 }
10116 v.reset(OpRISCV64SRA)
10117 v.Type = t
10118 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10119 v0.AddArg(x)
10120 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10121 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10122 v2.AuxInt = int64ToAuxInt(-1)
10123 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10124 v3.AuxInt = int64ToAuxInt(64)
10125 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
10126 v4.AddArg(y)
10127 v3.AddArg(v4)
10128 v2.AddArg(v3)
10129 v1.AddArg2(y, v2)
10130 v.AddArg2(v0, v1)
10131 return true
10132 }
10133
10134
10135
10136 for {
10137 x := v_0
10138 y := v_1
10139 if !(shiftIsBounded(v)) {
10140 break
10141 }
10142 v.reset(OpRISCV64SRA)
10143 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10144 v0.AddArg(x)
10145 v.AddArg2(v0, y)
10146 return true
10147 }
10148 return false
10149 }
10150 func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
10151 v_1 := v.Args[1]
10152 v_0 := v.Args[0]
10153 b := v.Block
10154 typ := &b.Func.Config.Types
10155
10156
10157
10158 for {
10159 t := v.Type
10160 x := v_0
10161 y := v_1
10162 if !(!shiftIsBounded(v)) {
10163 break
10164 }
10165 v.reset(OpRISCV64SRA)
10166 v.Type = t
10167 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10168 v0.AddArg(x)
10169 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10170 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10171 v2.AuxInt = int64ToAuxInt(-1)
10172 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10173 v3.AuxInt = int64ToAuxInt(64)
10174 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
10175 v4.AddArg(y)
10176 v3.AddArg(v4)
10177 v2.AddArg(v3)
10178 v1.AddArg2(y, v2)
10179 v.AddArg2(v0, v1)
10180 return true
10181 }
10182
10183
10184
10185 for {
10186 x := v_0
10187 y := v_1
10188 if !(shiftIsBounded(v)) {
10189 break
10190 }
10191 v.reset(OpRISCV64SRA)
10192 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10193 v0.AddArg(x)
10194 v.AddArg2(v0, y)
10195 return true
10196 }
10197 return false
10198 }
10199 func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
10200 v_1 := v.Args[1]
10201 v_0 := v.Args[0]
10202 b := v.Block
10203 typ := &b.Func.Config.Types
10204
10205
10206
10207 for {
10208 t := v.Type
10209 x := v_0
10210 y := v_1
10211 if !(!shiftIsBounded(v)) {
10212 break
10213 }
10214 v.reset(OpRISCV64SRA)
10215 v.Type = t
10216 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10217 v0.AddArg(x)
10218 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10219 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10220 v2.AuxInt = int64ToAuxInt(-1)
10221 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10222 v3.AuxInt = int64ToAuxInt(64)
10223 v3.AddArg(y)
10224 v2.AddArg(v3)
10225 v1.AddArg2(y, v2)
10226 v.AddArg2(v0, v1)
10227 return true
10228 }
10229
10230
10231
10232 for {
10233 x := v_0
10234 y := v_1
10235 if !(shiftIsBounded(v)) {
10236 break
10237 }
10238 v.reset(OpRISCV64SRA)
10239 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10240 v0.AddArg(x)
10241 v.AddArg2(v0, y)
10242 return true
10243 }
10244 return false
10245 }
10246 func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
10247 v_1 := v.Args[1]
10248 v_0 := v.Args[0]
10249 b := v.Block
10250 typ := &b.Func.Config.Types
10251
10252
10253
10254 for {
10255 t := v.Type
10256 x := v_0
10257 y := v_1
10258 if !(!shiftIsBounded(v)) {
10259 break
10260 }
10261 v.reset(OpRISCV64SRA)
10262 v.Type = t
10263 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10264 v0.AddArg(x)
10265 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
10266 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
10267 v2.AuxInt = int64ToAuxInt(-1)
10268 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
10269 v3.AuxInt = int64ToAuxInt(64)
10270 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
10271 v4.AddArg(y)
10272 v3.AddArg(v4)
10273 v2.AddArg(v3)
10274 v1.AddArg2(y, v2)
10275 v.AddArg2(v0, v1)
10276 return true
10277 }
10278
10279
10280
10281 for {
10282 x := v_0
10283 y := v_1
10284 if !(shiftIsBounded(v)) {
10285 break
10286 }
10287 v.reset(OpRISCV64SRA)
10288 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
10289 v0.AddArg(x)
10290 v.AddArg2(v0, y)
10291 return true
10292 }
10293 return false
10294 }
10295 func rewriteValueRISCV64_OpSelect0(v *Value) bool {
10296 v_0 := v.Args[0]
10297 b := v.Block
10298 typ := &b.Func.Config.Types
10299
10300
10301 for {
10302 if v_0.Op != OpAdd64carry {
10303 break
10304 }
10305 c := v_0.Args[2]
10306 x := v_0.Args[0]
10307 y := v_0.Args[1]
10308 v.reset(OpRISCV64ADD)
10309 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
10310 v0.AddArg2(x, y)
10311 v.AddArg2(v0, c)
10312 return true
10313 }
10314
10315
10316 for {
10317 if v_0.Op != OpSub64borrow {
10318 break
10319 }
10320 c := v_0.Args[2]
10321 x := v_0.Args[0]
10322 y := v_0.Args[1]
10323 v.reset(OpRISCV64SUB)
10324 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
10325 v0.AddArg2(x, y)
10326 v.AddArg2(v0, c)
10327 return true
10328 }
10329
10330
10331
10332 for {
10333 m := v_0
10334 if m.Op != OpRISCV64LoweredMuluhilo {
10335 break
10336 }
10337 y := m.Args[1]
10338 x := m.Args[0]
10339 if !(m.Uses == 1) {
10340 break
10341 }
10342 v.reset(OpRISCV64MULHU)
10343 v.AddArg2(x, y)
10344 return true
10345 }
10346 return false
10347 }
10348 func rewriteValueRISCV64_OpSelect1(v *Value) bool {
10349 v_0 := v.Args[0]
10350 b := v.Block
10351 typ := &b.Func.Config.Types
10352
10353
10354 for {
10355 if v_0.Op != OpAdd64carry {
10356 break
10357 }
10358 c := v_0.Args[2]
10359 x := v_0.Args[0]
10360 y := v_0.Args[1]
10361 v.reset(OpRISCV64OR)
10362 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10363 s := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
10364 s.AddArg2(x, y)
10365 v0.AddArg2(s, x)
10366 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10367 v3 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
10368 v3.AddArg2(s, c)
10369 v2.AddArg2(v3, s)
10370 v.AddArg2(v0, v2)
10371 return true
10372 }
10373
10374
10375 for {
10376 if v_0.Op != OpSub64borrow {
10377 break
10378 }
10379 c := v_0.Args[2]
10380 x := v_0.Args[0]
10381 y := v_0.Args[1]
10382 v.reset(OpRISCV64OR)
10383 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10384 s := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
10385 s.AddArg2(x, y)
10386 v0.AddArg2(x, s)
10387 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
10388 v3 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
10389 v3.AddArg2(s, c)
10390 v2.AddArg2(s, v3)
10391 v.AddArg2(v0, v2)
10392 return true
10393 }
10394
10395
10396
10397 for {
10398 m := v_0
10399 if m.Op != OpRISCV64LoweredMuluhilo {
10400 break
10401 }
10402 y := m.Args[1]
10403 x := m.Args[0]
10404 if !(m.Uses == 1) {
10405 break
10406 }
10407 v.reset(OpRISCV64MUL)
10408 v.AddArg2(x, y)
10409 return true
10410 }
10411 return false
10412 }
10413 func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
10414 v_0 := v.Args[0]
10415 b := v.Block
10416
10417
10418 for {
10419 t := v.Type
10420 x := v_0
10421 v.reset(OpRISCV64SRAI)
10422 v.AuxInt = int64ToAuxInt(63)
10423 v0 := b.NewValue0(v.Pos, OpRISCV64NEG, t)
10424 v0.AddArg(x)
10425 v.AddArg(v0)
10426 return true
10427 }
10428 }
10429 func rewriteValueRISCV64_OpStore(v *Value) bool {
10430 v_2 := v.Args[2]
10431 v_1 := v.Args[1]
10432 v_0 := v.Args[0]
10433
10434
10435
10436 for {
10437 t := auxToType(v.Aux)
10438 ptr := v_0
10439 val := v_1
10440 mem := v_2
10441 if !(t.Size() == 1) {
10442 break
10443 }
10444 v.reset(OpRISCV64MOVBstore)
10445 v.AddArg3(ptr, val, mem)
10446 return true
10447 }
10448
10449
10450
10451 for {
10452 t := auxToType(v.Aux)
10453 ptr := v_0
10454 val := v_1
10455 mem := v_2
10456 if !(t.Size() == 2) {
10457 break
10458 }
10459 v.reset(OpRISCV64MOVHstore)
10460 v.AddArg3(ptr, val, mem)
10461 return true
10462 }
10463
10464
10465
10466 for {
10467 t := auxToType(v.Aux)
10468 ptr := v_0
10469 val := v_1
10470 mem := v_2
10471 if !(t.Size() == 4 && !t.IsFloat()) {
10472 break
10473 }
10474 v.reset(OpRISCV64MOVWstore)
10475 v.AddArg3(ptr, val, mem)
10476 return true
10477 }
10478
10479
10480
10481 for {
10482 t := auxToType(v.Aux)
10483 ptr := v_0
10484 val := v_1
10485 mem := v_2
10486 if !(t.Size() == 8 && !t.IsFloat()) {
10487 break
10488 }
10489 v.reset(OpRISCV64MOVDstore)
10490 v.AddArg3(ptr, val, mem)
10491 return true
10492 }
10493
10494
10495
10496 for {
10497 t := auxToType(v.Aux)
10498 ptr := v_0
10499 val := v_1
10500 mem := v_2
10501 if !(t.Size() == 4 && t.IsFloat()) {
10502 break
10503 }
10504 v.reset(OpRISCV64FMOVWstore)
10505 v.AddArg3(ptr, val, mem)
10506 return true
10507 }
10508
10509
10510
10511 for {
10512 t := auxToType(v.Aux)
10513 ptr := v_0
10514 val := v_1
10515 mem := v_2
10516 if !(t.Size() == 8 && t.IsFloat()) {
10517 break
10518 }
10519 v.reset(OpRISCV64FMOVDstore)
10520 v.AddArg3(ptr, val, mem)
10521 return true
10522 }
10523 return false
10524 }
10525 func rewriteValueRISCV64_OpZero(v *Value) bool {
10526 v_1 := v.Args[1]
10527 v_0 := v.Args[0]
10528 b := v.Block
10529 config := b.Func.Config
10530 typ := &b.Func.Config.Types
10531
10532
10533 for {
10534 if auxIntToInt64(v.AuxInt) != 0 {
10535 break
10536 }
10537 mem := v_1
10538 v.copyOf(mem)
10539 return true
10540 }
10541
10542
10543 for {
10544 if auxIntToInt64(v.AuxInt) != 1 {
10545 break
10546 }
10547 ptr := v_0
10548 mem := v_1
10549 v.reset(OpRISCV64MOVBstore)
10550 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10551 v0.AuxInt = int64ToAuxInt(0)
10552 v.AddArg3(ptr, v0, mem)
10553 return true
10554 }
10555
10556
10557
10558 for {
10559 if auxIntToInt64(v.AuxInt) != 2 {
10560 break
10561 }
10562 t := auxToType(v.Aux)
10563 ptr := v_0
10564 mem := v_1
10565 if !(t.Alignment()%2 == 0) {
10566 break
10567 }
10568 v.reset(OpRISCV64MOVHstore)
10569 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10570 v0.AuxInt = int64ToAuxInt(0)
10571 v.AddArg3(ptr, v0, mem)
10572 return true
10573 }
10574
10575
10576 for {
10577 if auxIntToInt64(v.AuxInt) != 2 {
10578 break
10579 }
10580 ptr := v_0
10581 mem := v_1
10582 v.reset(OpRISCV64MOVBstore)
10583 v.AuxInt = int32ToAuxInt(1)
10584 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10585 v0.AuxInt = int64ToAuxInt(0)
10586 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10587 v1.AddArg3(ptr, v0, mem)
10588 v.AddArg3(ptr, v0, v1)
10589 return true
10590 }
10591
10592
10593
10594 for {
10595 if auxIntToInt64(v.AuxInt) != 4 {
10596 break
10597 }
10598 t := auxToType(v.Aux)
10599 ptr := v_0
10600 mem := v_1
10601 if !(t.Alignment()%4 == 0) {
10602 break
10603 }
10604 v.reset(OpRISCV64MOVWstore)
10605 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10606 v0.AuxInt = int64ToAuxInt(0)
10607 v.AddArg3(ptr, v0, mem)
10608 return true
10609 }
10610
10611
10612
10613 for {
10614 if auxIntToInt64(v.AuxInt) != 4 {
10615 break
10616 }
10617 t := auxToType(v.Aux)
10618 ptr := v_0
10619 mem := v_1
10620 if !(t.Alignment()%2 == 0) {
10621 break
10622 }
10623 v.reset(OpRISCV64MOVHstore)
10624 v.AuxInt = int32ToAuxInt(2)
10625 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10626 v0.AuxInt = int64ToAuxInt(0)
10627 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10628 v1.AddArg3(ptr, v0, mem)
10629 v.AddArg3(ptr, v0, v1)
10630 return true
10631 }
10632
10633
10634 for {
10635 if auxIntToInt64(v.AuxInt) != 4 {
10636 break
10637 }
10638 ptr := v_0
10639 mem := v_1
10640 v.reset(OpRISCV64MOVBstore)
10641 v.AuxInt = int32ToAuxInt(3)
10642 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10643 v0.AuxInt = int64ToAuxInt(0)
10644 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10645 v1.AuxInt = int32ToAuxInt(2)
10646 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10647 v2.AuxInt = int32ToAuxInt(1)
10648 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10649 v3.AddArg3(ptr, v0, mem)
10650 v2.AddArg3(ptr, v0, v3)
10651 v1.AddArg3(ptr, v0, v2)
10652 v.AddArg3(ptr, v0, v1)
10653 return true
10654 }
10655
10656
10657
10658 for {
10659 if auxIntToInt64(v.AuxInt) != 8 {
10660 break
10661 }
10662 t := auxToType(v.Aux)
10663 ptr := v_0
10664 mem := v_1
10665 if !(t.Alignment()%8 == 0) {
10666 break
10667 }
10668 v.reset(OpRISCV64MOVDstore)
10669 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10670 v0.AuxInt = int64ToAuxInt(0)
10671 v.AddArg3(ptr, v0, mem)
10672 return true
10673 }
10674
10675
10676
10677 for {
10678 if auxIntToInt64(v.AuxInt) != 8 {
10679 break
10680 }
10681 t := auxToType(v.Aux)
10682 ptr := v_0
10683 mem := v_1
10684 if !(t.Alignment()%4 == 0) {
10685 break
10686 }
10687 v.reset(OpRISCV64MOVWstore)
10688 v.AuxInt = int32ToAuxInt(4)
10689 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10690 v0.AuxInt = int64ToAuxInt(0)
10691 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
10692 v1.AddArg3(ptr, v0, mem)
10693 v.AddArg3(ptr, v0, v1)
10694 return true
10695 }
10696
10697
10698
10699 for {
10700 if auxIntToInt64(v.AuxInt) != 8 {
10701 break
10702 }
10703 t := auxToType(v.Aux)
10704 ptr := v_0
10705 mem := v_1
10706 if !(t.Alignment()%2 == 0) {
10707 break
10708 }
10709 v.reset(OpRISCV64MOVHstore)
10710 v.AuxInt = int32ToAuxInt(6)
10711 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10712 v0.AuxInt = int64ToAuxInt(0)
10713 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10714 v1.AuxInt = int32ToAuxInt(4)
10715 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10716 v2.AuxInt = int32ToAuxInt(2)
10717 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10718 v3.AddArg3(ptr, v0, mem)
10719 v2.AddArg3(ptr, v0, v3)
10720 v1.AddArg3(ptr, v0, v2)
10721 v.AddArg3(ptr, v0, v1)
10722 return true
10723 }
10724
10725
10726 for {
10727 if auxIntToInt64(v.AuxInt) != 3 {
10728 break
10729 }
10730 ptr := v_0
10731 mem := v_1
10732 v.reset(OpRISCV64MOVBstore)
10733 v.AuxInt = int32ToAuxInt(2)
10734 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10735 v0.AuxInt = int64ToAuxInt(0)
10736 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10737 v1.AuxInt = int32ToAuxInt(1)
10738 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
10739 v2.AddArg3(ptr, v0, mem)
10740 v1.AddArg3(ptr, v0, v2)
10741 v.AddArg3(ptr, v0, v1)
10742 return true
10743 }
10744
10745
10746
10747 for {
10748 if auxIntToInt64(v.AuxInt) != 6 {
10749 break
10750 }
10751 t := auxToType(v.Aux)
10752 ptr := v_0
10753 mem := v_1
10754 if !(t.Alignment()%2 == 0) {
10755 break
10756 }
10757 v.reset(OpRISCV64MOVHstore)
10758 v.AuxInt = int32ToAuxInt(4)
10759 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
10760 v0.AuxInt = int64ToAuxInt(0)
10761 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10762 v1.AuxInt = int32ToAuxInt(2)
10763 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
10764 v2.AddArg3(ptr, v0, mem)
10765 v1.AddArg3(ptr, v0, v2)
10766 v.AddArg3(ptr, v0, v1)
10767 return true
10768 }
10769
10770
10771
10772 for {
10773 s := auxIntToInt64(v.AuxInt)
10774 t := auxToType(v.Aux)
10775 ptr := v_0
10776 mem := v_1
10777 if !(s <= 24*moveSize(t.Alignment(), config)) {
10778 break
10779 }
10780 v.reset(OpRISCV64LoweredZero)
10781 v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s), int32(t.Alignment())))
10782 v.AddArg2(ptr, mem)
10783 return true
10784 }
10785
10786
10787
10788 for {
10789 s := auxIntToInt64(v.AuxInt)
10790 t := auxToType(v.Aux)
10791 ptr := v_0
10792 mem := v_1
10793 if !(s > 24*moveSize(t.Alignment(), config)) {
10794 break
10795 }
10796 v.reset(OpRISCV64LoweredZeroLoop)
10797 v.AuxInt = valAndOffToAuxInt(makeValAndOff(int32(s), int32(t.Alignment())))
10798 v.AddArg2(ptr, mem)
10799 return true
10800 }
10801 return false
10802 }
10803 func rewriteBlockRISCV64(b *Block) bool {
10804 typ := &b.Func.Config.Types
10805 switch b.Kind {
10806 case BlockRISCV64BEQ:
10807
10808
10809 for b.Controls[0].Op == OpRISCV64MOVDconst {
10810 v_0 := b.Controls[0]
10811 if auxIntToInt64(v_0.AuxInt) != 0 {
10812 break
10813 }
10814 cond := b.Controls[1]
10815 b.resetWithControl(BlockRISCV64BEQZ, cond)
10816 return true
10817 }
10818
10819
10820 for b.Controls[1].Op == OpRISCV64MOVDconst {
10821 cond := b.Controls[0]
10822 v_1 := b.Controls[1]
10823 if auxIntToInt64(v_1.AuxInt) != 0 {
10824 break
10825 }
10826 b.resetWithControl(BlockRISCV64BEQZ, cond)
10827 return true
10828 }
10829 case BlockRISCV64BEQZ:
10830
10831
10832 for b.Controls[0].Op == OpRISCV64SEQZ {
10833 v_0 := b.Controls[0]
10834 x := v_0.Args[0]
10835 b.resetWithControl(BlockRISCV64BNEZ, x)
10836 return true
10837 }
10838
10839
10840 for b.Controls[0].Op == OpRISCV64SNEZ {
10841 v_0 := b.Controls[0]
10842 x := v_0.Args[0]
10843 b.resetWithControl(BlockRISCV64BEQZ, x)
10844 return true
10845 }
10846
10847
10848 for b.Controls[0].Op == OpRISCV64NEG {
10849 v_0 := b.Controls[0]
10850 x := v_0.Args[0]
10851 b.resetWithControl(BlockRISCV64BEQZ, x)
10852 return true
10853 }
10854
10855
10856 for b.Controls[0].Op == OpRISCV64FNES {
10857 v_0 := b.Controls[0]
10858 t := v_0.Type
10859 _ = v_0.Args[1]
10860 v_0_0 := v_0.Args[0]
10861 v_0_1 := v_0.Args[1]
10862 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
10863 x := v_0_0
10864 y := v_0_1
10865 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
10866 v0.AddArg2(x, y)
10867 b.resetWithControl(BlockRISCV64BNEZ, v0)
10868 return true
10869 }
10870 }
10871
10872
10873 for b.Controls[0].Op == OpRISCV64FNED {
10874 v_0 := b.Controls[0]
10875 t := v_0.Type
10876 _ = v_0.Args[1]
10877 v_0_0 := v_0.Args[0]
10878 v_0_1 := v_0.Args[1]
10879 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
10880 x := v_0_0
10881 y := v_0_1
10882 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
10883 v0.AddArg2(x, y)
10884 b.resetWithControl(BlockRISCV64BNEZ, v0)
10885 return true
10886 }
10887 }
10888
10889
10890 for b.Controls[0].Op == OpRISCV64SUB {
10891 v_0 := b.Controls[0]
10892 y := v_0.Args[1]
10893 x := v_0.Args[0]
10894 b.resetWithControl2(BlockRISCV64BEQ, x, y)
10895 return true
10896 }
10897
10898
10899 for b.Controls[0].Op == OpRISCV64SLT {
10900 v_0 := b.Controls[0]
10901 y := v_0.Args[1]
10902 x := v_0.Args[0]
10903 b.resetWithControl2(BlockRISCV64BGE, x, y)
10904 return true
10905 }
10906
10907
10908 for b.Controls[0].Op == OpRISCV64SLTU {
10909 v_0 := b.Controls[0]
10910 y := v_0.Args[1]
10911 x := v_0.Args[0]
10912 b.resetWithControl2(BlockRISCV64BGEU, x, y)
10913 return true
10914 }
10915
10916
10917 for b.Controls[0].Op == OpRISCV64SLTI {
10918 v_0 := b.Controls[0]
10919 x := auxIntToInt64(v_0.AuxInt)
10920 y := v_0.Args[0]
10921 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
10922 v0.AuxInt = int64ToAuxInt(x)
10923 b.resetWithControl2(BlockRISCV64BGE, y, v0)
10924 return true
10925 }
10926
10927
10928 for b.Controls[0].Op == OpRISCV64SLTIU {
10929 v_0 := b.Controls[0]
10930 x := auxIntToInt64(v_0.AuxInt)
10931 y := v_0.Args[0]
10932 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
10933 v0.AuxInt = int64ToAuxInt(x)
10934 b.resetWithControl2(BlockRISCV64BGEU, y, v0)
10935 return true
10936 }
10937
10938
10939 for b.Controls[0].Op == OpRISCV64ANDI {
10940 v_0 := b.Controls[0]
10941 c := auxIntToInt64(v_0.AuxInt)
10942 v_0_0 := v_0.Args[0]
10943 if v_0_0.Op != OpRISCV64FCLASSD {
10944 break
10945 }
10946 v_0_0_0 := v_0_0.Args[0]
10947 if v_0_0_0.Op != OpRISCV64FNEGD {
10948 break
10949 }
10950 x := v_0_0_0.Args[0]
10951 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
10952 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
10953 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
10954 v1.AddArg(x)
10955 v0.AddArg(v1)
10956 b.resetWithControl(BlockRISCV64BEQZ, v0)
10957 return true
10958 }
10959
10960
10961 for b.Controls[0].Op == OpRISCV64ANDI {
10962 v_0 := b.Controls[0]
10963 c := auxIntToInt64(v_0.AuxInt)
10964 v_0_0 := v_0.Args[0]
10965 if v_0_0.Op != OpRISCV64FCLASSD {
10966 break
10967 }
10968 v_0_0_0 := v_0_0.Args[0]
10969 if v_0_0_0.Op != OpRISCV64FABSD {
10970 break
10971 }
10972 x := v_0_0_0.Args[0]
10973 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
10974 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
10975 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
10976 v1.AddArg(x)
10977 v0.AddArg(v1)
10978 b.resetWithControl(BlockRISCV64BEQZ, v0)
10979 return true
10980 }
10981 case BlockRISCV64BGE:
10982
10983
10984 for b.Controls[0].Op == OpRISCV64MOVDconst {
10985 v_0 := b.Controls[0]
10986 if auxIntToInt64(v_0.AuxInt) != 0 {
10987 break
10988 }
10989 cond := b.Controls[1]
10990 b.resetWithControl(BlockRISCV64BLEZ, cond)
10991 return true
10992 }
10993
10994
10995 for b.Controls[1].Op == OpRISCV64MOVDconst {
10996 cond := b.Controls[0]
10997 v_1 := b.Controls[1]
10998 if auxIntToInt64(v_1.AuxInt) != 0 {
10999 break
11000 }
11001 b.resetWithControl(BlockRISCV64BGEZ, cond)
11002 return true
11003 }
11004 case BlockRISCV64BGEU:
11005
11006
11007 for b.Controls[0].Op == OpRISCV64MOVDconst {
11008 v_0 := b.Controls[0]
11009 if auxIntToInt64(v_0.AuxInt) != 0 {
11010 break
11011 }
11012 cond := b.Controls[1]
11013 b.resetWithControl(BlockRISCV64BEQZ, cond)
11014 return true
11015 }
11016 case BlockRISCV64BLT:
11017
11018
11019 for b.Controls[0].Op == OpRISCV64MOVDconst {
11020 v_0 := b.Controls[0]
11021 if auxIntToInt64(v_0.AuxInt) != 0 {
11022 break
11023 }
11024 cond := b.Controls[1]
11025 b.resetWithControl(BlockRISCV64BGTZ, cond)
11026 return true
11027 }
11028
11029
11030 for b.Controls[1].Op == OpRISCV64MOVDconst {
11031 cond := b.Controls[0]
11032 v_1 := b.Controls[1]
11033 if auxIntToInt64(v_1.AuxInt) != 0 {
11034 break
11035 }
11036 b.resetWithControl(BlockRISCV64BLTZ, cond)
11037 return true
11038 }
11039 case BlockRISCV64BLTU:
11040
11041
11042 for b.Controls[0].Op == OpRISCV64MOVDconst {
11043 v_0 := b.Controls[0]
11044 if auxIntToInt64(v_0.AuxInt) != 0 {
11045 break
11046 }
11047 cond := b.Controls[1]
11048 b.resetWithControl(BlockRISCV64BNEZ, cond)
11049 return true
11050 }
11051 case BlockRISCV64BNE:
11052
11053
11054 for b.Controls[0].Op == OpRISCV64MOVDconst {
11055 v_0 := b.Controls[0]
11056 if auxIntToInt64(v_0.AuxInt) != 0 {
11057 break
11058 }
11059 cond := b.Controls[1]
11060 b.resetWithControl(BlockRISCV64BNEZ, cond)
11061 return true
11062 }
11063
11064
11065 for b.Controls[1].Op == OpRISCV64MOVDconst {
11066 cond := b.Controls[0]
11067 v_1 := b.Controls[1]
11068 if auxIntToInt64(v_1.AuxInt) != 0 {
11069 break
11070 }
11071 b.resetWithControl(BlockRISCV64BNEZ, cond)
11072 return true
11073 }
11074 case BlockRISCV64BNEZ:
11075
11076
11077 for b.Controls[0].Op == OpRISCV64SEQZ {
11078 v_0 := b.Controls[0]
11079 x := v_0.Args[0]
11080 b.resetWithControl(BlockRISCV64BEQZ, x)
11081 return true
11082 }
11083
11084
11085 for b.Controls[0].Op == OpRISCV64SNEZ {
11086 v_0 := b.Controls[0]
11087 x := v_0.Args[0]
11088 b.resetWithControl(BlockRISCV64BNEZ, x)
11089 return true
11090 }
11091
11092
11093 for b.Controls[0].Op == OpRISCV64NEG {
11094 v_0 := b.Controls[0]
11095 x := v_0.Args[0]
11096 b.resetWithControl(BlockRISCV64BNEZ, x)
11097 return true
11098 }
11099
11100
11101 for b.Controls[0].Op == OpRISCV64FNES {
11102 v_0 := b.Controls[0]
11103 t := v_0.Type
11104 _ = v_0.Args[1]
11105 v_0_0 := v_0.Args[0]
11106 v_0_1 := v_0.Args[1]
11107 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
11108 x := v_0_0
11109 y := v_0_1
11110 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
11111 v0.AddArg2(x, y)
11112 b.resetWithControl(BlockRISCV64BEQZ, v0)
11113 return true
11114 }
11115 }
11116
11117
11118 for b.Controls[0].Op == OpRISCV64FNED {
11119 v_0 := b.Controls[0]
11120 t := v_0.Type
11121 _ = v_0.Args[1]
11122 v_0_0 := v_0.Args[0]
11123 v_0_1 := v_0.Args[1]
11124 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
11125 x := v_0_0
11126 y := v_0_1
11127 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
11128 v0.AddArg2(x, y)
11129 b.resetWithControl(BlockRISCV64BEQZ, v0)
11130 return true
11131 }
11132 }
11133
11134
11135 for b.Controls[0].Op == OpRISCV64SUB {
11136 v_0 := b.Controls[0]
11137 y := v_0.Args[1]
11138 x := v_0.Args[0]
11139 b.resetWithControl2(BlockRISCV64BNE, x, y)
11140 return true
11141 }
11142
11143
11144 for b.Controls[0].Op == OpRISCV64SLT {
11145 v_0 := b.Controls[0]
11146 y := v_0.Args[1]
11147 x := v_0.Args[0]
11148 b.resetWithControl2(BlockRISCV64BLT, x, y)
11149 return true
11150 }
11151
11152
11153 for b.Controls[0].Op == OpRISCV64SLTU {
11154 v_0 := b.Controls[0]
11155 y := v_0.Args[1]
11156 x := v_0.Args[0]
11157 b.resetWithControl2(BlockRISCV64BLTU, x, y)
11158 return true
11159 }
11160
11161
11162 for b.Controls[0].Op == OpRISCV64SLTI {
11163 v_0 := b.Controls[0]
11164 x := auxIntToInt64(v_0.AuxInt)
11165 y := v_0.Args[0]
11166 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
11167 v0.AuxInt = int64ToAuxInt(x)
11168 b.resetWithControl2(BlockRISCV64BLT, y, v0)
11169 return true
11170 }
11171
11172
11173 for b.Controls[0].Op == OpRISCV64SLTIU {
11174 v_0 := b.Controls[0]
11175 x := auxIntToInt64(v_0.AuxInt)
11176 y := v_0.Args[0]
11177 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
11178 v0.AuxInt = int64ToAuxInt(x)
11179 b.resetWithControl2(BlockRISCV64BLTU, y, v0)
11180 return true
11181 }
11182
11183
11184 for b.Controls[0].Op == OpRISCV64ANDI {
11185 v_0 := b.Controls[0]
11186 c := auxIntToInt64(v_0.AuxInt)
11187 v_0_0 := v_0.Args[0]
11188 if v_0_0.Op != OpRISCV64FCLASSD {
11189 break
11190 }
11191 v_0_0_0 := v_0_0.Args[0]
11192 if v_0_0_0.Op != OpRISCV64FNEGD {
11193 break
11194 }
11195 x := v_0_0_0.Args[0]
11196 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
11197 v0.AuxInt = int64ToAuxInt((c & 0b11_0000_0000) | int64(bits.Reverse8(uint8(c))&0b1111_1111))
11198 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
11199 v1.AddArg(x)
11200 v0.AddArg(v1)
11201 b.resetWithControl(BlockRISCV64BNEZ, v0)
11202 return true
11203 }
11204
11205
11206 for b.Controls[0].Op == OpRISCV64ANDI {
11207 v_0 := b.Controls[0]
11208 c := auxIntToInt64(v_0.AuxInt)
11209 v_0_0 := v_0.Args[0]
11210 if v_0_0.Op != OpRISCV64FCLASSD {
11211 break
11212 }
11213 v_0_0_0 := v_0_0.Args[0]
11214 if v_0_0_0.Op != OpRISCV64FABSD {
11215 break
11216 }
11217 x := v_0_0_0.Args[0]
11218 v0 := b.NewValue0(v_0.Pos, OpRISCV64ANDI, typ.Int64)
11219 v0.AuxInt = int64ToAuxInt((c & 0b11_1111_0000) | int64(bits.Reverse8(uint8(c))&0b0000_1111))
11220 v1 := b.NewValue0(v_0.Pos, OpRISCV64FCLASSD, typ.Int64)
11221 v1.AddArg(x)
11222 v0.AddArg(v1)
11223 b.resetWithControl(BlockRISCV64BNEZ, v0)
11224 return true
11225 }
11226 case BlockIf:
11227
11228
11229 for {
11230 cond := b.Controls[0]
11231 v0 := b.NewValue0(cond.Pos, OpRISCV64MOVBUreg, typ.UInt64)
11232 v0.AddArg(cond)
11233 b.resetWithControl(BlockRISCV64BNEZ, v0)
11234 return true
11235 }
11236 }
11237 return false
11238 }
11239
View as plain text