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