1
2
3 package ssa
4
5 import "internal/buildcfg"
6 import "math"
7 import "cmd/compile/internal/types"
8
9 func rewriteValueRISCV64(v *Value) bool {
10 switch v.Op {
11 case OpAbs:
12 v.Op = OpRISCV64FABSD
13 return true
14 case OpAdd16:
15 v.Op = OpRISCV64ADD
16 return true
17 case OpAdd32:
18 v.Op = OpRISCV64ADD
19 return true
20 case OpAdd32F:
21 v.Op = OpRISCV64FADDS
22 return true
23 case OpAdd64:
24 v.Op = OpRISCV64ADD
25 return true
26 case OpAdd64F:
27 v.Op = OpRISCV64FADDD
28 return true
29 case OpAdd8:
30 v.Op = OpRISCV64ADD
31 return true
32 case OpAddPtr:
33 v.Op = OpRISCV64ADD
34 return true
35 case OpAddr:
36 return rewriteValueRISCV64_OpAddr(v)
37 case OpAnd16:
38 v.Op = OpRISCV64AND
39 return true
40 case OpAnd32:
41 v.Op = OpRISCV64AND
42 return true
43 case OpAnd64:
44 v.Op = OpRISCV64AND
45 return true
46 case OpAnd8:
47 v.Op = OpRISCV64AND
48 return true
49 case OpAndB:
50 v.Op = OpRISCV64AND
51 return true
52 case OpAtomicAdd32:
53 v.Op = OpRISCV64LoweredAtomicAdd32
54 return true
55 case OpAtomicAdd64:
56 v.Op = OpRISCV64LoweredAtomicAdd64
57 return true
58 case OpAtomicAnd32:
59 v.Op = OpRISCV64LoweredAtomicAnd32
60 return true
61 case OpAtomicAnd8:
62 return rewriteValueRISCV64_OpAtomicAnd8(v)
63 case OpAtomicCompareAndSwap32:
64 return rewriteValueRISCV64_OpAtomicCompareAndSwap32(v)
65 case OpAtomicCompareAndSwap64:
66 v.Op = OpRISCV64LoweredAtomicCas64
67 return true
68 case OpAtomicExchange32:
69 v.Op = OpRISCV64LoweredAtomicExchange32
70 return true
71 case OpAtomicExchange64:
72 v.Op = OpRISCV64LoweredAtomicExchange64
73 return true
74 case OpAtomicLoad32:
75 v.Op = OpRISCV64LoweredAtomicLoad32
76 return true
77 case OpAtomicLoad64:
78 v.Op = OpRISCV64LoweredAtomicLoad64
79 return true
80 case OpAtomicLoad8:
81 v.Op = OpRISCV64LoweredAtomicLoad8
82 return true
83 case OpAtomicLoadPtr:
84 v.Op = OpRISCV64LoweredAtomicLoad64
85 return true
86 case OpAtomicOr32:
87 v.Op = OpRISCV64LoweredAtomicOr32
88 return true
89 case OpAtomicOr8:
90 return rewriteValueRISCV64_OpAtomicOr8(v)
91 case OpAtomicStore32:
92 v.Op = OpRISCV64LoweredAtomicStore32
93 return true
94 case OpAtomicStore64:
95 v.Op = OpRISCV64LoweredAtomicStore64
96 return true
97 case OpAtomicStore8:
98 v.Op = OpRISCV64LoweredAtomicStore8
99 return true
100 case OpAtomicStorePtrNoWB:
101 v.Op = OpRISCV64LoweredAtomicStore64
102 return true
103 case OpAvg64u:
104 return rewriteValueRISCV64_OpAvg64u(v)
105 case OpBitLen16:
106 return rewriteValueRISCV64_OpBitLen16(v)
107 case OpBitLen32:
108 return rewriteValueRISCV64_OpBitLen32(v)
109 case OpBitLen64:
110 return rewriteValueRISCV64_OpBitLen64(v)
111 case OpBitLen8:
112 return rewriteValueRISCV64_OpBitLen8(v)
113 case OpBswap16:
114 return rewriteValueRISCV64_OpBswap16(v)
115 case OpBswap32:
116 return rewriteValueRISCV64_OpBswap32(v)
117 case OpBswap64:
118 v.Op = OpRISCV64REV8
119 return true
120 case OpClosureCall:
121 v.Op = OpRISCV64CALLclosure
122 return true
123 case OpCom16:
124 v.Op = OpRISCV64NOT
125 return true
126 case OpCom32:
127 v.Op = OpRISCV64NOT
128 return true
129 case OpCom64:
130 v.Op = OpRISCV64NOT
131 return true
132 case OpCom8:
133 v.Op = OpRISCV64NOT
134 return true
135 case OpConst16:
136 return rewriteValueRISCV64_OpConst16(v)
137 case OpConst32:
138 return rewriteValueRISCV64_OpConst32(v)
139 case OpConst32F:
140 return rewriteValueRISCV64_OpConst32F(v)
141 case OpConst64:
142 return rewriteValueRISCV64_OpConst64(v)
143 case OpConst64F:
144 return rewriteValueRISCV64_OpConst64F(v)
145 case OpConst8:
146 return rewriteValueRISCV64_OpConst8(v)
147 case OpConstBool:
148 return rewriteValueRISCV64_OpConstBool(v)
149 case OpConstNil:
150 return rewriteValueRISCV64_OpConstNil(v)
151 case OpCopysign:
152 v.Op = OpRISCV64FSGNJD
153 return true
154 case OpCtz16:
155 return rewriteValueRISCV64_OpCtz16(v)
156 case OpCtz16NonZero:
157 v.Op = OpCtz64
158 return true
159 case OpCtz32:
160 v.Op = OpRISCV64CTZW
161 return true
162 case OpCtz32NonZero:
163 v.Op = OpCtz64
164 return true
165 case OpCtz64:
166 v.Op = OpRISCV64CTZ
167 return true
168 case OpCtz64NonZero:
169 v.Op = OpCtz64
170 return true
171 case OpCtz8:
172 return rewriteValueRISCV64_OpCtz8(v)
173 case OpCtz8NonZero:
174 v.Op = OpCtz64
175 return true
176 case OpCvt32Fto32:
177 v.Op = OpRISCV64FCVTWS
178 return true
179 case OpCvt32Fto64:
180 v.Op = OpRISCV64FCVTLS
181 return true
182 case OpCvt32Fto64F:
183 v.Op = OpRISCV64FCVTDS
184 return true
185 case OpCvt32to32F:
186 v.Op = OpRISCV64FCVTSW
187 return true
188 case OpCvt32to64F:
189 v.Op = OpRISCV64FCVTDW
190 return true
191 case OpCvt64Fto32:
192 v.Op = OpRISCV64FCVTWD
193 return true
194 case OpCvt64Fto32F:
195 v.Op = OpRISCV64FCVTSD
196 return true
197 case OpCvt64Fto64:
198 v.Op = OpRISCV64FCVTLD
199 return true
200 case OpCvt64to32F:
201 v.Op = OpRISCV64FCVTSL
202 return true
203 case OpCvt64to64F:
204 v.Op = OpRISCV64FCVTDL
205 return true
206 case OpCvtBoolToUint8:
207 v.Op = OpCopy
208 return true
209 case OpDiv16:
210 return rewriteValueRISCV64_OpDiv16(v)
211 case OpDiv16u:
212 return rewriteValueRISCV64_OpDiv16u(v)
213 case OpDiv32:
214 return rewriteValueRISCV64_OpDiv32(v)
215 case OpDiv32F:
216 v.Op = OpRISCV64FDIVS
217 return true
218 case OpDiv32u:
219 v.Op = OpRISCV64DIVUW
220 return true
221 case OpDiv64:
222 return rewriteValueRISCV64_OpDiv64(v)
223 case OpDiv64F:
224 v.Op = OpRISCV64FDIVD
225 return true
226 case OpDiv64u:
227 v.Op = OpRISCV64DIVU
228 return true
229 case OpDiv8:
230 return rewriteValueRISCV64_OpDiv8(v)
231 case OpDiv8u:
232 return rewriteValueRISCV64_OpDiv8u(v)
233 case OpEq16:
234 return rewriteValueRISCV64_OpEq16(v)
235 case OpEq32:
236 return rewriteValueRISCV64_OpEq32(v)
237 case OpEq32F:
238 v.Op = OpRISCV64FEQS
239 return true
240 case OpEq64:
241 return rewriteValueRISCV64_OpEq64(v)
242 case OpEq64F:
243 v.Op = OpRISCV64FEQD
244 return true
245 case OpEq8:
246 return rewriteValueRISCV64_OpEq8(v)
247 case OpEqB:
248 return rewriteValueRISCV64_OpEqB(v)
249 case OpEqPtr:
250 return rewriteValueRISCV64_OpEqPtr(v)
251 case OpFMA:
252 v.Op = OpRISCV64FMADDD
253 return true
254 case OpGetCallerPC:
255 v.Op = OpRISCV64LoweredGetCallerPC
256 return true
257 case OpGetCallerSP:
258 v.Op = OpRISCV64LoweredGetCallerSP
259 return true
260 case OpGetClosurePtr:
261 v.Op = OpRISCV64LoweredGetClosurePtr
262 return true
263 case OpHmul32:
264 return rewriteValueRISCV64_OpHmul32(v)
265 case OpHmul32u:
266 return rewriteValueRISCV64_OpHmul32u(v)
267 case OpHmul64:
268 v.Op = OpRISCV64MULH
269 return true
270 case OpHmul64u:
271 v.Op = OpRISCV64MULHU
272 return true
273 case OpInterCall:
274 v.Op = OpRISCV64CALLinter
275 return true
276 case OpIsInBounds:
277 v.Op = OpLess64U
278 return true
279 case OpIsNonNil:
280 v.Op = OpRISCV64SNEZ
281 return true
282 case OpIsSliceInBounds:
283 v.Op = OpLeq64U
284 return true
285 case OpLeq16:
286 return rewriteValueRISCV64_OpLeq16(v)
287 case OpLeq16U:
288 return rewriteValueRISCV64_OpLeq16U(v)
289 case OpLeq32:
290 return rewriteValueRISCV64_OpLeq32(v)
291 case OpLeq32F:
292 v.Op = OpRISCV64FLES
293 return true
294 case OpLeq32U:
295 return rewriteValueRISCV64_OpLeq32U(v)
296 case OpLeq64:
297 return rewriteValueRISCV64_OpLeq64(v)
298 case OpLeq64F:
299 v.Op = OpRISCV64FLED
300 return true
301 case OpLeq64U:
302 return rewriteValueRISCV64_OpLeq64U(v)
303 case OpLeq8:
304 return rewriteValueRISCV64_OpLeq8(v)
305 case OpLeq8U:
306 return rewriteValueRISCV64_OpLeq8U(v)
307 case OpLess16:
308 return rewriteValueRISCV64_OpLess16(v)
309 case OpLess16U:
310 return rewriteValueRISCV64_OpLess16U(v)
311 case OpLess32:
312 return rewriteValueRISCV64_OpLess32(v)
313 case OpLess32F:
314 v.Op = OpRISCV64FLTS
315 return true
316 case OpLess32U:
317 return rewriteValueRISCV64_OpLess32U(v)
318 case OpLess64:
319 v.Op = OpRISCV64SLT
320 return true
321 case OpLess64F:
322 v.Op = OpRISCV64FLTD
323 return true
324 case OpLess64U:
325 v.Op = OpRISCV64SLTU
326 return true
327 case OpLess8:
328 return rewriteValueRISCV64_OpLess8(v)
329 case OpLess8U:
330 return rewriteValueRISCV64_OpLess8U(v)
331 case OpLoad:
332 return rewriteValueRISCV64_OpLoad(v)
333 case OpLocalAddr:
334 return rewriteValueRISCV64_OpLocalAddr(v)
335 case OpLsh16x16:
336 return rewriteValueRISCV64_OpLsh16x16(v)
337 case OpLsh16x32:
338 return rewriteValueRISCV64_OpLsh16x32(v)
339 case OpLsh16x64:
340 return rewriteValueRISCV64_OpLsh16x64(v)
341 case OpLsh16x8:
342 return rewriteValueRISCV64_OpLsh16x8(v)
343 case OpLsh32x16:
344 return rewriteValueRISCV64_OpLsh32x16(v)
345 case OpLsh32x32:
346 return rewriteValueRISCV64_OpLsh32x32(v)
347 case OpLsh32x64:
348 return rewriteValueRISCV64_OpLsh32x64(v)
349 case OpLsh32x8:
350 return rewriteValueRISCV64_OpLsh32x8(v)
351 case OpLsh64x16:
352 return rewriteValueRISCV64_OpLsh64x16(v)
353 case OpLsh64x32:
354 return rewriteValueRISCV64_OpLsh64x32(v)
355 case OpLsh64x64:
356 return rewriteValueRISCV64_OpLsh64x64(v)
357 case OpLsh64x8:
358 return rewriteValueRISCV64_OpLsh64x8(v)
359 case OpLsh8x16:
360 return rewriteValueRISCV64_OpLsh8x16(v)
361 case OpLsh8x32:
362 return rewriteValueRISCV64_OpLsh8x32(v)
363 case OpLsh8x64:
364 return rewriteValueRISCV64_OpLsh8x64(v)
365 case OpLsh8x8:
366 return rewriteValueRISCV64_OpLsh8x8(v)
367 case OpMax32F:
368 v.Op = OpRISCV64LoweredFMAXS
369 return true
370 case OpMax64:
371 return rewriteValueRISCV64_OpMax64(v)
372 case OpMax64F:
373 v.Op = OpRISCV64LoweredFMAXD
374 return true
375 case OpMax64u:
376 return rewriteValueRISCV64_OpMax64u(v)
377 case OpMin32F:
378 v.Op = OpRISCV64LoweredFMINS
379 return true
380 case OpMin64:
381 return rewriteValueRISCV64_OpMin64(v)
382 case OpMin64F:
383 v.Op = OpRISCV64LoweredFMIND
384 return true
385 case OpMin64u:
386 return rewriteValueRISCV64_OpMin64u(v)
387 case OpMod16:
388 return rewriteValueRISCV64_OpMod16(v)
389 case OpMod16u:
390 return rewriteValueRISCV64_OpMod16u(v)
391 case OpMod32:
392 return rewriteValueRISCV64_OpMod32(v)
393 case OpMod32u:
394 v.Op = OpRISCV64REMUW
395 return true
396 case OpMod64:
397 return rewriteValueRISCV64_OpMod64(v)
398 case OpMod64u:
399 v.Op = OpRISCV64REMU
400 return true
401 case OpMod8:
402 return rewriteValueRISCV64_OpMod8(v)
403 case OpMod8u:
404 return rewriteValueRISCV64_OpMod8u(v)
405 case OpMove:
406 return rewriteValueRISCV64_OpMove(v)
407 case OpMul16:
408 return rewriteValueRISCV64_OpMul16(v)
409 case OpMul32:
410 v.Op = OpRISCV64MULW
411 return true
412 case OpMul32F:
413 v.Op = OpRISCV64FMULS
414 return true
415 case OpMul64:
416 v.Op = OpRISCV64MUL
417 return true
418 case OpMul64F:
419 v.Op = OpRISCV64FMULD
420 return true
421 case OpMul64uhilo:
422 v.Op = OpRISCV64LoweredMuluhilo
423 return true
424 case OpMul64uover:
425 v.Op = OpRISCV64LoweredMuluover
426 return true
427 case OpMul8:
428 return rewriteValueRISCV64_OpMul8(v)
429 case OpNeg16:
430 v.Op = OpRISCV64NEG
431 return true
432 case OpNeg32:
433 v.Op = OpRISCV64NEG
434 return true
435 case OpNeg32F:
436 v.Op = OpRISCV64FNEGS
437 return true
438 case OpNeg64:
439 v.Op = OpRISCV64NEG
440 return true
441 case OpNeg64F:
442 v.Op = OpRISCV64FNEGD
443 return true
444 case OpNeg8:
445 v.Op = OpRISCV64NEG
446 return true
447 case OpNeq16:
448 return rewriteValueRISCV64_OpNeq16(v)
449 case OpNeq32:
450 return rewriteValueRISCV64_OpNeq32(v)
451 case OpNeq32F:
452 v.Op = OpRISCV64FNES
453 return true
454 case OpNeq64:
455 return rewriteValueRISCV64_OpNeq64(v)
456 case OpNeq64F:
457 v.Op = OpRISCV64FNED
458 return true
459 case OpNeq8:
460 return rewriteValueRISCV64_OpNeq8(v)
461 case OpNeqB:
462 return rewriteValueRISCV64_OpNeqB(v)
463 case OpNeqPtr:
464 return rewriteValueRISCV64_OpNeqPtr(v)
465 case OpNilCheck:
466 v.Op = OpRISCV64LoweredNilCheck
467 return true
468 case OpNot:
469 v.Op = OpRISCV64SEQZ
470 return true
471 case OpOffPtr:
472 return rewriteValueRISCV64_OpOffPtr(v)
473 case OpOr16:
474 v.Op = OpRISCV64OR
475 return true
476 case OpOr32:
477 v.Op = OpRISCV64OR
478 return true
479 case OpOr64:
480 v.Op = OpRISCV64OR
481 return true
482 case OpOr8:
483 v.Op = OpRISCV64OR
484 return true
485 case OpOrB:
486 v.Op = OpRISCV64OR
487 return true
488 case OpPanicBounds:
489 return rewriteValueRISCV64_OpPanicBounds(v)
490 case OpPopCount16:
491 return rewriteValueRISCV64_OpPopCount16(v)
492 case OpPopCount32:
493 v.Op = OpRISCV64CPOPW
494 return true
495 case OpPopCount64:
496 v.Op = OpRISCV64CPOP
497 return true
498 case OpPopCount8:
499 return rewriteValueRISCV64_OpPopCount8(v)
500 case OpPubBarrier:
501 v.Op = OpRISCV64LoweredPubBarrier
502 return true
503 case OpRISCV64ADD:
504 return rewriteValueRISCV64_OpRISCV64ADD(v)
505 case OpRISCV64ADDI:
506 return rewriteValueRISCV64_OpRISCV64ADDI(v)
507 case OpRISCV64AND:
508 return rewriteValueRISCV64_OpRISCV64AND(v)
509 case OpRISCV64ANDI:
510 return rewriteValueRISCV64_OpRISCV64ANDI(v)
511 case OpRISCV64FADDD:
512 return rewriteValueRISCV64_OpRISCV64FADDD(v)
513 case OpRISCV64FADDS:
514 return rewriteValueRISCV64_OpRISCV64FADDS(v)
515 case OpRISCV64FMADDD:
516 return rewriteValueRISCV64_OpRISCV64FMADDD(v)
517 case OpRISCV64FMADDS:
518 return rewriteValueRISCV64_OpRISCV64FMADDS(v)
519 case OpRISCV64FMSUBD:
520 return rewriteValueRISCV64_OpRISCV64FMSUBD(v)
521 case OpRISCV64FMSUBS:
522 return rewriteValueRISCV64_OpRISCV64FMSUBS(v)
523 case OpRISCV64FNMADDD:
524 return rewriteValueRISCV64_OpRISCV64FNMADDD(v)
525 case OpRISCV64FNMADDS:
526 return rewriteValueRISCV64_OpRISCV64FNMADDS(v)
527 case OpRISCV64FNMSUBD:
528 return rewriteValueRISCV64_OpRISCV64FNMSUBD(v)
529 case OpRISCV64FNMSUBS:
530 return rewriteValueRISCV64_OpRISCV64FNMSUBS(v)
531 case OpRISCV64FSUBD:
532 return rewriteValueRISCV64_OpRISCV64FSUBD(v)
533 case OpRISCV64FSUBS:
534 return rewriteValueRISCV64_OpRISCV64FSUBS(v)
535 case OpRISCV64MOVBUload:
536 return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
537 case OpRISCV64MOVBUreg:
538 return rewriteValueRISCV64_OpRISCV64MOVBUreg(v)
539 case OpRISCV64MOVBload:
540 return rewriteValueRISCV64_OpRISCV64MOVBload(v)
541 case OpRISCV64MOVBreg:
542 return rewriteValueRISCV64_OpRISCV64MOVBreg(v)
543 case OpRISCV64MOVBstore:
544 return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
545 case OpRISCV64MOVBstorezero:
546 return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
547 case OpRISCV64MOVDload:
548 return rewriteValueRISCV64_OpRISCV64MOVDload(v)
549 case OpRISCV64MOVDnop:
550 return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
551 case OpRISCV64MOVDreg:
552 return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
553 case OpRISCV64MOVDstore:
554 return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
555 case OpRISCV64MOVDstorezero:
556 return rewriteValueRISCV64_OpRISCV64MOVDstorezero(v)
557 case OpRISCV64MOVHUload:
558 return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
559 case OpRISCV64MOVHUreg:
560 return rewriteValueRISCV64_OpRISCV64MOVHUreg(v)
561 case OpRISCV64MOVHload:
562 return rewriteValueRISCV64_OpRISCV64MOVHload(v)
563 case OpRISCV64MOVHreg:
564 return rewriteValueRISCV64_OpRISCV64MOVHreg(v)
565 case OpRISCV64MOVHstore:
566 return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
567 case OpRISCV64MOVHstorezero:
568 return rewriteValueRISCV64_OpRISCV64MOVHstorezero(v)
569 case OpRISCV64MOVWUload:
570 return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
571 case OpRISCV64MOVWUreg:
572 return rewriteValueRISCV64_OpRISCV64MOVWUreg(v)
573 case OpRISCV64MOVWload:
574 return rewriteValueRISCV64_OpRISCV64MOVWload(v)
575 case OpRISCV64MOVWreg:
576 return rewriteValueRISCV64_OpRISCV64MOVWreg(v)
577 case OpRISCV64MOVWstore:
578 return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
579 case OpRISCV64MOVWstorezero:
580 return rewriteValueRISCV64_OpRISCV64MOVWstorezero(v)
581 case OpRISCV64NEG:
582 return rewriteValueRISCV64_OpRISCV64NEG(v)
583 case OpRISCV64NEGW:
584 return rewriteValueRISCV64_OpRISCV64NEGW(v)
585 case OpRISCV64OR:
586 return rewriteValueRISCV64_OpRISCV64OR(v)
587 case OpRISCV64ORI:
588 return rewriteValueRISCV64_OpRISCV64ORI(v)
589 case OpRISCV64ORN:
590 return rewriteValueRISCV64_OpRISCV64ORN(v)
591 case OpRISCV64ROL:
592 return rewriteValueRISCV64_OpRISCV64ROL(v)
593 case OpRISCV64ROLW:
594 return rewriteValueRISCV64_OpRISCV64ROLW(v)
595 case OpRISCV64ROR:
596 return rewriteValueRISCV64_OpRISCV64ROR(v)
597 case OpRISCV64RORW:
598 return rewriteValueRISCV64_OpRISCV64RORW(v)
599 case OpRISCV64SEQZ:
600 return rewriteValueRISCV64_OpRISCV64SEQZ(v)
601 case OpRISCV64SLL:
602 return rewriteValueRISCV64_OpRISCV64SLL(v)
603 case OpRISCV64SLLI:
604 return rewriteValueRISCV64_OpRISCV64SLLI(v)
605 case OpRISCV64SLLW:
606 return rewriteValueRISCV64_OpRISCV64SLLW(v)
607 case OpRISCV64SLT:
608 return rewriteValueRISCV64_OpRISCV64SLT(v)
609 case OpRISCV64SLTI:
610 return rewriteValueRISCV64_OpRISCV64SLTI(v)
611 case OpRISCV64SLTIU:
612 return rewriteValueRISCV64_OpRISCV64SLTIU(v)
613 case OpRISCV64SLTU:
614 return rewriteValueRISCV64_OpRISCV64SLTU(v)
615 case OpRISCV64SNEZ:
616 return rewriteValueRISCV64_OpRISCV64SNEZ(v)
617 case OpRISCV64SRA:
618 return rewriteValueRISCV64_OpRISCV64SRA(v)
619 case OpRISCV64SRAI:
620 return rewriteValueRISCV64_OpRISCV64SRAI(v)
621 case OpRISCV64SRAW:
622 return rewriteValueRISCV64_OpRISCV64SRAW(v)
623 case OpRISCV64SRL:
624 return rewriteValueRISCV64_OpRISCV64SRL(v)
625 case OpRISCV64SRLI:
626 return rewriteValueRISCV64_OpRISCV64SRLI(v)
627 case OpRISCV64SRLW:
628 return rewriteValueRISCV64_OpRISCV64SRLW(v)
629 case OpRISCV64SUB:
630 return rewriteValueRISCV64_OpRISCV64SUB(v)
631 case OpRISCV64SUBW:
632 return rewriteValueRISCV64_OpRISCV64SUBW(v)
633 case OpRISCV64XOR:
634 return rewriteValueRISCV64_OpRISCV64XOR(v)
635 case OpRotateLeft16:
636 return rewriteValueRISCV64_OpRotateLeft16(v)
637 case OpRotateLeft32:
638 v.Op = OpRISCV64ROLW
639 return true
640 case OpRotateLeft64:
641 v.Op = OpRISCV64ROL
642 return true
643 case OpRotateLeft8:
644 return rewriteValueRISCV64_OpRotateLeft8(v)
645 case OpRound32F:
646 v.Op = OpRISCV64LoweredRound32F
647 return true
648 case OpRound64F:
649 v.Op = OpRISCV64LoweredRound64F
650 return true
651 case OpRsh16Ux16:
652 return rewriteValueRISCV64_OpRsh16Ux16(v)
653 case OpRsh16Ux32:
654 return rewriteValueRISCV64_OpRsh16Ux32(v)
655 case OpRsh16Ux64:
656 return rewriteValueRISCV64_OpRsh16Ux64(v)
657 case OpRsh16Ux8:
658 return rewriteValueRISCV64_OpRsh16Ux8(v)
659 case OpRsh16x16:
660 return rewriteValueRISCV64_OpRsh16x16(v)
661 case OpRsh16x32:
662 return rewriteValueRISCV64_OpRsh16x32(v)
663 case OpRsh16x64:
664 return rewriteValueRISCV64_OpRsh16x64(v)
665 case OpRsh16x8:
666 return rewriteValueRISCV64_OpRsh16x8(v)
667 case OpRsh32Ux16:
668 return rewriteValueRISCV64_OpRsh32Ux16(v)
669 case OpRsh32Ux32:
670 return rewriteValueRISCV64_OpRsh32Ux32(v)
671 case OpRsh32Ux64:
672 return rewriteValueRISCV64_OpRsh32Ux64(v)
673 case OpRsh32Ux8:
674 return rewriteValueRISCV64_OpRsh32Ux8(v)
675 case OpRsh32x16:
676 return rewriteValueRISCV64_OpRsh32x16(v)
677 case OpRsh32x32:
678 return rewriteValueRISCV64_OpRsh32x32(v)
679 case OpRsh32x64:
680 return rewriteValueRISCV64_OpRsh32x64(v)
681 case OpRsh32x8:
682 return rewriteValueRISCV64_OpRsh32x8(v)
683 case OpRsh64Ux16:
684 return rewriteValueRISCV64_OpRsh64Ux16(v)
685 case OpRsh64Ux32:
686 return rewriteValueRISCV64_OpRsh64Ux32(v)
687 case OpRsh64Ux64:
688 return rewriteValueRISCV64_OpRsh64Ux64(v)
689 case OpRsh64Ux8:
690 return rewriteValueRISCV64_OpRsh64Ux8(v)
691 case OpRsh64x16:
692 return rewriteValueRISCV64_OpRsh64x16(v)
693 case OpRsh64x32:
694 return rewriteValueRISCV64_OpRsh64x32(v)
695 case OpRsh64x64:
696 return rewriteValueRISCV64_OpRsh64x64(v)
697 case OpRsh64x8:
698 return rewriteValueRISCV64_OpRsh64x8(v)
699 case OpRsh8Ux16:
700 return rewriteValueRISCV64_OpRsh8Ux16(v)
701 case OpRsh8Ux32:
702 return rewriteValueRISCV64_OpRsh8Ux32(v)
703 case OpRsh8Ux64:
704 return rewriteValueRISCV64_OpRsh8Ux64(v)
705 case OpRsh8Ux8:
706 return rewriteValueRISCV64_OpRsh8Ux8(v)
707 case OpRsh8x16:
708 return rewriteValueRISCV64_OpRsh8x16(v)
709 case OpRsh8x32:
710 return rewriteValueRISCV64_OpRsh8x32(v)
711 case OpRsh8x64:
712 return rewriteValueRISCV64_OpRsh8x64(v)
713 case OpRsh8x8:
714 return rewriteValueRISCV64_OpRsh8x8(v)
715 case OpSelect0:
716 return rewriteValueRISCV64_OpSelect0(v)
717 case OpSelect1:
718 return rewriteValueRISCV64_OpSelect1(v)
719 case OpSignExt16to32:
720 v.Op = OpRISCV64MOVHreg
721 return true
722 case OpSignExt16to64:
723 v.Op = OpRISCV64MOVHreg
724 return true
725 case OpSignExt32to64:
726 v.Op = OpRISCV64MOVWreg
727 return true
728 case OpSignExt8to16:
729 v.Op = OpRISCV64MOVBreg
730 return true
731 case OpSignExt8to32:
732 v.Op = OpRISCV64MOVBreg
733 return true
734 case OpSignExt8to64:
735 v.Op = OpRISCV64MOVBreg
736 return true
737 case OpSlicemask:
738 return rewriteValueRISCV64_OpSlicemask(v)
739 case OpSqrt:
740 v.Op = OpRISCV64FSQRTD
741 return true
742 case OpSqrt32:
743 v.Op = OpRISCV64FSQRTS
744 return true
745 case OpStaticCall:
746 v.Op = OpRISCV64CALLstatic
747 return true
748 case OpStore:
749 return rewriteValueRISCV64_OpStore(v)
750 case OpSub16:
751 v.Op = OpRISCV64SUB
752 return true
753 case OpSub32:
754 v.Op = OpRISCV64SUB
755 return true
756 case OpSub32F:
757 v.Op = OpRISCV64FSUBS
758 return true
759 case OpSub64:
760 v.Op = OpRISCV64SUB
761 return true
762 case OpSub64F:
763 v.Op = OpRISCV64FSUBD
764 return true
765 case OpSub8:
766 v.Op = OpRISCV64SUB
767 return true
768 case OpSubPtr:
769 v.Op = OpRISCV64SUB
770 return true
771 case OpTailCall:
772 v.Op = OpRISCV64CALLtail
773 return true
774 case OpTrunc16to8:
775 v.Op = OpCopy
776 return true
777 case OpTrunc32to16:
778 v.Op = OpCopy
779 return true
780 case OpTrunc32to8:
781 v.Op = OpCopy
782 return true
783 case OpTrunc64to16:
784 v.Op = OpCopy
785 return true
786 case OpTrunc64to32:
787 v.Op = OpCopy
788 return true
789 case OpTrunc64to8:
790 v.Op = OpCopy
791 return true
792 case OpWB:
793 v.Op = OpRISCV64LoweredWB
794 return true
795 case OpXor16:
796 v.Op = OpRISCV64XOR
797 return true
798 case OpXor32:
799 v.Op = OpRISCV64XOR
800 return true
801 case OpXor64:
802 v.Op = OpRISCV64XOR
803 return true
804 case OpXor8:
805 v.Op = OpRISCV64XOR
806 return true
807 case OpZero:
808 return rewriteValueRISCV64_OpZero(v)
809 case OpZeroExt16to32:
810 v.Op = OpRISCV64MOVHUreg
811 return true
812 case OpZeroExt16to64:
813 v.Op = OpRISCV64MOVHUreg
814 return true
815 case OpZeroExt32to64:
816 v.Op = OpRISCV64MOVWUreg
817 return true
818 case OpZeroExt8to16:
819 v.Op = OpRISCV64MOVBUreg
820 return true
821 case OpZeroExt8to32:
822 v.Op = OpRISCV64MOVBUreg
823 return true
824 case OpZeroExt8to64:
825 v.Op = OpRISCV64MOVBUreg
826 return true
827 }
828 return false
829 }
830 func rewriteValueRISCV64_OpAddr(v *Value) bool {
831 v_0 := v.Args[0]
832
833
834 for {
835 sym := auxToSym(v.Aux)
836 base := v_0
837 v.reset(OpRISCV64MOVaddr)
838 v.AuxInt = int32ToAuxInt(0)
839 v.Aux = symToAux(sym)
840 v.AddArg(base)
841 return true
842 }
843 }
844 func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool {
845 v_2 := v.Args[2]
846 v_1 := v.Args[1]
847 v_0 := v.Args[0]
848 b := v.Block
849 typ := &b.Func.Config.Types
850
851
852 for {
853 ptr := v_0
854 val := v_1
855 mem := v_2
856 v.reset(OpRISCV64LoweredAtomicAnd32)
857 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
858 v0.AuxInt = int64ToAuxInt(^3)
859 v0.AddArg(ptr)
860 v1 := b.NewValue0(v.Pos, OpRISCV64NOT, typ.UInt32)
861 v2 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
862 v3 := b.NewValue0(v.Pos, OpRISCV64XORI, typ.UInt32)
863 v3.AuxInt = int64ToAuxInt(0xff)
864 v4 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
865 v4.AddArg(val)
866 v3.AddArg(v4)
867 v5 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
868 v5.AuxInt = int64ToAuxInt(3)
869 v6 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
870 v6.AuxInt = int64ToAuxInt(3)
871 v6.AddArg(ptr)
872 v5.AddArg(v6)
873 v2.AddArg2(v3, v5)
874 v1.AddArg(v2)
875 v.AddArg3(v0, v1, mem)
876 return true
877 }
878 }
879 func rewriteValueRISCV64_OpAtomicCompareAndSwap32(v *Value) bool {
880 v_3 := v.Args[3]
881 v_2 := v.Args[2]
882 v_1 := v.Args[1]
883 v_0 := v.Args[0]
884 b := v.Block
885 typ := &b.Func.Config.Types
886
887
888 for {
889 ptr := v_0
890 old := v_1
891 new := v_2
892 mem := v_3
893 v.reset(OpRISCV64LoweredAtomicCas32)
894 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
895 v0.AddArg(old)
896 v.AddArg4(ptr, v0, new, mem)
897 return true
898 }
899 }
900 func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool {
901 v_2 := v.Args[2]
902 v_1 := v.Args[1]
903 v_0 := v.Args[0]
904 b := v.Block
905 typ := &b.Func.Config.Types
906
907
908 for {
909 ptr := v_0
910 val := v_1
911 mem := v_2
912 v.reset(OpRISCV64LoweredAtomicOr32)
913 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
914 v0.AuxInt = int64ToAuxInt(^3)
915 v0.AddArg(ptr)
916 v1 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
917 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
918 v2.AddArg(val)
919 v3 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
920 v3.AuxInt = int64ToAuxInt(3)
921 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
922 v4.AuxInt = int64ToAuxInt(3)
923 v4.AddArg(ptr)
924 v3.AddArg(v4)
925 v1.AddArg2(v2, v3)
926 v.AddArg3(v0, v1, mem)
927 return true
928 }
929 }
930 func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
931 v_1 := v.Args[1]
932 v_0 := v.Args[0]
933 b := v.Block
934
935
936 for {
937 t := v.Type
938 x := v_0
939 y := v_1
940 v.reset(OpRISCV64ADD)
941 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, t)
942 v1 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
943 v1.AuxInt = int64ToAuxInt(1)
944 v1.AddArg(x)
945 v2 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
946 v2.AuxInt = int64ToAuxInt(1)
947 v2.AddArg(y)
948 v0.AddArg2(v1, v2)
949 v3 := b.NewValue0(v.Pos, OpRISCV64ANDI, t)
950 v3.AuxInt = int64ToAuxInt(1)
951 v4 := b.NewValue0(v.Pos, OpRISCV64AND, t)
952 v4.AddArg2(x, y)
953 v3.AddArg(v4)
954 v.AddArg2(v0, v3)
955 return true
956 }
957 }
958 func rewriteValueRISCV64_OpBitLen16(v *Value) bool {
959 v_0 := v.Args[0]
960 b := v.Block
961 typ := &b.Func.Config.Types
962
963
964 for {
965 x := v_0
966 v.reset(OpBitLen64)
967 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
968 v0.AddArg(x)
969 v.AddArg(v0)
970 return true
971 }
972 }
973 func rewriteValueRISCV64_OpBitLen32(v *Value) bool {
974 v_0 := v.Args[0]
975 b := v.Block
976 typ := &b.Func.Config.Types
977
978
979 for {
980 t := v.Type
981 x := v_0
982 v.reset(OpRISCV64SUB)
983 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
984 v0.AuxInt = int64ToAuxInt(32)
985 v1 := b.NewValue0(v.Pos, OpRISCV64CLZW, t)
986 v1.AddArg(x)
987 v.AddArg2(v0, v1)
988 return true
989 }
990 }
991 func rewriteValueRISCV64_OpBitLen64(v *Value) bool {
992 v_0 := v.Args[0]
993 b := v.Block
994 typ := &b.Func.Config.Types
995
996
997 for {
998 t := v.Type
999 x := v_0
1000 v.reset(OpRISCV64SUB)
1001 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
1002 v0.AuxInt = int64ToAuxInt(64)
1003 v1 := b.NewValue0(v.Pos, OpRISCV64CLZ, t)
1004 v1.AddArg(x)
1005 v.AddArg2(v0, v1)
1006 return true
1007 }
1008 }
1009 func rewriteValueRISCV64_OpBitLen8(v *Value) bool {
1010 v_0 := v.Args[0]
1011 b := v.Block
1012 typ := &b.Func.Config.Types
1013
1014
1015 for {
1016 x := v_0
1017 v.reset(OpBitLen64)
1018 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1019 v0.AddArg(x)
1020 v.AddArg(v0)
1021 return true
1022 }
1023 }
1024 func rewriteValueRISCV64_OpBswap16(v *Value) bool {
1025 v_0 := v.Args[0]
1026 b := v.Block
1027
1028
1029 for {
1030 t := v.Type
1031 x := v_0
1032 v.reset(OpRISCV64SRLI)
1033 v.AuxInt = int64ToAuxInt(48)
1034 v0 := b.NewValue0(v.Pos, OpRISCV64REV8, t)
1035 v0.AddArg(x)
1036 v.AddArg(v0)
1037 return true
1038 }
1039 }
1040 func rewriteValueRISCV64_OpBswap32(v *Value) bool {
1041 v_0 := v.Args[0]
1042 b := v.Block
1043
1044
1045 for {
1046 t := v.Type
1047 x := v_0
1048 v.reset(OpRISCV64SRLI)
1049 v.AuxInt = int64ToAuxInt(32)
1050 v0 := b.NewValue0(v.Pos, OpRISCV64REV8, t)
1051 v0.AddArg(x)
1052 v.AddArg(v0)
1053 return true
1054 }
1055 }
1056 func rewriteValueRISCV64_OpConst16(v *Value) bool {
1057
1058
1059 for {
1060 val := auxIntToInt16(v.AuxInt)
1061 v.reset(OpRISCV64MOVDconst)
1062 v.AuxInt = int64ToAuxInt(int64(val))
1063 return true
1064 }
1065 }
1066 func rewriteValueRISCV64_OpConst32(v *Value) bool {
1067
1068
1069 for {
1070 val := auxIntToInt32(v.AuxInt)
1071 v.reset(OpRISCV64MOVDconst)
1072 v.AuxInt = int64ToAuxInt(int64(val))
1073 return true
1074 }
1075 }
1076 func rewriteValueRISCV64_OpConst32F(v *Value) bool {
1077 b := v.Block
1078 typ := &b.Func.Config.Types
1079
1080
1081 for {
1082 val := auxIntToFloat32(v.AuxInt)
1083 v.reset(OpRISCV64FMVSX)
1084 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
1085 v0.AuxInt = int64ToAuxInt(int64(math.Float32bits(val)))
1086 v.AddArg(v0)
1087 return true
1088 }
1089 }
1090 func rewriteValueRISCV64_OpConst64(v *Value) bool {
1091
1092
1093 for {
1094 val := auxIntToInt64(v.AuxInt)
1095 v.reset(OpRISCV64MOVDconst)
1096 v.AuxInt = int64ToAuxInt(int64(val))
1097 return true
1098 }
1099 }
1100 func rewriteValueRISCV64_OpConst64F(v *Value) bool {
1101 b := v.Block
1102 typ := &b.Func.Config.Types
1103
1104
1105 for {
1106 val := auxIntToFloat64(v.AuxInt)
1107 v.reset(OpRISCV64FMVDX)
1108 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
1109 v0.AuxInt = int64ToAuxInt(int64(math.Float64bits(val)))
1110 v.AddArg(v0)
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 if auxIntToInt64(v.AuxInt) != 12 {
3073 break
3074 }
3075 t := auxToType(v.Aux)
3076 dst := v_0
3077 src := v_1
3078 mem := v_2
3079 if !(t.Alignment()%4 == 0) {
3080 break
3081 }
3082 v.reset(OpRISCV64MOVWstore)
3083 v.AuxInt = int32ToAuxInt(8)
3084 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
3085 v0.AuxInt = int32ToAuxInt(8)
3086 v0.AddArg2(src, mem)
3087 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
3088 v1.AuxInt = int32ToAuxInt(4)
3089 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
3090 v2.AuxInt = int32ToAuxInt(4)
3091 v2.AddArg2(src, mem)
3092 v3 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
3093 v4 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
3094 v4.AddArg2(src, mem)
3095 v3.AddArg3(dst, v4, mem)
3096 v1.AddArg3(dst, v2, v3)
3097 v.AddArg3(dst, v0, v1)
3098 return true
3099 }
3100
3101
3102
3103 for {
3104 if auxIntToInt64(v.AuxInt) != 16 {
3105 break
3106 }
3107 t := auxToType(v.Aux)
3108 dst := v_0
3109 src := v_1
3110 mem := v_2
3111 if !(t.Alignment()%8 == 0) {
3112 break
3113 }
3114 v.reset(OpRISCV64MOVDstore)
3115 v.AuxInt = int32ToAuxInt(8)
3116 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3117 v0.AuxInt = int32ToAuxInt(8)
3118 v0.AddArg2(src, mem)
3119 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
3120 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3121 v2.AddArg2(src, mem)
3122 v1.AddArg3(dst, v2, mem)
3123 v.AddArg3(dst, v0, v1)
3124 return true
3125 }
3126
3127
3128
3129 for {
3130 if auxIntToInt64(v.AuxInt) != 24 {
3131 break
3132 }
3133 t := auxToType(v.Aux)
3134 dst := v_0
3135 src := v_1
3136 mem := v_2
3137 if !(t.Alignment()%8 == 0) {
3138 break
3139 }
3140 v.reset(OpRISCV64MOVDstore)
3141 v.AuxInt = int32ToAuxInt(16)
3142 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3143 v0.AuxInt = int32ToAuxInt(16)
3144 v0.AddArg2(src, mem)
3145 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
3146 v1.AuxInt = int32ToAuxInt(8)
3147 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3148 v2.AuxInt = int32ToAuxInt(8)
3149 v2.AddArg2(src, mem)
3150 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
3151 v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3152 v4.AddArg2(src, mem)
3153 v3.AddArg3(dst, v4, mem)
3154 v1.AddArg3(dst, v2, v3)
3155 v.AddArg3(dst, v0, v1)
3156 return true
3157 }
3158
3159
3160
3161 for {
3162 if auxIntToInt64(v.AuxInt) != 32 {
3163 break
3164 }
3165 t := auxToType(v.Aux)
3166 dst := v_0
3167 src := v_1
3168 mem := v_2
3169 if !(t.Alignment()%8 == 0) {
3170 break
3171 }
3172 v.reset(OpRISCV64MOVDstore)
3173 v.AuxInt = int32ToAuxInt(24)
3174 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3175 v0.AuxInt = int32ToAuxInt(24)
3176 v0.AddArg2(src, mem)
3177 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
3178 v1.AuxInt = int32ToAuxInt(16)
3179 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3180 v2.AuxInt = int32ToAuxInt(16)
3181 v2.AddArg2(src, mem)
3182 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
3183 v3.AuxInt = int32ToAuxInt(8)
3184 v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3185 v4.AuxInt = int32ToAuxInt(8)
3186 v4.AddArg2(src, mem)
3187 v5 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
3188 v6 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
3189 v6.AddArg2(src, mem)
3190 v5.AddArg3(dst, v6, mem)
3191 v3.AddArg3(dst, v4, v5)
3192 v1.AddArg3(dst, v2, v3)
3193 v.AddArg3(dst, v0, v1)
3194 return true
3195 }
3196
3197
3198
3199 for {
3200 s := auxIntToInt64(v.AuxInt)
3201 t := auxToType(v.Aux)
3202 dst := v_0
3203 src := v_1
3204 mem := v_2
3205 if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && logLargeCopy(v, s)) {
3206 break
3207 }
3208 v.reset(OpRISCV64DUFFCOPY)
3209 v.AuxInt = int64ToAuxInt(16 * (128 - s/8))
3210 v.AddArg3(dst, src, mem)
3211 return true
3212 }
3213
3214
3215
3216 for {
3217 s := auxIntToInt64(v.AuxInt)
3218 t := auxToType(v.Aux)
3219 dst := v_0
3220 src := v_1
3221 mem := v_2
3222 if !(s <= 16 || logLargeCopy(v, s)) {
3223 break
3224 }
3225 v.reset(OpRISCV64LoweredMove)
3226 v.AuxInt = int64ToAuxInt(t.Alignment())
3227 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, src.Type)
3228 v0.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
3229 v0.AddArg(src)
3230 v.AddArg4(dst, src, v0, mem)
3231 return true
3232 }
3233 return false
3234 }
3235 func rewriteValueRISCV64_OpMul16(v *Value) bool {
3236 v_1 := v.Args[1]
3237 v_0 := v.Args[0]
3238 b := v.Block
3239 typ := &b.Func.Config.Types
3240
3241
3242 for {
3243 x := v_0
3244 y := v_1
3245 v.reset(OpRISCV64MULW)
3246 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
3247 v0.AddArg(x)
3248 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
3249 v1.AddArg(y)
3250 v.AddArg2(v0, v1)
3251 return true
3252 }
3253 }
3254 func rewriteValueRISCV64_OpMul8(v *Value) bool {
3255 v_1 := v.Args[1]
3256 v_0 := v.Args[0]
3257 b := v.Block
3258 typ := &b.Func.Config.Types
3259
3260
3261 for {
3262 x := v_0
3263 y := v_1
3264 v.reset(OpRISCV64MULW)
3265 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
3266 v0.AddArg(x)
3267 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
3268 v1.AddArg(y)
3269 v.AddArg2(v0, v1)
3270 return true
3271 }
3272 }
3273 func rewriteValueRISCV64_OpNeq16(v *Value) bool {
3274 v_1 := v.Args[1]
3275 v_0 := v.Args[0]
3276 b := v.Block
3277 typ := &b.Func.Config.Types
3278
3279
3280 for {
3281 x := v_0
3282 y := v_1
3283 v.reset(OpNot)
3284 v0 := b.NewValue0(v.Pos, OpEq16, typ.Bool)
3285 v0.AddArg2(x, y)
3286 v.AddArg(v0)
3287 return true
3288 }
3289 }
3290 func rewriteValueRISCV64_OpNeq32(v *Value) bool {
3291 v_1 := v.Args[1]
3292 v_0 := v.Args[0]
3293 b := v.Block
3294 typ := &b.Func.Config.Types
3295
3296
3297 for {
3298 x := v_0
3299 y := v_1
3300 v.reset(OpNot)
3301 v0 := b.NewValue0(v.Pos, OpEq32, typ.Bool)
3302 v0.AddArg2(x, y)
3303 v.AddArg(v0)
3304 return true
3305 }
3306 }
3307 func rewriteValueRISCV64_OpNeq64(v *Value) bool {
3308 v_1 := v.Args[1]
3309 v_0 := v.Args[0]
3310 b := v.Block
3311 typ := &b.Func.Config.Types
3312
3313
3314 for {
3315 x := v_0
3316 y := v_1
3317 v.reset(OpNot)
3318 v0 := b.NewValue0(v.Pos, OpEq64, typ.Bool)
3319 v0.AddArg2(x, y)
3320 v.AddArg(v0)
3321 return true
3322 }
3323 }
3324 func rewriteValueRISCV64_OpNeq8(v *Value) bool {
3325 v_1 := v.Args[1]
3326 v_0 := v.Args[0]
3327 b := v.Block
3328 typ := &b.Func.Config.Types
3329
3330
3331 for {
3332 x := v_0
3333 y := v_1
3334 v.reset(OpNot)
3335 v0 := b.NewValue0(v.Pos, OpEq8, typ.Bool)
3336 v0.AddArg2(x, y)
3337 v.AddArg(v0)
3338 return true
3339 }
3340 }
3341 func rewriteValueRISCV64_OpNeqB(v *Value) bool {
3342 v_1 := v.Args[1]
3343 v_0 := v.Args[0]
3344 b := v.Block
3345 typ := &b.Func.Config.Types
3346
3347
3348 for {
3349 x := v_0
3350 y := v_1
3351 v.reset(OpRISCV64SNEZ)
3352 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
3353 v0.AddArg2(x, y)
3354 v.AddArg(v0)
3355 return true
3356 }
3357 }
3358 func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
3359 v_1 := v.Args[1]
3360 v_0 := v.Args[0]
3361 b := v.Block
3362 typ := &b.Func.Config.Types
3363
3364
3365 for {
3366 x := v_0
3367 y := v_1
3368 v.reset(OpNot)
3369 v0 := b.NewValue0(v.Pos, OpEqPtr, typ.Bool)
3370 v0.AddArg2(x, y)
3371 v.AddArg(v0)
3372 return true
3373 }
3374 }
3375 func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
3376 v_0 := v.Args[0]
3377 b := v.Block
3378 typ := &b.Func.Config.Types
3379
3380
3381
3382 for {
3383 off := auxIntToInt64(v.AuxInt)
3384 ptr := v_0
3385 if ptr.Op != OpSP || !(is32Bit(off)) {
3386 break
3387 }
3388 v.reset(OpRISCV64MOVaddr)
3389 v.AuxInt = int32ToAuxInt(int32(off))
3390 v.AddArg(ptr)
3391 return true
3392 }
3393
3394
3395
3396 for {
3397 off := auxIntToInt64(v.AuxInt)
3398 ptr := v_0
3399 if !(is32Bit(off)) {
3400 break
3401 }
3402 v.reset(OpRISCV64ADDI)
3403 v.AuxInt = int64ToAuxInt(off)
3404 v.AddArg(ptr)
3405 return true
3406 }
3407
3408
3409 for {
3410 off := auxIntToInt64(v.AuxInt)
3411 ptr := v_0
3412 v.reset(OpRISCV64ADD)
3413 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
3414 v0.AuxInt = int64ToAuxInt(off)
3415 v.AddArg2(v0, ptr)
3416 return true
3417 }
3418 }
3419 func rewriteValueRISCV64_OpPanicBounds(v *Value) bool {
3420 v_2 := v.Args[2]
3421 v_1 := v.Args[1]
3422 v_0 := v.Args[0]
3423
3424
3425
3426 for {
3427 kind := auxIntToInt64(v.AuxInt)
3428 x := v_0
3429 y := v_1
3430 mem := v_2
3431 if !(boundsABI(kind) == 0) {
3432 break
3433 }
3434 v.reset(OpRISCV64LoweredPanicBoundsA)
3435 v.AuxInt = int64ToAuxInt(kind)
3436 v.AddArg3(x, y, mem)
3437 return true
3438 }
3439
3440
3441
3442 for {
3443 kind := auxIntToInt64(v.AuxInt)
3444 x := v_0
3445 y := v_1
3446 mem := v_2
3447 if !(boundsABI(kind) == 1) {
3448 break
3449 }
3450 v.reset(OpRISCV64LoweredPanicBoundsB)
3451 v.AuxInt = int64ToAuxInt(kind)
3452 v.AddArg3(x, y, mem)
3453 return true
3454 }
3455
3456
3457
3458 for {
3459 kind := auxIntToInt64(v.AuxInt)
3460 x := v_0
3461 y := v_1
3462 mem := v_2
3463 if !(boundsABI(kind) == 2) {
3464 break
3465 }
3466 v.reset(OpRISCV64LoweredPanicBoundsC)
3467 v.AuxInt = int64ToAuxInt(kind)
3468 v.AddArg3(x, y, mem)
3469 return true
3470 }
3471 return false
3472 }
3473 func rewriteValueRISCV64_OpPopCount16(v *Value) bool {
3474 v_0 := v.Args[0]
3475 b := v.Block
3476 typ := &b.Func.Config.Types
3477
3478
3479 for {
3480 x := v_0
3481 v.reset(OpRISCV64CPOP)
3482 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
3483 v0.AddArg(x)
3484 v.AddArg(v0)
3485 return true
3486 }
3487 }
3488 func rewriteValueRISCV64_OpPopCount8(v *Value) bool {
3489 v_0 := v.Args[0]
3490 b := v.Block
3491 typ := &b.Func.Config.Types
3492
3493
3494 for {
3495 x := v_0
3496 v.reset(OpRISCV64CPOP)
3497 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3498 v0.AddArg(x)
3499 v.AddArg(v0)
3500 return true
3501 }
3502 }
3503 func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
3504 v_1 := v.Args[1]
3505 v_0 := v.Args[0]
3506
3507
3508
3509 for {
3510 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3511 if v_0.Op != OpRISCV64MOVDconst {
3512 continue
3513 }
3514 t := v_0.Type
3515 val := auxIntToInt64(v_0.AuxInt)
3516 x := v_1
3517 if !(is32Bit(val) && !t.IsPtr()) {
3518 continue
3519 }
3520 v.reset(OpRISCV64ADDI)
3521 v.AuxInt = int64ToAuxInt(val)
3522 v.AddArg(x)
3523 return true
3524 }
3525 break
3526 }
3527
3528
3529 for {
3530 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3531 x := v_0
3532 if v_1.Op != OpRISCV64NEG {
3533 continue
3534 }
3535 y := v_1.Args[0]
3536 v.reset(OpRISCV64SUB)
3537 v.AddArg2(x, y)
3538 return true
3539 }
3540 break
3541 }
3542
3543
3544
3545 for {
3546 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3547 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 1 {
3548 continue
3549 }
3550 x := v_0.Args[0]
3551 y := v_1
3552 if !(buildcfg.GORISCV64 >= 22) {
3553 continue
3554 }
3555 v.reset(OpRISCV64SH1ADD)
3556 v.AddArg2(x, y)
3557 return true
3558 }
3559 break
3560 }
3561
3562
3563
3564 for {
3565 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3566 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 2 {
3567 continue
3568 }
3569 x := v_0.Args[0]
3570 y := v_1
3571 if !(buildcfg.GORISCV64 >= 22) {
3572 continue
3573 }
3574 v.reset(OpRISCV64SH2ADD)
3575 v.AddArg2(x, y)
3576 return true
3577 }
3578 break
3579 }
3580
3581
3582
3583 for {
3584 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3585 if v_0.Op != OpRISCV64SLLI || auxIntToInt64(v_0.AuxInt) != 3 {
3586 continue
3587 }
3588 x := v_0.Args[0]
3589 y := v_1
3590 if !(buildcfg.GORISCV64 >= 22) {
3591 continue
3592 }
3593 v.reset(OpRISCV64SH3ADD)
3594 v.AddArg2(x, y)
3595 return true
3596 }
3597 break
3598 }
3599 return false
3600 }
3601 func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
3602 v_0 := v.Args[0]
3603
3604
3605
3606 for {
3607 c := auxIntToInt64(v.AuxInt)
3608 if v_0.Op != OpRISCV64MOVaddr {
3609 break
3610 }
3611 d := auxIntToInt32(v_0.AuxInt)
3612 s := auxToSym(v_0.Aux)
3613 x := v_0.Args[0]
3614 if !(is32Bit(c + int64(d))) {
3615 break
3616 }
3617 v.reset(OpRISCV64MOVaddr)
3618 v.AuxInt = int32ToAuxInt(int32(c) + d)
3619 v.Aux = symToAux(s)
3620 v.AddArg(x)
3621 return true
3622 }
3623
3624
3625 for {
3626 if auxIntToInt64(v.AuxInt) != 0 {
3627 break
3628 }
3629 x := v_0
3630 v.copyOf(x)
3631 return true
3632 }
3633
3634
3635
3636 for {
3637 x := auxIntToInt64(v.AuxInt)
3638 if v_0.Op != OpRISCV64MOVDconst {
3639 break
3640 }
3641 y := auxIntToInt64(v_0.AuxInt)
3642 if !(is32Bit(x + y)) {
3643 break
3644 }
3645 v.reset(OpRISCV64MOVDconst)
3646 v.AuxInt = int64ToAuxInt(x + y)
3647 return true
3648 }
3649
3650
3651
3652 for {
3653 x := auxIntToInt64(v.AuxInt)
3654 if v_0.Op != OpRISCV64ADDI {
3655 break
3656 }
3657 y := auxIntToInt64(v_0.AuxInt)
3658 z := v_0.Args[0]
3659 if !(is32Bit(x + y)) {
3660 break
3661 }
3662 v.reset(OpRISCV64ADDI)
3663 v.AuxInt = int64ToAuxInt(x + y)
3664 v.AddArg(z)
3665 return true
3666 }
3667 return false
3668 }
3669 func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
3670 v_1 := v.Args[1]
3671 v_0 := v.Args[0]
3672
3673
3674
3675 for {
3676 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3677 if v_0.Op != OpRISCV64MOVDconst {
3678 continue
3679 }
3680 val := auxIntToInt64(v_0.AuxInt)
3681 x := v_1
3682 if !(is32Bit(val)) {
3683 continue
3684 }
3685 v.reset(OpRISCV64ANDI)
3686 v.AuxInt = int64ToAuxInt(val)
3687 v.AddArg(x)
3688 return true
3689 }
3690 break
3691 }
3692
3693
3694 for {
3695 x := v_0
3696 if x != v_1 {
3697 break
3698 }
3699 v.copyOf(x)
3700 return true
3701 }
3702 return false
3703 }
3704 func rewriteValueRISCV64_OpRISCV64ANDI(v *Value) bool {
3705 v_0 := v.Args[0]
3706
3707
3708 for {
3709 if auxIntToInt64(v.AuxInt) != 0 {
3710 break
3711 }
3712 v.reset(OpRISCV64MOVDconst)
3713 v.AuxInt = int64ToAuxInt(0)
3714 return true
3715 }
3716
3717
3718 for {
3719 if auxIntToInt64(v.AuxInt) != -1 {
3720 break
3721 }
3722 x := v_0
3723 v.copyOf(x)
3724 return true
3725 }
3726
3727
3728 for {
3729 x := auxIntToInt64(v.AuxInt)
3730 if v_0.Op != OpRISCV64MOVDconst {
3731 break
3732 }
3733 y := auxIntToInt64(v_0.AuxInt)
3734 v.reset(OpRISCV64MOVDconst)
3735 v.AuxInt = int64ToAuxInt(x & y)
3736 return true
3737 }
3738
3739
3740 for {
3741 x := auxIntToInt64(v.AuxInt)
3742 if v_0.Op != OpRISCV64ANDI {
3743 break
3744 }
3745 y := auxIntToInt64(v_0.AuxInt)
3746 z := v_0.Args[0]
3747 v.reset(OpRISCV64ANDI)
3748 v.AuxInt = int64ToAuxInt(x & y)
3749 v.AddArg(z)
3750 return true
3751 }
3752 return false
3753 }
3754 func rewriteValueRISCV64_OpRISCV64FADDD(v *Value) bool {
3755 v_1 := v.Args[1]
3756 v_0 := v.Args[0]
3757
3758
3759
3760 for {
3761 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3762 a := v_0
3763 if v_1.Op != OpRISCV64FMULD {
3764 continue
3765 }
3766 y := v_1.Args[1]
3767 x := v_1.Args[0]
3768 if !(a.Block.Func.useFMA(v)) {
3769 continue
3770 }
3771 v.reset(OpRISCV64FMADDD)
3772 v.AddArg3(x, y, a)
3773 return true
3774 }
3775 break
3776 }
3777 return false
3778 }
3779 func rewriteValueRISCV64_OpRISCV64FADDS(v *Value) bool {
3780 v_1 := v.Args[1]
3781 v_0 := v.Args[0]
3782
3783
3784
3785 for {
3786 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3787 a := v_0
3788 if v_1.Op != OpRISCV64FMULS {
3789 continue
3790 }
3791 y := v_1.Args[1]
3792 x := v_1.Args[0]
3793 if !(a.Block.Func.useFMA(v)) {
3794 continue
3795 }
3796 v.reset(OpRISCV64FMADDS)
3797 v.AddArg3(x, y, a)
3798 return true
3799 }
3800 break
3801 }
3802 return false
3803 }
3804 func rewriteValueRISCV64_OpRISCV64FMADDD(v *Value) bool {
3805 v_2 := v.Args[2]
3806 v_1 := v.Args[1]
3807 v_0 := v.Args[0]
3808
3809
3810
3811 for {
3812 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3813 neg := v_0
3814 if neg.Op != OpRISCV64FNEGD {
3815 continue
3816 }
3817 x := neg.Args[0]
3818 y := v_1
3819 z := v_2
3820 if !(neg.Uses == 1) {
3821 continue
3822 }
3823 v.reset(OpRISCV64FNMSUBD)
3824 v.AddArg3(x, y, z)
3825 return true
3826 }
3827 break
3828 }
3829
3830
3831
3832 for {
3833 x := v_0
3834 y := v_1
3835 neg := v_2
3836 if neg.Op != OpRISCV64FNEGD {
3837 break
3838 }
3839 z := neg.Args[0]
3840 if !(neg.Uses == 1) {
3841 break
3842 }
3843 v.reset(OpRISCV64FMSUBD)
3844 v.AddArg3(x, y, z)
3845 return true
3846 }
3847 return false
3848 }
3849 func rewriteValueRISCV64_OpRISCV64FMADDS(v *Value) bool {
3850 v_2 := v.Args[2]
3851 v_1 := v.Args[1]
3852 v_0 := v.Args[0]
3853
3854
3855
3856 for {
3857 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3858 neg := v_0
3859 if neg.Op != OpRISCV64FNEGS {
3860 continue
3861 }
3862 x := neg.Args[0]
3863 y := v_1
3864 z := v_2
3865 if !(neg.Uses == 1) {
3866 continue
3867 }
3868 v.reset(OpRISCV64FNMSUBS)
3869 v.AddArg3(x, y, z)
3870 return true
3871 }
3872 break
3873 }
3874
3875
3876
3877 for {
3878 x := v_0
3879 y := v_1
3880 neg := v_2
3881 if neg.Op != OpRISCV64FNEGS {
3882 break
3883 }
3884 z := neg.Args[0]
3885 if !(neg.Uses == 1) {
3886 break
3887 }
3888 v.reset(OpRISCV64FMSUBS)
3889 v.AddArg3(x, y, z)
3890 return true
3891 }
3892 return false
3893 }
3894 func rewriteValueRISCV64_OpRISCV64FMSUBD(v *Value) bool {
3895 v_2 := v.Args[2]
3896 v_1 := v.Args[1]
3897 v_0 := v.Args[0]
3898
3899
3900
3901 for {
3902 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3903 neg := v_0
3904 if neg.Op != OpRISCV64FNEGD {
3905 continue
3906 }
3907 x := neg.Args[0]
3908 y := v_1
3909 z := v_2
3910 if !(neg.Uses == 1) {
3911 continue
3912 }
3913 v.reset(OpRISCV64FNMADDD)
3914 v.AddArg3(x, y, z)
3915 return true
3916 }
3917 break
3918 }
3919
3920
3921
3922 for {
3923 x := v_0
3924 y := v_1
3925 neg := v_2
3926 if neg.Op != OpRISCV64FNEGD {
3927 break
3928 }
3929 z := neg.Args[0]
3930 if !(neg.Uses == 1) {
3931 break
3932 }
3933 v.reset(OpRISCV64FMADDD)
3934 v.AddArg3(x, y, z)
3935 return true
3936 }
3937 return false
3938 }
3939 func rewriteValueRISCV64_OpRISCV64FMSUBS(v *Value) bool {
3940 v_2 := v.Args[2]
3941 v_1 := v.Args[1]
3942 v_0 := v.Args[0]
3943
3944
3945
3946 for {
3947 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3948 neg := v_0
3949 if neg.Op != OpRISCV64FNEGS {
3950 continue
3951 }
3952 x := neg.Args[0]
3953 y := v_1
3954 z := v_2
3955 if !(neg.Uses == 1) {
3956 continue
3957 }
3958 v.reset(OpRISCV64FNMADDS)
3959 v.AddArg3(x, y, z)
3960 return true
3961 }
3962 break
3963 }
3964
3965
3966
3967 for {
3968 x := v_0
3969 y := v_1
3970 neg := v_2
3971 if neg.Op != OpRISCV64FNEGS {
3972 break
3973 }
3974 z := neg.Args[0]
3975 if !(neg.Uses == 1) {
3976 break
3977 }
3978 v.reset(OpRISCV64FMADDS)
3979 v.AddArg3(x, y, z)
3980 return true
3981 }
3982 return false
3983 }
3984 func rewriteValueRISCV64_OpRISCV64FNMADDD(v *Value) bool {
3985 v_2 := v.Args[2]
3986 v_1 := v.Args[1]
3987 v_0 := v.Args[0]
3988
3989
3990
3991 for {
3992 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3993 neg := v_0
3994 if neg.Op != OpRISCV64FNEGD {
3995 continue
3996 }
3997 x := neg.Args[0]
3998 y := v_1
3999 z := v_2
4000 if !(neg.Uses == 1) {
4001 continue
4002 }
4003 v.reset(OpRISCV64FMSUBD)
4004 v.AddArg3(x, y, z)
4005 return true
4006 }
4007 break
4008 }
4009
4010
4011
4012 for {
4013 x := v_0
4014 y := v_1
4015 neg := v_2
4016 if neg.Op != OpRISCV64FNEGD {
4017 break
4018 }
4019 z := neg.Args[0]
4020 if !(neg.Uses == 1) {
4021 break
4022 }
4023 v.reset(OpRISCV64FNMSUBD)
4024 v.AddArg3(x, y, z)
4025 return true
4026 }
4027 return false
4028 }
4029 func rewriteValueRISCV64_OpRISCV64FNMADDS(v *Value) bool {
4030 v_2 := v.Args[2]
4031 v_1 := v.Args[1]
4032 v_0 := v.Args[0]
4033
4034
4035
4036 for {
4037 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4038 neg := v_0
4039 if neg.Op != OpRISCV64FNEGS {
4040 continue
4041 }
4042 x := neg.Args[0]
4043 y := v_1
4044 z := v_2
4045 if !(neg.Uses == 1) {
4046 continue
4047 }
4048 v.reset(OpRISCV64FMSUBS)
4049 v.AddArg3(x, y, z)
4050 return true
4051 }
4052 break
4053 }
4054
4055
4056
4057 for {
4058 x := v_0
4059 y := v_1
4060 neg := v_2
4061 if neg.Op != OpRISCV64FNEGS {
4062 break
4063 }
4064 z := neg.Args[0]
4065 if !(neg.Uses == 1) {
4066 break
4067 }
4068 v.reset(OpRISCV64FNMSUBS)
4069 v.AddArg3(x, y, z)
4070 return true
4071 }
4072 return false
4073 }
4074 func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *Value) bool {
4075 v_2 := v.Args[2]
4076 v_1 := v.Args[1]
4077 v_0 := v.Args[0]
4078
4079
4080
4081 for {
4082 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4083 neg := v_0
4084 if neg.Op != OpRISCV64FNEGD {
4085 continue
4086 }
4087 x := neg.Args[0]
4088 y := v_1
4089 z := v_2
4090 if !(neg.Uses == 1) {
4091 continue
4092 }
4093 v.reset(OpRISCV64FMADDD)
4094 v.AddArg3(x, y, z)
4095 return true
4096 }
4097 break
4098 }
4099
4100
4101
4102 for {
4103 x := v_0
4104 y := v_1
4105 neg := v_2
4106 if neg.Op != OpRISCV64FNEGD {
4107 break
4108 }
4109 z := neg.Args[0]
4110 if !(neg.Uses == 1) {
4111 break
4112 }
4113 v.reset(OpRISCV64FNMADDD)
4114 v.AddArg3(x, y, z)
4115 return true
4116 }
4117 return false
4118 }
4119 func rewriteValueRISCV64_OpRISCV64FNMSUBS(v *Value) bool {
4120 v_2 := v.Args[2]
4121 v_1 := v.Args[1]
4122 v_0 := v.Args[0]
4123
4124
4125
4126 for {
4127 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4128 neg := v_0
4129 if neg.Op != OpRISCV64FNEGS {
4130 continue
4131 }
4132 x := neg.Args[0]
4133 y := v_1
4134 z := v_2
4135 if !(neg.Uses == 1) {
4136 continue
4137 }
4138 v.reset(OpRISCV64FMADDS)
4139 v.AddArg3(x, y, z)
4140 return true
4141 }
4142 break
4143 }
4144
4145
4146
4147 for {
4148 x := v_0
4149 y := v_1
4150 neg := v_2
4151 if neg.Op != OpRISCV64FNEGS {
4152 break
4153 }
4154 z := neg.Args[0]
4155 if !(neg.Uses == 1) {
4156 break
4157 }
4158 v.reset(OpRISCV64FNMADDS)
4159 v.AddArg3(x, y, z)
4160 return true
4161 }
4162 return false
4163 }
4164 func rewriteValueRISCV64_OpRISCV64FSUBD(v *Value) bool {
4165 v_1 := v.Args[1]
4166 v_0 := v.Args[0]
4167
4168
4169
4170 for {
4171 a := v_0
4172 if v_1.Op != OpRISCV64FMULD {
4173 break
4174 }
4175 y := v_1.Args[1]
4176 x := v_1.Args[0]
4177 if !(a.Block.Func.useFMA(v)) {
4178 break
4179 }
4180 v.reset(OpRISCV64FNMSUBD)
4181 v.AddArg3(x, y, a)
4182 return true
4183 }
4184
4185
4186
4187 for {
4188 if v_0.Op != OpRISCV64FMULD {
4189 break
4190 }
4191 y := v_0.Args[1]
4192 x := v_0.Args[0]
4193 a := v_1
4194 if !(a.Block.Func.useFMA(v)) {
4195 break
4196 }
4197 v.reset(OpRISCV64FMSUBD)
4198 v.AddArg3(x, y, a)
4199 return true
4200 }
4201 return false
4202 }
4203 func rewriteValueRISCV64_OpRISCV64FSUBS(v *Value) bool {
4204 v_1 := v.Args[1]
4205 v_0 := v.Args[0]
4206
4207
4208
4209 for {
4210 a := v_0
4211 if v_1.Op != OpRISCV64FMULS {
4212 break
4213 }
4214 y := v_1.Args[1]
4215 x := v_1.Args[0]
4216 if !(a.Block.Func.useFMA(v)) {
4217 break
4218 }
4219 v.reset(OpRISCV64FNMSUBS)
4220 v.AddArg3(x, y, a)
4221 return true
4222 }
4223
4224
4225
4226 for {
4227 if v_0.Op != OpRISCV64FMULS {
4228 break
4229 }
4230 y := v_0.Args[1]
4231 x := v_0.Args[0]
4232 a := v_1
4233 if !(a.Block.Func.useFMA(v)) {
4234 break
4235 }
4236 v.reset(OpRISCV64FMSUBS)
4237 v.AddArg3(x, y, a)
4238 return true
4239 }
4240 return false
4241 }
4242 func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
4243 v_1 := v.Args[1]
4244 v_0 := v.Args[0]
4245 b := v.Block
4246 config := b.Func.Config
4247
4248
4249
4250 for {
4251 off1 := auxIntToInt32(v.AuxInt)
4252 sym1 := auxToSym(v.Aux)
4253 if v_0.Op != OpRISCV64MOVaddr {
4254 break
4255 }
4256 off2 := auxIntToInt32(v_0.AuxInt)
4257 sym2 := auxToSym(v_0.Aux)
4258 base := v_0.Args[0]
4259 mem := v_1
4260 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4261 break
4262 }
4263 v.reset(OpRISCV64MOVBUload)
4264 v.AuxInt = int32ToAuxInt(off1 + off2)
4265 v.Aux = symToAux(mergeSym(sym1, sym2))
4266 v.AddArg2(base, mem)
4267 return true
4268 }
4269
4270
4271
4272 for {
4273 off1 := auxIntToInt32(v.AuxInt)
4274 sym := auxToSym(v.Aux)
4275 if v_0.Op != OpRISCV64ADDI {
4276 break
4277 }
4278 off2 := auxIntToInt64(v_0.AuxInt)
4279 base := v_0.Args[0]
4280 mem := v_1
4281 if !(is32Bit(int64(off1) + off2)) {
4282 break
4283 }
4284 v.reset(OpRISCV64MOVBUload)
4285 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4286 v.Aux = symToAux(sym)
4287 v.AddArg2(base, mem)
4288 return true
4289 }
4290 return false
4291 }
4292 func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
4293 v_0 := v.Args[0]
4294 b := v.Block
4295
4296
4297 for {
4298 x := v_0
4299 if x.Op != OpRISCV64FLES {
4300 break
4301 }
4302 v.copyOf(x)
4303 return true
4304 }
4305
4306
4307 for {
4308 x := v_0
4309 if x.Op != OpRISCV64FLTS {
4310 break
4311 }
4312 v.copyOf(x)
4313 return true
4314 }
4315
4316
4317 for {
4318 x := v_0
4319 if x.Op != OpRISCV64FEQS {
4320 break
4321 }
4322 v.copyOf(x)
4323 return true
4324 }
4325
4326
4327 for {
4328 x := v_0
4329 if x.Op != OpRISCV64FNES {
4330 break
4331 }
4332 v.copyOf(x)
4333 return true
4334 }
4335
4336
4337 for {
4338 x := v_0
4339 if x.Op != OpRISCV64FLED {
4340 break
4341 }
4342 v.copyOf(x)
4343 return true
4344 }
4345
4346
4347 for {
4348 x := v_0
4349 if x.Op != OpRISCV64FLTD {
4350 break
4351 }
4352 v.copyOf(x)
4353 return true
4354 }
4355
4356
4357 for {
4358 x := v_0
4359 if x.Op != OpRISCV64FEQD {
4360 break
4361 }
4362 v.copyOf(x)
4363 return true
4364 }
4365
4366
4367 for {
4368 x := v_0
4369 if x.Op != OpRISCV64FNED {
4370 break
4371 }
4372 v.copyOf(x)
4373 return true
4374 }
4375
4376
4377 for {
4378 x := v_0
4379 if x.Op != OpRISCV64SEQZ {
4380 break
4381 }
4382 v.copyOf(x)
4383 return true
4384 }
4385
4386
4387 for {
4388 x := v_0
4389 if x.Op != OpRISCV64SNEZ {
4390 break
4391 }
4392 v.copyOf(x)
4393 return true
4394 }
4395
4396
4397 for {
4398 x := v_0
4399 if x.Op != OpRISCV64SLT {
4400 break
4401 }
4402 v.copyOf(x)
4403 return true
4404 }
4405
4406
4407 for {
4408 x := v_0
4409 if x.Op != OpRISCV64SLTU {
4410 break
4411 }
4412 v.copyOf(x)
4413 return true
4414 }
4415
4416
4417
4418 for {
4419 x := v_0
4420 if x.Op != OpRISCV64ANDI {
4421 break
4422 }
4423 c := auxIntToInt64(x.AuxInt)
4424 if !(c >= 0 && int64(uint8(c)) == c) {
4425 break
4426 }
4427 v.copyOf(x)
4428 return true
4429 }
4430
4431
4432
4433 for {
4434 if v_0.Op != OpRISCV64ANDI {
4435 break
4436 }
4437 c := auxIntToInt64(v_0.AuxInt)
4438 x := v_0.Args[0]
4439 if !(c < 0) {
4440 break
4441 }
4442 v.reset(OpRISCV64ANDI)
4443 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
4444 v.AddArg(x)
4445 return true
4446 }
4447
4448
4449 for {
4450 if v_0.Op != OpRISCV64MOVDconst {
4451 break
4452 }
4453 c := auxIntToInt64(v_0.AuxInt)
4454 v.reset(OpRISCV64MOVDconst)
4455 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
4456 return true
4457 }
4458
4459
4460 for {
4461 x := v_0
4462 if x.Op != OpRISCV64MOVBUload {
4463 break
4464 }
4465 v.reset(OpRISCV64MOVDreg)
4466 v.AddArg(x)
4467 return true
4468 }
4469
4470
4471 for {
4472 x := v_0
4473 if x.Op != OpSelect0 {
4474 break
4475 }
4476 x_0 := x.Args[0]
4477 if x_0.Op != OpRISCV64LoweredAtomicLoad8 {
4478 break
4479 }
4480 v.reset(OpRISCV64MOVDreg)
4481 v.AddArg(x)
4482 return true
4483 }
4484
4485
4486 for {
4487 x := v_0
4488 if x.Op != OpSelect0 {
4489 break
4490 }
4491 x_0 := x.Args[0]
4492 if x_0.Op != OpRISCV64LoweredAtomicCas32 {
4493 break
4494 }
4495 v.reset(OpRISCV64MOVDreg)
4496 v.AddArg(x)
4497 return true
4498 }
4499
4500
4501 for {
4502 x := v_0
4503 if x.Op != OpSelect0 {
4504 break
4505 }
4506 x_0 := x.Args[0]
4507 if x_0.Op != OpRISCV64LoweredAtomicCas64 {
4508 break
4509 }
4510 v.reset(OpRISCV64MOVDreg)
4511 v.AddArg(x)
4512 return true
4513 }
4514
4515
4516 for {
4517 x := v_0
4518 if x.Op != OpRISCV64MOVBUreg {
4519 break
4520 }
4521 v.reset(OpRISCV64MOVDreg)
4522 v.AddArg(x)
4523 return true
4524 }
4525
4526
4527
4528 for {
4529 t := v.Type
4530 x := v_0
4531 if x.Op != OpRISCV64MOVBload {
4532 break
4533 }
4534 off := auxIntToInt32(x.AuxInt)
4535 sym := auxToSym(x.Aux)
4536 mem := x.Args[1]
4537 ptr := x.Args[0]
4538 if !(x.Uses == 1 && clobber(x)) {
4539 break
4540 }
4541 b = x.Block
4542 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBUload, t)
4543 v.copyOf(v0)
4544 v0.AuxInt = int32ToAuxInt(off)
4545 v0.Aux = symToAux(sym)
4546 v0.AddArg2(ptr, mem)
4547 return true
4548 }
4549 return false
4550 }
4551 func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
4552 v_1 := v.Args[1]
4553 v_0 := v.Args[0]
4554 b := v.Block
4555 config := b.Func.Config
4556
4557
4558
4559 for {
4560 off1 := auxIntToInt32(v.AuxInt)
4561 sym1 := auxToSym(v.Aux)
4562 if v_0.Op != OpRISCV64MOVaddr {
4563 break
4564 }
4565 off2 := auxIntToInt32(v_0.AuxInt)
4566 sym2 := auxToSym(v_0.Aux)
4567 base := v_0.Args[0]
4568 mem := v_1
4569 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4570 break
4571 }
4572 v.reset(OpRISCV64MOVBload)
4573 v.AuxInt = int32ToAuxInt(off1 + off2)
4574 v.Aux = symToAux(mergeSym(sym1, sym2))
4575 v.AddArg2(base, mem)
4576 return true
4577 }
4578
4579
4580
4581 for {
4582 off1 := auxIntToInt32(v.AuxInt)
4583 sym := auxToSym(v.Aux)
4584 if v_0.Op != OpRISCV64ADDI {
4585 break
4586 }
4587 off2 := auxIntToInt64(v_0.AuxInt)
4588 base := v_0.Args[0]
4589 mem := v_1
4590 if !(is32Bit(int64(off1) + off2)) {
4591 break
4592 }
4593 v.reset(OpRISCV64MOVBload)
4594 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4595 v.Aux = symToAux(sym)
4596 v.AddArg2(base, mem)
4597 return true
4598 }
4599 return false
4600 }
4601 func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
4602 v_0 := v.Args[0]
4603 b := v.Block
4604
4605
4606
4607 for {
4608 x := v_0
4609 if x.Op != OpRISCV64ANDI {
4610 break
4611 }
4612 c := auxIntToInt64(x.AuxInt)
4613 if !(c >= 0 && int64(int8(c)) == c) {
4614 break
4615 }
4616 v.copyOf(x)
4617 return true
4618 }
4619
4620
4621 for {
4622 if v_0.Op != OpRISCV64MOVDconst {
4623 break
4624 }
4625 c := auxIntToInt64(v_0.AuxInt)
4626 v.reset(OpRISCV64MOVDconst)
4627 v.AuxInt = int64ToAuxInt(int64(int8(c)))
4628 return true
4629 }
4630
4631
4632 for {
4633 x := v_0
4634 if x.Op != OpRISCV64MOVBload {
4635 break
4636 }
4637 v.reset(OpRISCV64MOVDreg)
4638 v.AddArg(x)
4639 return true
4640 }
4641
4642
4643 for {
4644 x := v_0
4645 if x.Op != OpRISCV64MOVBreg {
4646 break
4647 }
4648 v.reset(OpRISCV64MOVDreg)
4649 v.AddArg(x)
4650 return true
4651 }
4652
4653
4654
4655 for {
4656 t := v.Type
4657 x := v_0
4658 if x.Op != OpRISCV64MOVBUload {
4659 break
4660 }
4661 off := auxIntToInt32(x.AuxInt)
4662 sym := auxToSym(x.Aux)
4663 mem := x.Args[1]
4664 ptr := x.Args[0]
4665 if !(x.Uses == 1 && clobber(x)) {
4666 break
4667 }
4668 b = x.Block
4669 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBload, t)
4670 v.copyOf(v0)
4671 v0.AuxInt = int32ToAuxInt(off)
4672 v0.Aux = symToAux(sym)
4673 v0.AddArg2(ptr, mem)
4674 return true
4675 }
4676 return false
4677 }
4678 func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
4679 v_2 := v.Args[2]
4680 v_1 := v.Args[1]
4681 v_0 := v.Args[0]
4682 b := v.Block
4683 config := b.Func.Config
4684
4685
4686
4687 for {
4688 off1 := auxIntToInt32(v.AuxInt)
4689 sym1 := auxToSym(v.Aux)
4690 if v_0.Op != OpRISCV64MOVaddr {
4691 break
4692 }
4693 off2 := auxIntToInt32(v_0.AuxInt)
4694 sym2 := auxToSym(v_0.Aux)
4695 base := v_0.Args[0]
4696 val := v_1
4697 mem := v_2
4698 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4699 break
4700 }
4701 v.reset(OpRISCV64MOVBstore)
4702 v.AuxInt = int32ToAuxInt(off1 + off2)
4703 v.Aux = symToAux(mergeSym(sym1, sym2))
4704 v.AddArg3(base, val, mem)
4705 return true
4706 }
4707
4708
4709
4710 for {
4711 off1 := auxIntToInt32(v.AuxInt)
4712 sym := auxToSym(v.Aux)
4713 if v_0.Op != OpRISCV64ADDI {
4714 break
4715 }
4716 off2 := auxIntToInt64(v_0.AuxInt)
4717 base := v_0.Args[0]
4718 val := v_1
4719 mem := v_2
4720 if !(is32Bit(int64(off1) + off2)) {
4721 break
4722 }
4723 v.reset(OpRISCV64MOVBstore)
4724 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4725 v.Aux = symToAux(sym)
4726 v.AddArg3(base, val, mem)
4727 return true
4728 }
4729
4730
4731 for {
4732 off := auxIntToInt32(v.AuxInt)
4733 sym := auxToSym(v.Aux)
4734 ptr := v_0
4735 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4736 break
4737 }
4738 mem := v_2
4739 v.reset(OpRISCV64MOVBstorezero)
4740 v.AuxInt = int32ToAuxInt(off)
4741 v.Aux = symToAux(sym)
4742 v.AddArg2(ptr, mem)
4743 return true
4744 }
4745
4746
4747 for {
4748 off := auxIntToInt32(v.AuxInt)
4749 sym := auxToSym(v.Aux)
4750 ptr := v_0
4751 if v_1.Op != OpRISCV64MOVBreg {
4752 break
4753 }
4754 x := v_1.Args[0]
4755 mem := v_2
4756 v.reset(OpRISCV64MOVBstore)
4757 v.AuxInt = int32ToAuxInt(off)
4758 v.Aux = symToAux(sym)
4759 v.AddArg3(ptr, x, mem)
4760 return true
4761 }
4762
4763
4764 for {
4765 off := auxIntToInt32(v.AuxInt)
4766 sym := auxToSym(v.Aux)
4767 ptr := v_0
4768 if v_1.Op != OpRISCV64MOVHreg {
4769 break
4770 }
4771 x := v_1.Args[0]
4772 mem := v_2
4773 v.reset(OpRISCV64MOVBstore)
4774 v.AuxInt = int32ToAuxInt(off)
4775 v.Aux = symToAux(sym)
4776 v.AddArg3(ptr, x, mem)
4777 return true
4778 }
4779
4780
4781 for {
4782 off := auxIntToInt32(v.AuxInt)
4783 sym := auxToSym(v.Aux)
4784 ptr := v_0
4785 if v_1.Op != OpRISCV64MOVWreg {
4786 break
4787 }
4788 x := v_1.Args[0]
4789 mem := v_2
4790 v.reset(OpRISCV64MOVBstore)
4791 v.AuxInt = int32ToAuxInt(off)
4792 v.Aux = symToAux(sym)
4793 v.AddArg3(ptr, x, mem)
4794 return true
4795 }
4796
4797
4798 for {
4799 off := auxIntToInt32(v.AuxInt)
4800 sym := auxToSym(v.Aux)
4801 ptr := v_0
4802 if v_1.Op != OpRISCV64MOVBUreg {
4803 break
4804 }
4805 x := v_1.Args[0]
4806 mem := v_2
4807 v.reset(OpRISCV64MOVBstore)
4808 v.AuxInt = int32ToAuxInt(off)
4809 v.Aux = symToAux(sym)
4810 v.AddArg3(ptr, x, mem)
4811 return true
4812 }
4813
4814
4815 for {
4816 off := auxIntToInt32(v.AuxInt)
4817 sym := auxToSym(v.Aux)
4818 ptr := v_0
4819 if v_1.Op != OpRISCV64MOVHUreg {
4820 break
4821 }
4822 x := v_1.Args[0]
4823 mem := v_2
4824 v.reset(OpRISCV64MOVBstore)
4825 v.AuxInt = int32ToAuxInt(off)
4826 v.Aux = symToAux(sym)
4827 v.AddArg3(ptr, x, mem)
4828 return true
4829 }
4830
4831
4832 for {
4833 off := auxIntToInt32(v.AuxInt)
4834 sym := auxToSym(v.Aux)
4835 ptr := v_0
4836 if v_1.Op != OpRISCV64MOVWUreg {
4837 break
4838 }
4839 x := v_1.Args[0]
4840 mem := v_2
4841 v.reset(OpRISCV64MOVBstore)
4842 v.AuxInt = int32ToAuxInt(off)
4843 v.Aux = symToAux(sym)
4844 v.AddArg3(ptr, x, mem)
4845 return true
4846 }
4847 return false
4848 }
4849 func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
4850 v_1 := v.Args[1]
4851 v_0 := v.Args[0]
4852 b := v.Block
4853 config := b.Func.Config
4854
4855
4856
4857 for {
4858 off1 := auxIntToInt32(v.AuxInt)
4859 sym1 := auxToSym(v.Aux)
4860 if v_0.Op != OpRISCV64MOVaddr {
4861 break
4862 }
4863 off2 := auxIntToInt32(v_0.AuxInt)
4864 sym2 := auxToSym(v_0.Aux)
4865 base := v_0.Args[0]
4866 mem := v_1
4867 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
4868 break
4869 }
4870 v.reset(OpRISCV64MOVBstorezero)
4871 v.AuxInt = int32ToAuxInt(off1 + off2)
4872 v.Aux = symToAux(mergeSym(sym1, sym2))
4873 v.AddArg2(base, mem)
4874 return true
4875 }
4876
4877
4878
4879 for {
4880 off1 := auxIntToInt32(v.AuxInt)
4881 sym := auxToSym(v.Aux)
4882 if v_0.Op != OpRISCV64ADDI {
4883 break
4884 }
4885 off2 := auxIntToInt64(v_0.AuxInt)
4886 base := v_0.Args[0]
4887 mem := v_1
4888 if !(is32Bit(int64(off1) + off2)) {
4889 break
4890 }
4891 v.reset(OpRISCV64MOVBstorezero)
4892 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4893 v.Aux = symToAux(sym)
4894 v.AddArg2(base, mem)
4895 return true
4896 }
4897 return false
4898 }
4899 func rewriteValueRISCV64_OpRISCV64MOVDload(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(OpRISCV64MOVDload)
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(OpRISCV64MOVDload)
4942 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4943 v.Aux = symToAux(sym)
4944 v.AddArg2(base, mem)
4945 return true
4946 }
4947 return false
4948 }
4949 func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
4950 v_0 := v.Args[0]
4951
4952
4953 for {
4954 if v_0.Op != OpRISCV64MOVDconst {
4955 break
4956 }
4957 c := auxIntToInt64(v_0.AuxInt)
4958 v.reset(OpRISCV64MOVDconst)
4959 v.AuxInt = int64ToAuxInt(c)
4960 return true
4961 }
4962 return false
4963 }
4964 func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
4965 v_0 := v.Args[0]
4966
4967
4968
4969 for {
4970 x := v_0
4971 if !(x.Uses == 1) {
4972 break
4973 }
4974 v.reset(OpRISCV64MOVDnop)
4975 v.AddArg(x)
4976 return true
4977 }
4978 return false
4979 }
4980 func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
4981 v_2 := v.Args[2]
4982 v_1 := v.Args[1]
4983 v_0 := v.Args[0]
4984 b := v.Block
4985 config := b.Func.Config
4986
4987
4988
4989 for {
4990 off1 := auxIntToInt32(v.AuxInt)
4991 sym1 := auxToSym(v.Aux)
4992 if v_0.Op != OpRISCV64MOVaddr {
4993 break
4994 }
4995 off2 := auxIntToInt32(v_0.AuxInt)
4996 sym2 := auxToSym(v_0.Aux)
4997 base := v_0.Args[0]
4998 val := v_1
4999 mem := v_2
5000 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5001 break
5002 }
5003 v.reset(OpRISCV64MOVDstore)
5004 v.AuxInt = int32ToAuxInt(off1 + off2)
5005 v.Aux = symToAux(mergeSym(sym1, sym2))
5006 v.AddArg3(base, val, mem)
5007 return true
5008 }
5009
5010
5011
5012 for {
5013 off1 := auxIntToInt32(v.AuxInt)
5014 sym := auxToSym(v.Aux)
5015 if v_0.Op != OpRISCV64ADDI {
5016 break
5017 }
5018 off2 := auxIntToInt64(v_0.AuxInt)
5019 base := v_0.Args[0]
5020 val := v_1
5021 mem := v_2
5022 if !(is32Bit(int64(off1) + off2)) {
5023 break
5024 }
5025 v.reset(OpRISCV64MOVDstore)
5026 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5027 v.Aux = symToAux(sym)
5028 v.AddArg3(base, val, mem)
5029 return true
5030 }
5031
5032
5033 for {
5034 off := auxIntToInt32(v.AuxInt)
5035 sym := auxToSym(v.Aux)
5036 ptr := v_0
5037 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5038 break
5039 }
5040 mem := v_2
5041 v.reset(OpRISCV64MOVDstorezero)
5042 v.AuxInt = int32ToAuxInt(off)
5043 v.Aux = symToAux(sym)
5044 v.AddArg2(ptr, mem)
5045 return true
5046 }
5047 return false
5048 }
5049 func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool {
5050 v_1 := v.Args[1]
5051 v_0 := v.Args[0]
5052 b := v.Block
5053 config := b.Func.Config
5054
5055
5056
5057 for {
5058 off1 := auxIntToInt32(v.AuxInt)
5059 sym1 := auxToSym(v.Aux)
5060 if v_0.Op != OpRISCV64MOVaddr {
5061 break
5062 }
5063 off2 := auxIntToInt32(v_0.AuxInt)
5064 sym2 := auxToSym(v_0.Aux)
5065 base := v_0.Args[0]
5066 mem := v_1
5067 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5068 break
5069 }
5070 v.reset(OpRISCV64MOVDstorezero)
5071 v.AuxInt = int32ToAuxInt(off1 + off2)
5072 v.Aux = symToAux(mergeSym(sym1, sym2))
5073 v.AddArg2(base, mem)
5074 return true
5075 }
5076
5077
5078
5079 for {
5080 off1 := auxIntToInt32(v.AuxInt)
5081 sym := auxToSym(v.Aux)
5082 if v_0.Op != OpRISCV64ADDI {
5083 break
5084 }
5085 off2 := auxIntToInt64(v_0.AuxInt)
5086 base := v_0.Args[0]
5087 mem := v_1
5088 if !(is32Bit(int64(off1) + off2)) {
5089 break
5090 }
5091 v.reset(OpRISCV64MOVDstorezero)
5092 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5093 v.Aux = symToAux(sym)
5094 v.AddArg2(base, mem)
5095 return true
5096 }
5097 return false
5098 }
5099 func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
5100 v_1 := v.Args[1]
5101 v_0 := v.Args[0]
5102 b := v.Block
5103 config := b.Func.Config
5104
5105
5106
5107 for {
5108 off1 := auxIntToInt32(v.AuxInt)
5109 sym1 := auxToSym(v.Aux)
5110 if v_0.Op != OpRISCV64MOVaddr {
5111 break
5112 }
5113 off2 := auxIntToInt32(v_0.AuxInt)
5114 sym2 := auxToSym(v_0.Aux)
5115 base := v_0.Args[0]
5116 mem := v_1
5117 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5118 break
5119 }
5120 v.reset(OpRISCV64MOVHUload)
5121 v.AuxInt = int32ToAuxInt(off1 + off2)
5122 v.Aux = symToAux(mergeSym(sym1, sym2))
5123 v.AddArg2(base, mem)
5124 return true
5125 }
5126
5127
5128
5129 for {
5130 off1 := auxIntToInt32(v.AuxInt)
5131 sym := auxToSym(v.Aux)
5132 if v_0.Op != OpRISCV64ADDI {
5133 break
5134 }
5135 off2 := auxIntToInt64(v_0.AuxInt)
5136 base := v_0.Args[0]
5137 mem := v_1
5138 if !(is32Bit(int64(off1) + off2)) {
5139 break
5140 }
5141 v.reset(OpRISCV64MOVHUload)
5142 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5143 v.Aux = symToAux(sym)
5144 v.AddArg2(base, mem)
5145 return true
5146 }
5147 return false
5148 }
5149 func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
5150 v_0 := v.Args[0]
5151 b := v.Block
5152
5153
5154
5155 for {
5156 x := v_0
5157 if x.Op != OpRISCV64ANDI {
5158 break
5159 }
5160 c := auxIntToInt64(x.AuxInt)
5161 if !(c >= 0 && int64(uint16(c)) == c) {
5162 break
5163 }
5164 v.copyOf(x)
5165 return true
5166 }
5167
5168
5169
5170 for {
5171 if v_0.Op != OpRISCV64ANDI {
5172 break
5173 }
5174 c := auxIntToInt64(v_0.AuxInt)
5175 x := v_0.Args[0]
5176 if !(c < 0) {
5177 break
5178 }
5179 v.reset(OpRISCV64ANDI)
5180 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
5181 v.AddArg(x)
5182 return true
5183 }
5184
5185
5186 for {
5187 if v_0.Op != OpRISCV64MOVDconst {
5188 break
5189 }
5190 c := auxIntToInt64(v_0.AuxInt)
5191 v.reset(OpRISCV64MOVDconst)
5192 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
5193 return true
5194 }
5195
5196
5197 for {
5198 x := v_0
5199 if x.Op != OpRISCV64MOVBUload {
5200 break
5201 }
5202 v.reset(OpRISCV64MOVDreg)
5203 v.AddArg(x)
5204 return true
5205 }
5206
5207
5208 for {
5209 x := v_0
5210 if x.Op != OpRISCV64MOVHUload {
5211 break
5212 }
5213 v.reset(OpRISCV64MOVDreg)
5214 v.AddArg(x)
5215 return true
5216 }
5217
5218
5219 for {
5220 x := v_0
5221 if x.Op != OpRISCV64MOVBUreg {
5222 break
5223 }
5224 v.reset(OpRISCV64MOVDreg)
5225 v.AddArg(x)
5226 return true
5227 }
5228
5229
5230 for {
5231 x := v_0
5232 if x.Op != OpRISCV64MOVHUreg {
5233 break
5234 }
5235 v.reset(OpRISCV64MOVDreg)
5236 v.AddArg(x)
5237 return true
5238 }
5239
5240
5241
5242 for {
5243 t := v.Type
5244 x := v_0
5245 if x.Op != OpRISCV64MOVHload {
5246 break
5247 }
5248 off := auxIntToInt32(x.AuxInt)
5249 sym := auxToSym(x.Aux)
5250 mem := x.Args[1]
5251 ptr := x.Args[0]
5252 if !(x.Uses == 1 && clobber(x)) {
5253 break
5254 }
5255 b = x.Block
5256 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHUload, t)
5257 v.copyOf(v0)
5258 v0.AuxInt = int32ToAuxInt(off)
5259 v0.Aux = symToAux(sym)
5260 v0.AddArg2(ptr, mem)
5261 return true
5262 }
5263 return false
5264 }
5265 func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
5266 v_1 := v.Args[1]
5267 v_0 := v.Args[0]
5268 b := v.Block
5269 config := b.Func.Config
5270
5271
5272
5273 for {
5274 off1 := auxIntToInt32(v.AuxInt)
5275 sym1 := auxToSym(v.Aux)
5276 if v_0.Op != OpRISCV64MOVaddr {
5277 break
5278 }
5279 off2 := auxIntToInt32(v_0.AuxInt)
5280 sym2 := auxToSym(v_0.Aux)
5281 base := v_0.Args[0]
5282 mem := v_1
5283 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5284 break
5285 }
5286 v.reset(OpRISCV64MOVHload)
5287 v.AuxInt = int32ToAuxInt(off1 + off2)
5288 v.Aux = symToAux(mergeSym(sym1, sym2))
5289 v.AddArg2(base, mem)
5290 return true
5291 }
5292
5293
5294
5295 for {
5296 off1 := auxIntToInt32(v.AuxInt)
5297 sym := auxToSym(v.Aux)
5298 if v_0.Op != OpRISCV64ADDI {
5299 break
5300 }
5301 off2 := auxIntToInt64(v_0.AuxInt)
5302 base := v_0.Args[0]
5303 mem := v_1
5304 if !(is32Bit(int64(off1) + off2)) {
5305 break
5306 }
5307 v.reset(OpRISCV64MOVHload)
5308 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5309 v.Aux = symToAux(sym)
5310 v.AddArg2(base, mem)
5311 return true
5312 }
5313 return false
5314 }
5315 func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
5316 v_0 := v.Args[0]
5317 b := v.Block
5318
5319
5320
5321 for {
5322 x := v_0
5323 if x.Op != OpRISCV64ANDI {
5324 break
5325 }
5326 c := auxIntToInt64(x.AuxInt)
5327 if !(c >= 0 && int64(int16(c)) == c) {
5328 break
5329 }
5330 v.copyOf(x)
5331 return true
5332 }
5333
5334
5335 for {
5336 if v_0.Op != OpRISCV64MOVDconst {
5337 break
5338 }
5339 c := auxIntToInt64(v_0.AuxInt)
5340 v.reset(OpRISCV64MOVDconst)
5341 v.AuxInt = int64ToAuxInt(int64(int16(c)))
5342 return true
5343 }
5344
5345
5346 for {
5347 x := v_0
5348 if x.Op != OpRISCV64MOVBload {
5349 break
5350 }
5351 v.reset(OpRISCV64MOVDreg)
5352 v.AddArg(x)
5353 return true
5354 }
5355
5356
5357 for {
5358 x := v_0
5359 if x.Op != OpRISCV64MOVBUload {
5360 break
5361 }
5362 v.reset(OpRISCV64MOVDreg)
5363 v.AddArg(x)
5364 return true
5365 }
5366
5367
5368 for {
5369 x := v_0
5370 if x.Op != OpRISCV64MOVHload {
5371 break
5372 }
5373 v.reset(OpRISCV64MOVDreg)
5374 v.AddArg(x)
5375 return true
5376 }
5377
5378
5379 for {
5380 x := v_0
5381 if x.Op != OpRISCV64MOVBreg {
5382 break
5383 }
5384 v.reset(OpRISCV64MOVDreg)
5385 v.AddArg(x)
5386 return true
5387 }
5388
5389
5390 for {
5391 x := v_0
5392 if x.Op != OpRISCV64MOVBUreg {
5393 break
5394 }
5395 v.reset(OpRISCV64MOVDreg)
5396 v.AddArg(x)
5397 return true
5398 }
5399
5400
5401 for {
5402 x := v_0
5403 if x.Op != OpRISCV64MOVHreg {
5404 break
5405 }
5406 v.reset(OpRISCV64MOVDreg)
5407 v.AddArg(x)
5408 return true
5409 }
5410
5411
5412
5413 for {
5414 t := v.Type
5415 x := v_0
5416 if x.Op != OpRISCV64MOVHUload {
5417 break
5418 }
5419 off := auxIntToInt32(x.AuxInt)
5420 sym := auxToSym(x.Aux)
5421 mem := x.Args[1]
5422 ptr := x.Args[0]
5423 if !(x.Uses == 1 && clobber(x)) {
5424 break
5425 }
5426 b = x.Block
5427 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHload, t)
5428 v.copyOf(v0)
5429 v0.AuxInt = int32ToAuxInt(off)
5430 v0.Aux = symToAux(sym)
5431 v0.AddArg2(ptr, mem)
5432 return true
5433 }
5434 return false
5435 }
5436 func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
5437 v_2 := v.Args[2]
5438 v_1 := v.Args[1]
5439 v_0 := v.Args[0]
5440 b := v.Block
5441 config := b.Func.Config
5442
5443
5444
5445 for {
5446 off1 := auxIntToInt32(v.AuxInt)
5447 sym1 := auxToSym(v.Aux)
5448 if v_0.Op != OpRISCV64MOVaddr {
5449 break
5450 }
5451 off2 := auxIntToInt32(v_0.AuxInt)
5452 sym2 := auxToSym(v_0.Aux)
5453 base := v_0.Args[0]
5454 val := v_1
5455 mem := v_2
5456 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5457 break
5458 }
5459 v.reset(OpRISCV64MOVHstore)
5460 v.AuxInt = int32ToAuxInt(off1 + off2)
5461 v.Aux = symToAux(mergeSym(sym1, sym2))
5462 v.AddArg3(base, val, mem)
5463 return true
5464 }
5465
5466
5467
5468 for {
5469 off1 := auxIntToInt32(v.AuxInt)
5470 sym := auxToSym(v.Aux)
5471 if v_0.Op != OpRISCV64ADDI {
5472 break
5473 }
5474 off2 := auxIntToInt64(v_0.AuxInt)
5475 base := v_0.Args[0]
5476 val := v_1
5477 mem := v_2
5478 if !(is32Bit(int64(off1) + off2)) {
5479 break
5480 }
5481 v.reset(OpRISCV64MOVHstore)
5482 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5483 v.Aux = symToAux(sym)
5484 v.AddArg3(base, val, mem)
5485 return true
5486 }
5487
5488
5489 for {
5490 off := auxIntToInt32(v.AuxInt)
5491 sym := auxToSym(v.Aux)
5492 ptr := v_0
5493 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5494 break
5495 }
5496 mem := v_2
5497 v.reset(OpRISCV64MOVHstorezero)
5498 v.AuxInt = int32ToAuxInt(off)
5499 v.Aux = symToAux(sym)
5500 v.AddArg2(ptr, mem)
5501 return true
5502 }
5503
5504
5505 for {
5506 off := auxIntToInt32(v.AuxInt)
5507 sym := auxToSym(v.Aux)
5508 ptr := v_0
5509 if v_1.Op != OpRISCV64MOVHreg {
5510 break
5511 }
5512 x := v_1.Args[0]
5513 mem := v_2
5514 v.reset(OpRISCV64MOVHstore)
5515 v.AuxInt = int32ToAuxInt(off)
5516 v.Aux = symToAux(sym)
5517 v.AddArg3(ptr, x, mem)
5518 return true
5519 }
5520
5521
5522 for {
5523 off := auxIntToInt32(v.AuxInt)
5524 sym := auxToSym(v.Aux)
5525 ptr := v_0
5526 if v_1.Op != OpRISCV64MOVWreg {
5527 break
5528 }
5529 x := v_1.Args[0]
5530 mem := v_2
5531 v.reset(OpRISCV64MOVHstore)
5532 v.AuxInt = int32ToAuxInt(off)
5533 v.Aux = symToAux(sym)
5534 v.AddArg3(ptr, x, mem)
5535 return true
5536 }
5537
5538
5539 for {
5540 off := auxIntToInt32(v.AuxInt)
5541 sym := auxToSym(v.Aux)
5542 ptr := v_0
5543 if v_1.Op != OpRISCV64MOVHUreg {
5544 break
5545 }
5546 x := v_1.Args[0]
5547 mem := v_2
5548 v.reset(OpRISCV64MOVHstore)
5549 v.AuxInt = int32ToAuxInt(off)
5550 v.Aux = symToAux(sym)
5551 v.AddArg3(ptr, x, mem)
5552 return true
5553 }
5554
5555
5556 for {
5557 off := auxIntToInt32(v.AuxInt)
5558 sym := auxToSym(v.Aux)
5559 ptr := v_0
5560 if v_1.Op != OpRISCV64MOVWUreg {
5561 break
5562 }
5563 x := v_1.Args[0]
5564 mem := v_2
5565 v.reset(OpRISCV64MOVHstore)
5566 v.AuxInt = int32ToAuxInt(off)
5567 v.Aux = symToAux(sym)
5568 v.AddArg3(ptr, x, mem)
5569 return true
5570 }
5571 return false
5572 }
5573 func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool {
5574 v_1 := v.Args[1]
5575 v_0 := v.Args[0]
5576 b := v.Block
5577 config := b.Func.Config
5578
5579
5580
5581 for {
5582 off1 := auxIntToInt32(v.AuxInt)
5583 sym1 := auxToSym(v.Aux)
5584 if v_0.Op != OpRISCV64MOVaddr {
5585 break
5586 }
5587 off2 := auxIntToInt32(v_0.AuxInt)
5588 sym2 := auxToSym(v_0.Aux)
5589 base := v_0.Args[0]
5590 mem := v_1
5591 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5592 break
5593 }
5594 v.reset(OpRISCV64MOVHstorezero)
5595 v.AuxInt = int32ToAuxInt(off1 + off2)
5596 v.Aux = symToAux(mergeSym(sym1, sym2))
5597 v.AddArg2(base, mem)
5598 return true
5599 }
5600
5601
5602
5603 for {
5604 off1 := auxIntToInt32(v.AuxInt)
5605 sym := auxToSym(v.Aux)
5606 if v_0.Op != OpRISCV64ADDI {
5607 break
5608 }
5609 off2 := auxIntToInt64(v_0.AuxInt)
5610 base := v_0.Args[0]
5611 mem := v_1
5612 if !(is32Bit(int64(off1) + off2)) {
5613 break
5614 }
5615 v.reset(OpRISCV64MOVHstorezero)
5616 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5617 v.Aux = symToAux(sym)
5618 v.AddArg2(base, mem)
5619 return true
5620 }
5621 return false
5622 }
5623 func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
5624 v_1 := v.Args[1]
5625 v_0 := v.Args[0]
5626 b := v.Block
5627 config := b.Func.Config
5628
5629
5630
5631 for {
5632 off1 := auxIntToInt32(v.AuxInt)
5633 sym1 := auxToSym(v.Aux)
5634 if v_0.Op != OpRISCV64MOVaddr {
5635 break
5636 }
5637 off2 := auxIntToInt32(v_0.AuxInt)
5638 sym2 := auxToSym(v_0.Aux)
5639 base := v_0.Args[0]
5640 mem := v_1
5641 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5642 break
5643 }
5644 v.reset(OpRISCV64MOVWUload)
5645 v.AuxInt = int32ToAuxInt(off1 + off2)
5646 v.Aux = symToAux(mergeSym(sym1, sym2))
5647 v.AddArg2(base, mem)
5648 return true
5649 }
5650
5651
5652
5653 for {
5654 off1 := auxIntToInt32(v.AuxInt)
5655 sym := auxToSym(v.Aux)
5656 if v_0.Op != OpRISCV64ADDI {
5657 break
5658 }
5659 off2 := auxIntToInt64(v_0.AuxInt)
5660 base := v_0.Args[0]
5661 mem := v_1
5662 if !(is32Bit(int64(off1) + off2)) {
5663 break
5664 }
5665 v.reset(OpRISCV64MOVWUload)
5666 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5667 v.Aux = symToAux(sym)
5668 v.AddArg2(base, mem)
5669 return true
5670 }
5671 return false
5672 }
5673 func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
5674 v_0 := v.Args[0]
5675 b := v.Block
5676 typ := &b.Func.Config.Types
5677
5678
5679
5680 for {
5681 x := v_0
5682 if x.Op != OpRISCV64ANDI {
5683 break
5684 }
5685 c := auxIntToInt64(x.AuxInt)
5686 if !(c >= 0 && int64(uint32(c)) == c) {
5687 break
5688 }
5689 v.copyOf(x)
5690 return true
5691 }
5692
5693
5694
5695 for {
5696 if v_0.Op != OpRISCV64ANDI {
5697 break
5698 }
5699 c := auxIntToInt64(v_0.AuxInt)
5700 x := v_0.Args[0]
5701 if !(c < 0) {
5702 break
5703 }
5704 v.reset(OpRISCV64AND)
5705 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5706 v0.AuxInt = int64ToAuxInt(int64(uint32(c)))
5707 v.AddArg2(v0, x)
5708 return true
5709 }
5710
5711
5712 for {
5713 if v_0.Op != OpRISCV64MOVDconst {
5714 break
5715 }
5716 c := auxIntToInt64(v_0.AuxInt)
5717 v.reset(OpRISCV64MOVDconst)
5718 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
5719 return true
5720 }
5721
5722
5723 for {
5724 x := v_0
5725 if x.Op != OpRISCV64MOVBUload {
5726 break
5727 }
5728 v.reset(OpRISCV64MOVDreg)
5729 v.AddArg(x)
5730 return true
5731 }
5732
5733
5734 for {
5735 x := v_0
5736 if x.Op != OpRISCV64MOVHUload {
5737 break
5738 }
5739 v.reset(OpRISCV64MOVDreg)
5740 v.AddArg(x)
5741 return true
5742 }
5743
5744
5745 for {
5746 x := v_0
5747 if x.Op != OpRISCV64MOVWUload {
5748 break
5749 }
5750 v.reset(OpRISCV64MOVDreg)
5751 v.AddArg(x)
5752 return true
5753 }
5754
5755
5756 for {
5757 x := v_0
5758 if x.Op != OpRISCV64MOVBUreg {
5759 break
5760 }
5761 v.reset(OpRISCV64MOVDreg)
5762 v.AddArg(x)
5763 return true
5764 }
5765
5766
5767 for {
5768 x := v_0
5769 if x.Op != OpRISCV64MOVHUreg {
5770 break
5771 }
5772 v.reset(OpRISCV64MOVDreg)
5773 v.AddArg(x)
5774 return true
5775 }
5776
5777
5778 for {
5779 x := v_0
5780 if x.Op != OpRISCV64MOVWUreg {
5781 break
5782 }
5783 v.reset(OpRISCV64MOVDreg)
5784 v.AddArg(x)
5785 return true
5786 }
5787
5788
5789
5790 for {
5791 t := v.Type
5792 x := v_0
5793 if x.Op != OpRISCV64MOVWload {
5794 break
5795 }
5796 off := auxIntToInt32(x.AuxInt)
5797 sym := auxToSym(x.Aux)
5798 mem := x.Args[1]
5799 ptr := x.Args[0]
5800 if !(x.Uses == 1 && clobber(x)) {
5801 break
5802 }
5803 b = x.Block
5804 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWUload, t)
5805 v.copyOf(v0)
5806 v0.AuxInt = int32ToAuxInt(off)
5807 v0.Aux = symToAux(sym)
5808 v0.AddArg2(ptr, mem)
5809 return true
5810 }
5811 return false
5812 }
5813 func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
5814 v_1 := v.Args[1]
5815 v_0 := v.Args[0]
5816 b := v.Block
5817 config := b.Func.Config
5818
5819
5820
5821 for {
5822 off1 := auxIntToInt32(v.AuxInt)
5823 sym1 := auxToSym(v.Aux)
5824 if v_0.Op != OpRISCV64MOVaddr {
5825 break
5826 }
5827 off2 := auxIntToInt32(v_0.AuxInt)
5828 sym2 := auxToSym(v_0.Aux)
5829 base := v_0.Args[0]
5830 mem := v_1
5831 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
5832 break
5833 }
5834 v.reset(OpRISCV64MOVWload)
5835 v.AuxInt = int32ToAuxInt(off1 + off2)
5836 v.Aux = symToAux(mergeSym(sym1, sym2))
5837 v.AddArg2(base, mem)
5838 return true
5839 }
5840
5841
5842
5843 for {
5844 off1 := auxIntToInt32(v.AuxInt)
5845 sym := auxToSym(v.Aux)
5846 if v_0.Op != OpRISCV64ADDI {
5847 break
5848 }
5849 off2 := auxIntToInt64(v_0.AuxInt)
5850 base := v_0.Args[0]
5851 mem := v_1
5852 if !(is32Bit(int64(off1) + off2)) {
5853 break
5854 }
5855 v.reset(OpRISCV64MOVWload)
5856 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5857 v.Aux = symToAux(sym)
5858 v.AddArg2(base, mem)
5859 return true
5860 }
5861 return false
5862 }
5863 func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
5864 v_0 := v.Args[0]
5865 b := v.Block
5866
5867
5868
5869 for {
5870 x := v_0
5871 if x.Op != OpRISCV64ANDI {
5872 break
5873 }
5874 c := auxIntToInt64(x.AuxInt)
5875 if !(c >= 0 && int64(int32(c)) == c) {
5876 break
5877 }
5878 v.copyOf(x)
5879 return true
5880 }
5881
5882
5883 for {
5884 if v_0.Op != OpRISCV64NEG {
5885 break
5886 }
5887 x := v_0.Args[0]
5888 v.reset(OpRISCV64NEGW)
5889 v.AddArg(x)
5890 return true
5891 }
5892
5893
5894 for {
5895 if v_0.Op != OpRISCV64MOVDconst {
5896 break
5897 }
5898 c := auxIntToInt64(v_0.AuxInt)
5899 v.reset(OpRISCV64MOVDconst)
5900 v.AuxInt = int64ToAuxInt(int64(int32(c)))
5901 return true
5902 }
5903
5904
5905 for {
5906 x := v_0
5907 if x.Op != OpRISCV64MOVBload {
5908 break
5909 }
5910 v.reset(OpRISCV64MOVDreg)
5911 v.AddArg(x)
5912 return true
5913 }
5914
5915
5916 for {
5917 x := v_0
5918 if x.Op != OpRISCV64MOVBUload {
5919 break
5920 }
5921 v.reset(OpRISCV64MOVDreg)
5922 v.AddArg(x)
5923 return true
5924 }
5925
5926
5927 for {
5928 x := v_0
5929 if x.Op != OpRISCV64MOVHload {
5930 break
5931 }
5932 v.reset(OpRISCV64MOVDreg)
5933 v.AddArg(x)
5934 return true
5935 }
5936
5937
5938 for {
5939 x := v_0
5940 if x.Op != OpRISCV64MOVHUload {
5941 break
5942 }
5943 v.reset(OpRISCV64MOVDreg)
5944 v.AddArg(x)
5945 return true
5946 }
5947
5948
5949 for {
5950 x := v_0
5951 if x.Op != OpRISCV64MOVWload {
5952 break
5953 }
5954 v.reset(OpRISCV64MOVDreg)
5955 v.AddArg(x)
5956 return true
5957 }
5958
5959
5960 for {
5961 x := v_0
5962 if x.Op != OpRISCV64ADDIW {
5963 break
5964 }
5965 v.reset(OpRISCV64MOVDreg)
5966 v.AddArg(x)
5967 return true
5968 }
5969
5970
5971 for {
5972 x := v_0
5973 if x.Op != OpRISCV64SUBW {
5974 break
5975 }
5976 v.reset(OpRISCV64MOVDreg)
5977 v.AddArg(x)
5978 return true
5979 }
5980
5981
5982 for {
5983 x := v_0
5984 if x.Op != OpRISCV64NEGW {
5985 break
5986 }
5987 v.reset(OpRISCV64MOVDreg)
5988 v.AddArg(x)
5989 return true
5990 }
5991
5992
5993 for {
5994 x := v_0
5995 if x.Op != OpRISCV64MULW {
5996 break
5997 }
5998 v.reset(OpRISCV64MOVDreg)
5999 v.AddArg(x)
6000 return true
6001 }
6002
6003
6004 for {
6005 x := v_0
6006 if x.Op != OpRISCV64DIVW {
6007 break
6008 }
6009 v.reset(OpRISCV64MOVDreg)
6010 v.AddArg(x)
6011 return true
6012 }
6013
6014
6015 for {
6016 x := v_0
6017 if x.Op != OpRISCV64DIVUW {
6018 break
6019 }
6020 v.reset(OpRISCV64MOVDreg)
6021 v.AddArg(x)
6022 return true
6023 }
6024
6025
6026 for {
6027 x := v_0
6028 if x.Op != OpRISCV64REMW {
6029 break
6030 }
6031 v.reset(OpRISCV64MOVDreg)
6032 v.AddArg(x)
6033 return true
6034 }
6035
6036
6037 for {
6038 x := v_0
6039 if x.Op != OpRISCV64REMUW {
6040 break
6041 }
6042 v.reset(OpRISCV64MOVDreg)
6043 v.AddArg(x)
6044 return true
6045 }
6046
6047
6048 for {
6049 x := v_0
6050 if x.Op != OpRISCV64ROLW {
6051 break
6052 }
6053 v.reset(OpRISCV64MOVDreg)
6054 v.AddArg(x)
6055 return true
6056 }
6057
6058
6059 for {
6060 x := v_0
6061 if x.Op != OpRISCV64RORW {
6062 break
6063 }
6064 v.reset(OpRISCV64MOVDreg)
6065 v.AddArg(x)
6066 return true
6067 }
6068
6069
6070 for {
6071 x := v_0
6072 if x.Op != OpRISCV64RORIW {
6073 break
6074 }
6075 v.reset(OpRISCV64MOVDreg)
6076 v.AddArg(x)
6077 return true
6078 }
6079
6080
6081 for {
6082 x := v_0
6083 if x.Op != OpRISCV64MOVBreg {
6084 break
6085 }
6086 v.reset(OpRISCV64MOVDreg)
6087 v.AddArg(x)
6088 return true
6089 }
6090
6091
6092 for {
6093 x := v_0
6094 if x.Op != OpRISCV64MOVBUreg {
6095 break
6096 }
6097 v.reset(OpRISCV64MOVDreg)
6098 v.AddArg(x)
6099 return true
6100 }
6101
6102
6103 for {
6104 x := v_0
6105 if x.Op != OpRISCV64MOVHreg {
6106 break
6107 }
6108 v.reset(OpRISCV64MOVDreg)
6109 v.AddArg(x)
6110 return true
6111 }
6112
6113
6114 for {
6115 x := v_0
6116 if x.Op != OpRISCV64MOVWreg {
6117 break
6118 }
6119 v.reset(OpRISCV64MOVDreg)
6120 v.AddArg(x)
6121 return true
6122 }
6123
6124
6125
6126 for {
6127 t := v.Type
6128 x := v_0
6129 if x.Op != OpRISCV64MOVWUload {
6130 break
6131 }
6132 off := auxIntToInt32(x.AuxInt)
6133 sym := auxToSym(x.Aux)
6134 mem := x.Args[1]
6135 ptr := x.Args[0]
6136 if !(x.Uses == 1 && clobber(x)) {
6137 break
6138 }
6139 b = x.Block
6140 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWload, t)
6141 v.copyOf(v0)
6142 v0.AuxInt = int32ToAuxInt(off)
6143 v0.Aux = symToAux(sym)
6144 v0.AddArg2(ptr, mem)
6145 return true
6146 }
6147 return false
6148 }
6149 func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
6150 v_2 := v.Args[2]
6151 v_1 := v.Args[1]
6152 v_0 := v.Args[0]
6153 b := v.Block
6154 config := b.Func.Config
6155
6156
6157
6158 for {
6159 off1 := auxIntToInt32(v.AuxInt)
6160 sym1 := auxToSym(v.Aux)
6161 if v_0.Op != OpRISCV64MOVaddr {
6162 break
6163 }
6164 off2 := auxIntToInt32(v_0.AuxInt)
6165 sym2 := auxToSym(v_0.Aux)
6166 base := v_0.Args[0]
6167 val := v_1
6168 mem := v_2
6169 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6170 break
6171 }
6172 v.reset(OpRISCV64MOVWstore)
6173 v.AuxInt = int32ToAuxInt(off1 + off2)
6174 v.Aux = symToAux(mergeSym(sym1, sym2))
6175 v.AddArg3(base, val, mem)
6176 return true
6177 }
6178
6179
6180
6181 for {
6182 off1 := auxIntToInt32(v.AuxInt)
6183 sym := auxToSym(v.Aux)
6184 if v_0.Op != OpRISCV64ADDI {
6185 break
6186 }
6187 off2 := auxIntToInt64(v_0.AuxInt)
6188 base := v_0.Args[0]
6189 val := v_1
6190 mem := v_2
6191 if !(is32Bit(int64(off1) + off2)) {
6192 break
6193 }
6194 v.reset(OpRISCV64MOVWstore)
6195 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6196 v.Aux = symToAux(sym)
6197 v.AddArg3(base, val, mem)
6198 return true
6199 }
6200
6201
6202 for {
6203 off := auxIntToInt32(v.AuxInt)
6204 sym := auxToSym(v.Aux)
6205 ptr := v_0
6206 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6207 break
6208 }
6209 mem := v_2
6210 v.reset(OpRISCV64MOVWstorezero)
6211 v.AuxInt = int32ToAuxInt(off)
6212 v.Aux = symToAux(sym)
6213 v.AddArg2(ptr, mem)
6214 return true
6215 }
6216
6217
6218 for {
6219 off := auxIntToInt32(v.AuxInt)
6220 sym := auxToSym(v.Aux)
6221 ptr := v_0
6222 if v_1.Op != OpRISCV64MOVWreg {
6223 break
6224 }
6225 x := v_1.Args[0]
6226 mem := v_2
6227 v.reset(OpRISCV64MOVWstore)
6228 v.AuxInt = int32ToAuxInt(off)
6229 v.Aux = symToAux(sym)
6230 v.AddArg3(ptr, x, mem)
6231 return true
6232 }
6233
6234
6235 for {
6236 off := auxIntToInt32(v.AuxInt)
6237 sym := auxToSym(v.Aux)
6238 ptr := v_0
6239 if v_1.Op != OpRISCV64MOVWUreg {
6240 break
6241 }
6242 x := v_1.Args[0]
6243 mem := v_2
6244 v.reset(OpRISCV64MOVWstore)
6245 v.AuxInt = int32ToAuxInt(off)
6246 v.Aux = symToAux(sym)
6247 v.AddArg3(ptr, x, mem)
6248 return true
6249 }
6250 return false
6251 }
6252 func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
6253 v_1 := v.Args[1]
6254 v_0 := v.Args[0]
6255 b := v.Block
6256 config := b.Func.Config
6257
6258
6259
6260 for {
6261 off1 := auxIntToInt32(v.AuxInt)
6262 sym1 := auxToSym(v.Aux)
6263 if v_0.Op != OpRISCV64MOVaddr {
6264 break
6265 }
6266 off2 := auxIntToInt32(v_0.AuxInt)
6267 sym2 := auxToSym(v_0.Aux)
6268 base := v_0.Args[0]
6269 mem := v_1
6270 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2)) && (base.Op != OpSB || !config.ctxt.Flag_dynlink)) {
6271 break
6272 }
6273 v.reset(OpRISCV64MOVWstorezero)
6274 v.AuxInt = int32ToAuxInt(off1 + off2)
6275 v.Aux = symToAux(mergeSym(sym1, sym2))
6276 v.AddArg2(base, mem)
6277 return true
6278 }
6279
6280
6281
6282 for {
6283 off1 := auxIntToInt32(v.AuxInt)
6284 sym := auxToSym(v.Aux)
6285 if v_0.Op != OpRISCV64ADDI {
6286 break
6287 }
6288 off2 := auxIntToInt64(v_0.AuxInt)
6289 base := v_0.Args[0]
6290 mem := v_1
6291 if !(is32Bit(int64(off1) + off2)) {
6292 break
6293 }
6294 v.reset(OpRISCV64MOVWstorezero)
6295 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
6296 v.Aux = symToAux(sym)
6297 v.AddArg2(base, mem)
6298 return true
6299 }
6300 return false
6301 }
6302 func rewriteValueRISCV64_OpRISCV64NEG(v *Value) bool {
6303 v_0 := v.Args[0]
6304 b := v.Block
6305
6306
6307 for {
6308 if v_0.Op != OpRISCV64SUB {
6309 break
6310 }
6311 y := v_0.Args[1]
6312 x := v_0.Args[0]
6313 v.reset(OpRISCV64SUB)
6314 v.AddArg2(y, x)
6315 return true
6316 }
6317
6318
6319
6320 for {
6321 t := v.Type
6322 s := v_0
6323 if s.Op != OpRISCV64ADDI {
6324 break
6325 }
6326 val := auxIntToInt64(s.AuxInt)
6327 s_0 := s.Args[0]
6328 if s_0.Op != OpRISCV64SUB {
6329 break
6330 }
6331 y := s_0.Args[1]
6332 x := s_0.Args[0]
6333 if !(s.Uses == 1 && is32Bit(-val)) {
6334 break
6335 }
6336 v.reset(OpRISCV64ADDI)
6337 v.AuxInt = int64ToAuxInt(-val)
6338 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, t)
6339 v0.AddArg2(y, x)
6340 v.AddArg(v0)
6341 return true
6342 }
6343
6344
6345 for {
6346 if v_0.Op != OpRISCV64NEG {
6347 break
6348 }
6349 x := v_0.Args[0]
6350 v.copyOf(x)
6351 return true
6352 }
6353
6354
6355
6356 for {
6357 s := v_0
6358 if s.Op != OpRISCV64ADDI {
6359 break
6360 }
6361 val := auxIntToInt64(s.AuxInt)
6362 s_0 := s.Args[0]
6363 if s_0.Op != OpRISCV64NEG {
6364 break
6365 }
6366 x := s_0.Args[0]
6367 if !(s.Uses == 1 && is32Bit(-val)) {
6368 break
6369 }
6370 v.reset(OpRISCV64ADDI)
6371 v.AuxInt = int64ToAuxInt(-val)
6372 v.AddArg(x)
6373 return true
6374 }
6375
6376
6377 for {
6378 if v_0.Op != OpRISCV64MOVDconst {
6379 break
6380 }
6381 x := auxIntToInt64(v_0.AuxInt)
6382 v.reset(OpRISCV64MOVDconst)
6383 v.AuxInt = int64ToAuxInt(-x)
6384 return true
6385 }
6386 return false
6387 }
6388 func rewriteValueRISCV64_OpRISCV64NEGW(v *Value) bool {
6389 v_0 := v.Args[0]
6390
6391
6392 for {
6393 if v_0.Op != OpRISCV64MOVDconst {
6394 break
6395 }
6396 x := auxIntToInt64(v_0.AuxInt)
6397 v.reset(OpRISCV64MOVDconst)
6398 v.AuxInt = int64ToAuxInt(int64(int32(-x)))
6399 return true
6400 }
6401 return false
6402 }
6403 func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
6404 v_1 := v.Args[1]
6405 v_0 := v.Args[0]
6406
6407
6408
6409 for {
6410 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
6411 if v_0.Op != OpRISCV64MOVDconst {
6412 continue
6413 }
6414 val := auxIntToInt64(v_0.AuxInt)
6415 x := v_1
6416 if !(is32Bit(val)) {
6417 continue
6418 }
6419 v.reset(OpRISCV64ORI)
6420 v.AuxInt = int64ToAuxInt(val)
6421 v.AddArg(x)
6422 return true
6423 }
6424 break
6425 }
6426
6427
6428 for {
6429 x := v_0
6430 if x != v_1 {
6431 break
6432 }
6433 v.copyOf(x)
6434 return true
6435 }
6436 return false
6437 }
6438 func rewriteValueRISCV64_OpRISCV64ORI(v *Value) bool {
6439 v_0 := v.Args[0]
6440
6441
6442 for {
6443 if auxIntToInt64(v.AuxInt) != 0 {
6444 break
6445 }
6446 x := v_0
6447 v.copyOf(x)
6448 return true
6449 }
6450
6451
6452 for {
6453 if auxIntToInt64(v.AuxInt) != -1 {
6454 break
6455 }
6456 v.reset(OpRISCV64MOVDconst)
6457 v.AuxInt = int64ToAuxInt(-1)
6458 return true
6459 }
6460
6461
6462 for {
6463 x := auxIntToInt64(v.AuxInt)
6464 if v_0.Op != OpRISCV64MOVDconst {
6465 break
6466 }
6467 y := auxIntToInt64(v_0.AuxInt)
6468 v.reset(OpRISCV64MOVDconst)
6469 v.AuxInt = int64ToAuxInt(x | y)
6470 return true
6471 }
6472
6473
6474 for {
6475 x := auxIntToInt64(v.AuxInt)
6476 if v_0.Op != OpRISCV64ORI {
6477 break
6478 }
6479 y := auxIntToInt64(v_0.AuxInt)
6480 z := v_0.Args[0]
6481 v.reset(OpRISCV64ORI)
6482 v.AuxInt = int64ToAuxInt(x | y)
6483 v.AddArg(z)
6484 return true
6485 }
6486 return false
6487 }
6488 func rewriteValueRISCV64_OpRISCV64ORN(v *Value) bool {
6489 v_1 := v.Args[1]
6490 v_0 := v.Args[0]
6491
6492
6493 for {
6494 x := v_0
6495 if x != v_1 {
6496 break
6497 }
6498 v.reset(OpRISCV64MOVDconst)
6499 v.AuxInt = int64ToAuxInt(-1)
6500 return true
6501 }
6502 return false
6503 }
6504 func rewriteValueRISCV64_OpRISCV64ROL(v *Value) bool {
6505 v_1 := v.Args[1]
6506 v_0 := v.Args[0]
6507
6508
6509 for {
6510 x := v_0
6511 if v_1.Op != OpRISCV64MOVDconst {
6512 break
6513 }
6514 val := auxIntToInt64(v_1.AuxInt)
6515 v.reset(OpRISCV64RORI)
6516 v.AuxInt = int64ToAuxInt(int64(int8(-val) & 63))
6517 v.AddArg(x)
6518 return true
6519 }
6520
6521
6522 for {
6523 x := v_0
6524 if v_1.Op != OpRISCV64NEG {
6525 break
6526 }
6527 y := v_1.Args[0]
6528 v.reset(OpRISCV64ROR)
6529 v.AddArg2(x, y)
6530 return true
6531 }
6532 return false
6533 }
6534 func rewriteValueRISCV64_OpRISCV64ROLW(v *Value) bool {
6535 v_1 := v.Args[1]
6536 v_0 := v.Args[0]
6537
6538
6539 for {
6540 x := v_0
6541 if v_1.Op != OpRISCV64MOVDconst {
6542 break
6543 }
6544 val := auxIntToInt64(v_1.AuxInt)
6545 v.reset(OpRISCV64RORIW)
6546 v.AuxInt = int64ToAuxInt(int64(int8(-val) & 31))
6547 v.AddArg(x)
6548 return true
6549 }
6550
6551
6552 for {
6553 x := v_0
6554 if v_1.Op != OpRISCV64NEG {
6555 break
6556 }
6557 y := v_1.Args[0]
6558 v.reset(OpRISCV64RORW)
6559 v.AddArg2(x, y)
6560 return true
6561 }
6562 return false
6563 }
6564 func rewriteValueRISCV64_OpRISCV64ROR(v *Value) bool {
6565 v_1 := v.Args[1]
6566 v_0 := v.Args[0]
6567
6568
6569 for {
6570 x := v_0
6571 if v_1.Op != OpRISCV64MOVDconst {
6572 break
6573 }
6574 val := auxIntToInt64(v_1.AuxInt)
6575 v.reset(OpRISCV64RORI)
6576 v.AuxInt = int64ToAuxInt(int64(val & 63))
6577 v.AddArg(x)
6578 return true
6579 }
6580 return false
6581 }
6582 func rewriteValueRISCV64_OpRISCV64RORW(v *Value) bool {
6583 v_1 := v.Args[1]
6584 v_0 := v.Args[0]
6585
6586
6587 for {
6588 x := v_0
6589 if v_1.Op != OpRISCV64MOVDconst {
6590 break
6591 }
6592 val := auxIntToInt64(v_1.AuxInt)
6593 v.reset(OpRISCV64RORIW)
6594 v.AuxInt = int64ToAuxInt(int64(val & 31))
6595 v.AddArg(x)
6596 return true
6597 }
6598 return false
6599 }
6600 func rewriteValueRISCV64_OpRISCV64SEQZ(v *Value) bool {
6601 v_0 := v.Args[0]
6602
6603
6604 for {
6605 if v_0.Op != OpRISCV64NEG {
6606 break
6607 }
6608 x := v_0.Args[0]
6609 v.reset(OpRISCV64SEQZ)
6610 v.AddArg(x)
6611 return true
6612 }
6613
6614
6615 for {
6616 if v_0.Op != OpRISCV64SEQZ {
6617 break
6618 }
6619 x := v_0.Args[0]
6620 v.reset(OpRISCV64SNEZ)
6621 v.AddArg(x)
6622 return true
6623 }
6624
6625
6626 for {
6627 if v_0.Op != OpRISCV64SNEZ {
6628 break
6629 }
6630 x := v_0.Args[0]
6631 v.reset(OpRISCV64SEQZ)
6632 v.AddArg(x)
6633 return true
6634 }
6635 return false
6636 }
6637 func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
6638 v_1 := v.Args[1]
6639 v_0 := v.Args[0]
6640
6641
6642 for {
6643 x := v_0
6644 if v_1.Op != OpRISCV64MOVDconst {
6645 break
6646 }
6647 val := auxIntToInt64(v_1.AuxInt)
6648 v.reset(OpRISCV64SLLI)
6649 v.AuxInt = int64ToAuxInt(int64(val & 63))
6650 v.AddArg(x)
6651 return true
6652 }
6653 return false
6654 }
6655 func rewriteValueRISCV64_OpRISCV64SLLI(v *Value) bool {
6656 v_0 := v.Args[0]
6657
6658
6659
6660 for {
6661 x := auxIntToInt64(v.AuxInt)
6662 if v_0.Op != OpRISCV64MOVDconst {
6663 break
6664 }
6665 y := auxIntToInt64(v_0.AuxInt)
6666 if !(is32Bit(y << uint32(x))) {
6667 break
6668 }
6669 v.reset(OpRISCV64MOVDconst)
6670 v.AuxInt = int64ToAuxInt(y << uint32(x))
6671 return true
6672 }
6673 return false
6674 }
6675 func rewriteValueRISCV64_OpRISCV64SLLW(v *Value) bool {
6676 v_1 := v.Args[1]
6677 v_0 := v.Args[0]
6678
6679
6680 for {
6681 x := v_0
6682 if v_1.Op != OpRISCV64MOVDconst {
6683 break
6684 }
6685 val := auxIntToInt64(v_1.AuxInt)
6686 v.reset(OpRISCV64SLLIW)
6687 v.AuxInt = int64ToAuxInt(int64(val & 31))
6688 v.AddArg(x)
6689 return true
6690 }
6691 return false
6692 }
6693 func rewriteValueRISCV64_OpRISCV64SLT(v *Value) bool {
6694 v_1 := v.Args[1]
6695 v_0 := v.Args[0]
6696
6697
6698
6699 for {
6700 x := v_0
6701 if v_1.Op != OpRISCV64MOVDconst {
6702 break
6703 }
6704 val := auxIntToInt64(v_1.AuxInt)
6705 if !(val >= -2048 && val <= 2047) {
6706 break
6707 }
6708 v.reset(OpRISCV64SLTI)
6709 v.AuxInt = int64ToAuxInt(val)
6710 v.AddArg(x)
6711 return true
6712 }
6713
6714
6715 for {
6716 x := v_0
6717 if x != v_1 {
6718 break
6719 }
6720 v.reset(OpRISCV64MOVDconst)
6721 v.AuxInt = int64ToAuxInt(0)
6722 return true
6723 }
6724 return false
6725 }
6726 func rewriteValueRISCV64_OpRISCV64SLTI(v *Value) bool {
6727 v_0 := v.Args[0]
6728
6729
6730 for {
6731 x := auxIntToInt64(v.AuxInt)
6732 if v_0.Op != OpRISCV64MOVDconst {
6733 break
6734 }
6735 y := auxIntToInt64(v_0.AuxInt)
6736 v.reset(OpRISCV64MOVDconst)
6737 v.AuxInt = int64ToAuxInt(b2i(int64(y) < int64(x)))
6738 return true
6739 }
6740
6741
6742
6743 for {
6744 x := auxIntToInt64(v.AuxInt)
6745 if v_0.Op != OpRISCV64ANDI {
6746 break
6747 }
6748 y := auxIntToInt64(v_0.AuxInt)
6749 if !(y >= 0 && int64(y) < int64(x)) {
6750 break
6751 }
6752 v.reset(OpRISCV64MOVDconst)
6753 v.AuxInt = int64ToAuxInt(1)
6754 return true
6755 }
6756
6757
6758
6759 for {
6760 x := auxIntToInt64(v.AuxInt)
6761 if v_0.Op != OpRISCV64ORI {
6762 break
6763 }
6764 y := auxIntToInt64(v_0.AuxInt)
6765 if !(y >= 0 && int64(y) >= int64(x)) {
6766 break
6767 }
6768 v.reset(OpRISCV64MOVDconst)
6769 v.AuxInt = int64ToAuxInt(0)
6770 return true
6771 }
6772 return false
6773 }
6774 func rewriteValueRISCV64_OpRISCV64SLTIU(v *Value) bool {
6775 v_0 := v.Args[0]
6776
6777
6778 for {
6779 x := auxIntToInt64(v.AuxInt)
6780 if v_0.Op != OpRISCV64MOVDconst {
6781 break
6782 }
6783 y := auxIntToInt64(v_0.AuxInt)
6784 v.reset(OpRISCV64MOVDconst)
6785 v.AuxInt = int64ToAuxInt(b2i(uint64(y) < uint64(x)))
6786 return true
6787 }
6788
6789
6790
6791 for {
6792 x := auxIntToInt64(v.AuxInt)
6793 if v_0.Op != OpRISCV64ANDI {
6794 break
6795 }
6796 y := auxIntToInt64(v_0.AuxInt)
6797 if !(y >= 0 && uint64(y) < uint64(x)) {
6798 break
6799 }
6800 v.reset(OpRISCV64MOVDconst)
6801 v.AuxInt = int64ToAuxInt(1)
6802 return true
6803 }
6804
6805
6806
6807 for {
6808 x := auxIntToInt64(v.AuxInt)
6809 if v_0.Op != OpRISCV64ORI {
6810 break
6811 }
6812 y := auxIntToInt64(v_0.AuxInt)
6813 if !(y >= 0 && uint64(y) >= uint64(x)) {
6814 break
6815 }
6816 v.reset(OpRISCV64MOVDconst)
6817 v.AuxInt = int64ToAuxInt(0)
6818 return true
6819 }
6820 return false
6821 }
6822 func rewriteValueRISCV64_OpRISCV64SLTU(v *Value) bool {
6823 v_1 := v.Args[1]
6824 v_0 := v.Args[0]
6825
6826
6827
6828 for {
6829 x := v_0
6830 if v_1.Op != OpRISCV64MOVDconst {
6831 break
6832 }
6833 val := auxIntToInt64(v_1.AuxInt)
6834 if !(val >= -2048 && val <= 2047) {
6835 break
6836 }
6837 v.reset(OpRISCV64SLTIU)
6838 v.AuxInt = int64ToAuxInt(val)
6839 v.AddArg(x)
6840 return true
6841 }
6842
6843
6844 for {
6845 x := v_0
6846 if x != v_1 {
6847 break
6848 }
6849 v.reset(OpRISCV64MOVDconst)
6850 v.AuxInt = int64ToAuxInt(0)
6851 return true
6852 }
6853 return false
6854 }
6855 func rewriteValueRISCV64_OpRISCV64SNEZ(v *Value) bool {
6856 v_0 := v.Args[0]
6857
6858
6859 for {
6860 if v_0.Op != OpRISCV64NEG {
6861 break
6862 }
6863 x := v_0.Args[0]
6864 v.reset(OpRISCV64SNEZ)
6865 v.AddArg(x)
6866 return true
6867 }
6868
6869
6870 for {
6871 if v_0.Op != OpRISCV64SEQZ {
6872 break
6873 }
6874 x := v_0.Args[0]
6875 v.reset(OpRISCV64SEQZ)
6876 v.AddArg(x)
6877 return true
6878 }
6879
6880
6881 for {
6882 if v_0.Op != OpRISCV64SNEZ {
6883 break
6884 }
6885 x := v_0.Args[0]
6886 v.reset(OpRISCV64SNEZ)
6887 v.AddArg(x)
6888 return true
6889 }
6890 return false
6891 }
6892 func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
6893 v_1 := v.Args[1]
6894 v_0 := v.Args[0]
6895
6896
6897 for {
6898 x := v_0
6899 if v_1.Op != OpRISCV64MOVDconst {
6900 break
6901 }
6902 val := auxIntToInt64(v_1.AuxInt)
6903 v.reset(OpRISCV64SRAI)
6904 v.AuxInt = int64ToAuxInt(int64(val & 63))
6905 v.AddArg(x)
6906 return true
6907 }
6908 return false
6909 }
6910 func rewriteValueRISCV64_OpRISCV64SRAI(v *Value) bool {
6911 v_0 := v.Args[0]
6912 b := v.Block
6913
6914
6915
6916 for {
6917 t := v.Type
6918 x := auxIntToInt64(v.AuxInt)
6919 if v_0.Op != OpRISCV64MOVWreg {
6920 break
6921 }
6922 y := v_0.Args[0]
6923 if !(x >= 0 && x <= 31) {
6924 break
6925 }
6926 v.reset(OpRISCV64SRAIW)
6927 v.Type = t
6928 v.AuxInt = int64ToAuxInt(int64(x))
6929 v.AddArg(y)
6930 return true
6931 }
6932
6933
6934
6935 for {
6936 t := v.Type
6937 x := auxIntToInt64(v.AuxInt)
6938 if v_0.Op != OpRISCV64MOVBreg {
6939 break
6940 }
6941 y := v_0.Args[0]
6942 if !(x >= 8) {
6943 break
6944 }
6945 v.reset(OpRISCV64SRAI)
6946 v.AuxInt = int64ToAuxInt(63)
6947 v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
6948 v0.AuxInt = int64ToAuxInt(56)
6949 v0.AddArg(y)
6950 v.AddArg(v0)
6951 return true
6952 }
6953
6954
6955
6956 for {
6957 t := v.Type
6958 x := auxIntToInt64(v.AuxInt)
6959 if v_0.Op != OpRISCV64MOVHreg {
6960 break
6961 }
6962 y := v_0.Args[0]
6963 if !(x >= 16) {
6964 break
6965 }
6966 v.reset(OpRISCV64SRAI)
6967 v.AuxInt = int64ToAuxInt(63)
6968 v0 := b.NewValue0(v.Pos, OpRISCV64SLLI, t)
6969 v0.AuxInt = int64ToAuxInt(48)
6970 v0.AddArg(y)
6971 v.AddArg(v0)
6972 return true
6973 }
6974
6975
6976
6977 for {
6978 x := auxIntToInt64(v.AuxInt)
6979 if v_0.Op != OpRISCV64MOVWreg {
6980 break
6981 }
6982 y := v_0.Args[0]
6983 if !(x >= 32) {
6984 break
6985 }
6986 v.reset(OpRISCV64SRAIW)
6987 v.AuxInt = int64ToAuxInt(31)
6988 v.AddArg(y)
6989 return true
6990 }
6991
6992
6993 for {
6994 x := auxIntToInt64(v.AuxInt)
6995 if v_0.Op != OpRISCV64MOVDconst {
6996 break
6997 }
6998 y := auxIntToInt64(v_0.AuxInt)
6999 v.reset(OpRISCV64MOVDconst)
7000 v.AuxInt = int64ToAuxInt(int64(y) >> uint32(x))
7001 return true
7002 }
7003 return false
7004 }
7005 func rewriteValueRISCV64_OpRISCV64SRAW(v *Value) bool {
7006 v_1 := v.Args[1]
7007 v_0 := v.Args[0]
7008
7009
7010 for {
7011 x := v_0
7012 if v_1.Op != OpRISCV64MOVDconst {
7013 break
7014 }
7015 val := auxIntToInt64(v_1.AuxInt)
7016 v.reset(OpRISCV64SRAIW)
7017 v.AuxInt = int64ToAuxInt(int64(val & 31))
7018 v.AddArg(x)
7019 return true
7020 }
7021 return false
7022 }
7023 func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
7024 v_1 := v.Args[1]
7025 v_0 := v.Args[0]
7026
7027
7028 for {
7029 x := v_0
7030 if v_1.Op != OpRISCV64MOVDconst {
7031 break
7032 }
7033 val := auxIntToInt64(v_1.AuxInt)
7034 v.reset(OpRISCV64SRLI)
7035 v.AuxInt = int64ToAuxInt(int64(val & 63))
7036 v.AddArg(x)
7037 return true
7038 }
7039 return false
7040 }
7041 func rewriteValueRISCV64_OpRISCV64SRLI(v *Value) bool {
7042 v_0 := v.Args[0]
7043
7044
7045
7046 for {
7047 t := v.Type
7048 x := auxIntToInt64(v.AuxInt)
7049 if v_0.Op != OpRISCV64MOVWUreg {
7050 break
7051 }
7052 y := v_0.Args[0]
7053 if !(x >= 0 && x <= 31) {
7054 break
7055 }
7056 v.reset(OpRISCV64SRLIW)
7057 v.Type = t
7058 v.AuxInt = int64ToAuxInt(int64(x))
7059 v.AddArg(y)
7060 return true
7061 }
7062
7063
7064
7065 for {
7066 t := v.Type
7067 x := auxIntToInt64(v.AuxInt)
7068 if v_0.Op != OpRISCV64MOVBUreg {
7069 break
7070 }
7071 if !(x >= 8) {
7072 break
7073 }
7074 v.reset(OpRISCV64MOVDconst)
7075 v.Type = t
7076 v.AuxInt = int64ToAuxInt(0)
7077 return true
7078 }
7079
7080
7081
7082 for {
7083 t := v.Type
7084 x := auxIntToInt64(v.AuxInt)
7085 if v_0.Op != OpRISCV64MOVHUreg {
7086 break
7087 }
7088 if !(x >= 16) {
7089 break
7090 }
7091 v.reset(OpRISCV64MOVDconst)
7092 v.Type = t
7093 v.AuxInt = int64ToAuxInt(0)
7094 return true
7095 }
7096
7097
7098
7099 for {
7100 t := v.Type
7101 x := auxIntToInt64(v.AuxInt)
7102 if v_0.Op != OpRISCV64MOVWUreg {
7103 break
7104 }
7105 if !(x >= 32) {
7106 break
7107 }
7108 v.reset(OpRISCV64MOVDconst)
7109 v.Type = t
7110 v.AuxInt = int64ToAuxInt(0)
7111 return true
7112 }
7113
7114
7115 for {
7116 x := auxIntToInt64(v.AuxInt)
7117 if v_0.Op != OpRISCV64MOVDconst {
7118 break
7119 }
7120 y := auxIntToInt64(v_0.AuxInt)
7121 v.reset(OpRISCV64MOVDconst)
7122 v.AuxInt = int64ToAuxInt(int64(uint64(y) >> uint32(x)))
7123 return true
7124 }
7125 return false
7126 }
7127 func rewriteValueRISCV64_OpRISCV64SRLW(v *Value) bool {
7128 v_1 := v.Args[1]
7129 v_0 := v.Args[0]
7130
7131
7132 for {
7133 x := v_0
7134 if v_1.Op != OpRISCV64MOVDconst {
7135 break
7136 }
7137 val := auxIntToInt64(v_1.AuxInt)
7138 v.reset(OpRISCV64SRLIW)
7139 v.AuxInt = int64ToAuxInt(int64(val & 31))
7140 v.AddArg(x)
7141 return true
7142 }
7143 return false
7144 }
7145 func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
7146 v_1 := v.Args[1]
7147 v_0 := v.Args[0]
7148 b := v.Block
7149
7150
7151 for {
7152 x := v_0
7153 if v_1.Op != OpRISCV64NEG {
7154 break
7155 }
7156 y := v_1.Args[0]
7157 v.reset(OpRISCV64ADD)
7158 v.AddArg2(x, y)
7159 return true
7160 }
7161
7162
7163 for {
7164 x := v_0
7165 if x != v_1 {
7166 break
7167 }
7168 v.reset(OpRISCV64MOVDconst)
7169 v.AuxInt = int64ToAuxInt(0)
7170 return true
7171 }
7172
7173
7174
7175 for {
7176 x := v_0
7177 if v_1.Op != OpRISCV64MOVDconst {
7178 break
7179 }
7180 val := auxIntToInt64(v_1.AuxInt)
7181 if !(is32Bit(-val)) {
7182 break
7183 }
7184 v.reset(OpRISCV64ADDI)
7185 v.AuxInt = int64ToAuxInt(-val)
7186 v.AddArg(x)
7187 return true
7188 }
7189
7190
7191
7192 for {
7193 t := v.Type
7194 if v_0.Op != OpRISCV64MOVDconst {
7195 break
7196 }
7197 val := auxIntToInt64(v_0.AuxInt)
7198 y := v_1
7199 if !(is32Bit(-val)) {
7200 break
7201 }
7202 v.reset(OpRISCV64NEG)
7203 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, t)
7204 v0.AuxInt = int64ToAuxInt(-val)
7205 v0.AddArg(y)
7206 v.AddArg(v0)
7207 return true
7208 }
7209
7210
7211 for {
7212 x := v_0
7213 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
7214 break
7215 }
7216 v.copyOf(x)
7217 return true
7218 }
7219
7220
7221 for {
7222 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
7223 break
7224 }
7225 x := v_1
7226 v.reset(OpRISCV64NEG)
7227 v.AddArg(x)
7228 return true
7229 }
7230 return false
7231 }
7232 func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
7233 v_1 := v.Args[1]
7234 v_0 := v.Args[0]
7235
7236
7237 for {
7238 x := v_0
7239 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
7240 break
7241 }
7242 v.reset(OpRISCV64ADDIW)
7243 v.AuxInt = int64ToAuxInt(0)
7244 v.AddArg(x)
7245 return true
7246 }
7247
7248
7249 for {
7250 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
7251 break
7252 }
7253 x := v_1
7254 v.reset(OpRISCV64NEGW)
7255 v.AddArg(x)
7256 return true
7257 }
7258 return false
7259 }
7260 func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
7261 v_1 := v.Args[1]
7262 v_0 := v.Args[0]
7263
7264
7265
7266 for {
7267 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
7268 if v_0.Op != OpRISCV64MOVDconst {
7269 continue
7270 }
7271 val := auxIntToInt64(v_0.AuxInt)
7272 x := v_1
7273 if !(is32Bit(val)) {
7274 continue
7275 }
7276 v.reset(OpRISCV64XORI)
7277 v.AuxInt = int64ToAuxInt(val)
7278 v.AddArg(x)
7279 return true
7280 }
7281 break
7282 }
7283
7284
7285 for {
7286 x := v_0
7287 if x != v_1 {
7288 break
7289 }
7290 v.reset(OpRISCV64MOVDconst)
7291 v.AuxInt = int64ToAuxInt(0)
7292 return true
7293 }
7294 return false
7295 }
7296 func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
7297 v_1 := v.Args[1]
7298 v_0 := v.Args[0]
7299 b := v.Block
7300 typ := &b.Func.Config.Types
7301
7302
7303 for {
7304 t := v.Type
7305 x := v_0
7306 y := v_1
7307 v.reset(OpRISCV64OR)
7308 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
7309 v1 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
7310 v1.AuxInt = int64ToAuxInt(15)
7311 v1.AddArg(y)
7312 v0.AddArg2(x, v1)
7313 v2 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7314 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7315 v3.AddArg(x)
7316 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
7317 v4.AuxInt = int64ToAuxInt(15)
7318 v5 := b.NewValue0(v.Pos, OpRISCV64NEG, y.Type)
7319 v5.AddArg(y)
7320 v4.AddArg(v5)
7321 v2.AddArg2(v3, v4)
7322 v.AddArg2(v0, v2)
7323 return true
7324 }
7325 }
7326 func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
7327 v_1 := v.Args[1]
7328 v_0 := v.Args[0]
7329 b := v.Block
7330 typ := &b.Func.Config.Types
7331
7332
7333 for {
7334 t := v.Type
7335 x := v_0
7336 y := v_1
7337 v.reset(OpRISCV64OR)
7338 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
7339 v1 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
7340 v1.AuxInt = int64ToAuxInt(7)
7341 v1.AddArg(y)
7342 v0.AddArg2(x, v1)
7343 v2 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7344 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7345 v3.AddArg(x)
7346 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, y.Type)
7347 v4.AuxInt = int64ToAuxInt(7)
7348 v5 := b.NewValue0(v.Pos, OpRISCV64NEG, y.Type)
7349 v5.AddArg(y)
7350 v4.AddArg(v5)
7351 v2.AddArg2(v3, v4)
7352 v.AddArg2(v0, v2)
7353 return true
7354 }
7355 }
7356 func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
7357 v_1 := v.Args[1]
7358 v_0 := v.Args[0]
7359 b := v.Block
7360 typ := &b.Func.Config.Types
7361
7362
7363
7364 for {
7365 t := v.Type
7366 x := v_0
7367 y := v_1
7368 if !(!shiftIsBounded(v)) {
7369 break
7370 }
7371 v.reset(OpRISCV64AND)
7372 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7373 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7374 v1.AddArg(x)
7375 v0.AddArg2(v1, y)
7376 v2 := b.NewValue0(v.Pos, OpNeg16, t)
7377 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7378 v3.AuxInt = int64ToAuxInt(64)
7379 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7380 v4.AddArg(y)
7381 v3.AddArg(v4)
7382 v2.AddArg(v3)
7383 v.AddArg2(v0, v2)
7384 return true
7385 }
7386
7387
7388
7389 for {
7390 x := v_0
7391 y := v_1
7392 if !(shiftIsBounded(v)) {
7393 break
7394 }
7395 v.reset(OpRISCV64SRL)
7396 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7397 v0.AddArg(x)
7398 v.AddArg2(v0, y)
7399 return true
7400 }
7401 return false
7402 }
7403 func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
7404 v_1 := v.Args[1]
7405 v_0 := v.Args[0]
7406 b := v.Block
7407 typ := &b.Func.Config.Types
7408
7409
7410
7411 for {
7412 t := v.Type
7413 x := v_0
7414 y := v_1
7415 if !(!shiftIsBounded(v)) {
7416 break
7417 }
7418 v.reset(OpRISCV64AND)
7419 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7420 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7421 v1.AddArg(x)
7422 v0.AddArg2(v1, y)
7423 v2 := b.NewValue0(v.Pos, OpNeg16, t)
7424 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7425 v3.AuxInt = int64ToAuxInt(64)
7426 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7427 v4.AddArg(y)
7428 v3.AddArg(v4)
7429 v2.AddArg(v3)
7430 v.AddArg2(v0, v2)
7431 return true
7432 }
7433
7434
7435
7436 for {
7437 x := v_0
7438 y := v_1
7439 if !(shiftIsBounded(v)) {
7440 break
7441 }
7442 v.reset(OpRISCV64SRL)
7443 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7444 v0.AddArg(x)
7445 v.AddArg2(v0, y)
7446 return true
7447 }
7448 return false
7449 }
7450 func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
7451 v_1 := v.Args[1]
7452 v_0 := v.Args[0]
7453 b := v.Block
7454 typ := &b.Func.Config.Types
7455
7456
7457
7458 for {
7459 t := v.Type
7460 x := v_0
7461 y := v_1
7462 if !(!shiftIsBounded(v)) {
7463 break
7464 }
7465 v.reset(OpRISCV64AND)
7466 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7467 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7468 v1.AddArg(x)
7469 v0.AddArg2(v1, y)
7470 v2 := b.NewValue0(v.Pos, OpNeg16, t)
7471 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7472 v3.AuxInt = int64ToAuxInt(64)
7473 v3.AddArg(y)
7474 v2.AddArg(v3)
7475 v.AddArg2(v0, v2)
7476 return true
7477 }
7478
7479
7480
7481 for {
7482 x := v_0
7483 y := v_1
7484 if !(shiftIsBounded(v)) {
7485 break
7486 }
7487 v.reset(OpRISCV64SRL)
7488 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7489 v0.AddArg(x)
7490 v.AddArg2(v0, y)
7491 return true
7492 }
7493 return false
7494 }
7495 func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
7496 v_1 := v.Args[1]
7497 v_0 := v.Args[0]
7498 b := v.Block
7499 typ := &b.Func.Config.Types
7500
7501
7502
7503 for {
7504 t := v.Type
7505 x := v_0
7506 y := v_1
7507 if !(!shiftIsBounded(v)) {
7508 break
7509 }
7510 v.reset(OpRISCV64AND)
7511 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7512 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7513 v1.AddArg(x)
7514 v0.AddArg2(v1, y)
7515 v2 := b.NewValue0(v.Pos, OpNeg16, t)
7516 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7517 v3.AuxInt = int64ToAuxInt(64)
7518 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7519 v4.AddArg(y)
7520 v3.AddArg(v4)
7521 v2.AddArg(v3)
7522 v.AddArg2(v0, v2)
7523 return true
7524 }
7525
7526
7527
7528 for {
7529 x := v_0
7530 y := v_1
7531 if !(shiftIsBounded(v)) {
7532 break
7533 }
7534 v.reset(OpRISCV64SRL)
7535 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7536 v0.AddArg(x)
7537 v.AddArg2(v0, y)
7538 return true
7539 }
7540 return false
7541 }
7542 func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
7543 v_1 := v.Args[1]
7544 v_0 := v.Args[0]
7545 b := v.Block
7546 typ := &b.Func.Config.Types
7547
7548
7549
7550 for {
7551 t := v.Type
7552 x := v_0
7553 y := v_1
7554 if !(!shiftIsBounded(v)) {
7555 break
7556 }
7557 v.reset(OpRISCV64SRA)
7558 v.Type = t
7559 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7560 v0.AddArg(x)
7561 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7562 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7563 v2.AuxInt = int64ToAuxInt(-1)
7564 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7565 v3.AuxInt = int64ToAuxInt(64)
7566 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7567 v4.AddArg(y)
7568 v3.AddArg(v4)
7569 v2.AddArg(v3)
7570 v1.AddArg2(y, v2)
7571 v.AddArg2(v0, v1)
7572 return true
7573 }
7574
7575
7576
7577 for {
7578 x := v_0
7579 y := v_1
7580 if !(shiftIsBounded(v)) {
7581 break
7582 }
7583 v.reset(OpRISCV64SRA)
7584 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7585 v0.AddArg(x)
7586 v.AddArg2(v0, y)
7587 return true
7588 }
7589 return false
7590 }
7591 func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
7592 v_1 := v.Args[1]
7593 v_0 := v.Args[0]
7594 b := v.Block
7595 typ := &b.Func.Config.Types
7596
7597
7598
7599 for {
7600 t := v.Type
7601 x := v_0
7602 y := v_1
7603 if !(!shiftIsBounded(v)) {
7604 break
7605 }
7606 v.reset(OpRISCV64SRA)
7607 v.Type = t
7608 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7609 v0.AddArg(x)
7610 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7611 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7612 v2.AuxInt = int64ToAuxInt(-1)
7613 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7614 v3.AuxInt = int64ToAuxInt(64)
7615 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7616 v4.AddArg(y)
7617 v3.AddArg(v4)
7618 v2.AddArg(v3)
7619 v1.AddArg2(y, v2)
7620 v.AddArg2(v0, v1)
7621 return true
7622 }
7623
7624
7625
7626 for {
7627 x := v_0
7628 y := v_1
7629 if !(shiftIsBounded(v)) {
7630 break
7631 }
7632 v.reset(OpRISCV64SRA)
7633 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7634 v0.AddArg(x)
7635 v.AddArg2(v0, y)
7636 return true
7637 }
7638 return false
7639 }
7640 func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
7641 v_1 := v.Args[1]
7642 v_0 := v.Args[0]
7643 b := v.Block
7644 typ := &b.Func.Config.Types
7645
7646
7647
7648 for {
7649 t := v.Type
7650 x := v_0
7651 y := v_1
7652 if !(!shiftIsBounded(v)) {
7653 break
7654 }
7655 v.reset(OpRISCV64SRA)
7656 v.Type = t
7657 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7658 v0.AddArg(x)
7659 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7660 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7661 v2.AuxInt = int64ToAuxInt(-1)
7662 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7663 v3.AuxInt = int64ToAuxInt(64)
7664 v3.AddArg(y)
7665 v2.AddArg(v3)
7666 v1.AddArg2(y, v2)
7667 v.AddArg2(v0, v1)
7668 return true
7669 }
7670
7671
7672
7673 for {
7674 x := v_0
7675 y := v_1
7676 if !(shiftIsBounded(v)) {
7677 break
7678 }
7679 v.reset(OpRISCV64SRA)
7680 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7681 v0.AddArg(x)
7682 v.AddArg2(v0, y)
7683 return true
7684 }
7685 return false
7686 }
7687 func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
7688 v_1 := v.Args[1]
7689 v_0 := v.Args[0]
7690 b := v.Block
7691 typ := &b.Func.Config.Types
7692
7693
7694
7695 for {
7696 t := v.Type
7697 x := v_0
7698 y := v_1
7699 if !(!shiftIsBounded(v)) {
7700 break
7701 }
7702 v.reset(OpRISCV64SRA)
7703 v.Type = t
7704 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7705 v0.AddArg(x)
7706 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7707 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7708 v2.AuxInt = int64ToAuxInt(-1)
7709 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7710 v3.AuxInt = int64ToAuxInt(64)
7711 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7712 v4.AddArg(y)
7713 v3.AddArg(v4)
7714 v2.AddArg(v3)
7715 v1.AddArg2(y, v2)
7716 v.AddArg2(v0, v1)
7717 return true
7718 }
7719
7720
7721
7722 for {
7723 x := v_0
7724 y := v_1
7725 if !(shiftIsBounded(v)) {
7726 break
7727 }
7728 v.reset(OpRISCV64SRA)
7729 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
7730 v0.AddArg(x)
7731 v.AddArg2(v0, y)
7732 return true
7733 }
7734 return false
7735 }
7736 func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
7737 v_1 := v.Args[1]
7738 v_0 := v.Args[0]
7739 b := v.Block
7740 typ := &b.Func.Config.Types
7741
7742
7743
7744 for {
7745 t := v.Type
7746 x := v_0
7747 y := v_1
7748 if !(!shiftIsBounded(v)) {
7749 break
7750 }
7751 v.reset(OpRISCV64AND)
7752 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
7753 v0.AddArg2(x, y)
7754 v1 := b.NewValue0(v.Pos, OpNeg32, t)
7755 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7756 v2.AuxInt = int64ToAuxInt(32)
7757 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7758 v3.AddArg(y)
7759 v2.AddArg(v3)
7760 v1.AddArg(v2)
7761 v.AddArg2(v0, v1)
7762 return true
7763 }
7764
7765
7766
7767 for {
7768 x := v_0
7769 y := v_1
7770 if !(shiftIsBounded(v)) {
7771 break
7772 }
7773 v.reset(OpRISCV64SRLW)
7774 v.AddArg2(x, y)
7775 return true
7776 }
7777 return false
7778 }
7779 func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
7780 v_1 := v.Args[1]
7781 v_0 := v.Args[0]
7782 b := v.Block
7783 typ := &b.Func.Config.Types
7784
7785
7786
7787 for {
7788 t := v.Type
7789 x := v_0
7790 y := v_1
7791 if !(!shiftIsBounded(v)) {
7792 break
7793 }
7794 v.reset(OpRISCV64AND)
7795 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
7796 v0.AddArg2(x, y)
7797 v1 := b.NewValue0(v.Pos, OpNeg32, t)
7798 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7799 v2.AuxInt = int64ToAuxInt(32)
7800 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7801 v3.AddArg(y)
7802 v2.AddArg(v3)
7803 v1.AddArg(v2)
7804 v.AddArg2(v0, v1)
7805 return true
7806 }
7807
7808
7809
7810 for {
7811 x := v_0
7812 y := v_1
7813 if !(shiftIsBounded(v)) {
7814 break
7815 }
7816 v.reset(OpRISCV64SRLW)
7817 v.AddArg2(x, y)
7818 return true
7819 }
7820 return false
7821 }
7822 func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
7823 v_1 := v.Args[1]
7824 v_0 := v.Args[0]
7825 b := v.Block
7826
7827
7828
7829 for {
7830 t := v.Type
7831 x := v_0
7832 y := v_1
7833 if !(!shiftIsBounded(v)) {
7834 break
7835 }
7836 v.reset(OpRISCV64AND)
7837 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
7838 v0.AddArg2(x, y)
7839 v1 := b.NewValue0(v.Pos, OpNeg32, t)
7840 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7841 v2.AuxInt = int64ToAuxInt(32)
7842 v2.AddArg(y)
7843 v1.AddArg(v2)
7844 v.AddArg2(v0, v1)
7845 return true
7846 }
7847
7848
7849
7850 for {
7851 x := v_0
7852 y := v_1
7853 if !(shiftIsBounded(v)) {
7854 break
7855 }
7856 v.reset(OpRISCV64SRLW)
7857 v.AddArg2(x, y)
7858 return true
7859 }
7860 return false
7861 }
7862 func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
7863 v_1 := v.Args[1]
7864 v_0 := v.Args[0]
7865 b := v.Block
7866 typ := &b.Func.Config.Types
7867
7868
7869
7870 for {
7871 t := v.Type
7872 x := v_0
7873 y := v_1
7874 if !(!shiftIsBounded(v)) {
7875 break
7876 }
7877 v.reset(OpRISCV64AND)
7878 v0 := b.NewValue0(v.Pos, OpRISCV64SRLW, t)
7879 v0.AddArg2(x, y)
7880 v1 := b.NewValue0(v.Pos, OpNeg32, t)
7881 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7882 v2.AuxInt = int64ToAuxInt(32)
7883 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7884 v3.AddArg(y)
7885 v2.AddArg(v3)
7886 v1.AddArg(v2)
7887 v.AddArg2(v0, v1)
7888 return true
7889 }
7890
7891
7892
7893 for {
7894 x := v_0
7895 y := v_1
7896 if !(shiftIsBounded(v)) {
7897 break
7898 }
7899 v.reset(OpRISCV64SRLW)
7900 v.AddArg2(x, y)
7901 return true
7902 }
7903 return false
7904 }
7905 func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
7906 v_1 := v.Args[1]
7907 v_0 := v.Args[0]
7908 b := v.Block
7909 typ := &b.Func.Config.Types
7910
7911
7912
7913 for {
7914 t := v.Type
7915 x := v_0
7916 y := v_1
7917 if !(!shiftIsBounded(v)) {
7918 break
7919 }
7920 v.reset(OpRISCV64SRAW)
7921 v.Type = t
7922 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7923 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7924 v1.AuxInt = int64ToAuxInt(-1)
7925 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7926 v2.AuxInt = int64ToAuxInt(32)
7927 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7928 v3.AddArg(y)
7929 v2.AddArg(v3)
7930 v1.AddArg(v2)
7931 v0.AddArg2(y, v1)
7932 v.AddArg2(x, v0)
7933 return true
7934 }
7935
7936
7937
7938 for {
7939 x := v_0
7940 y := v_1
7941 if !(shiftIsBounded(v)) {
7942 break
7943 }
7944 v.reset(OpRISCV64SRAW)
7945 v.AddArg2(x, y)
7946 return true
7947 }
7948 return false
7949 }
7950 func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
7951 v_1 := v.Args[1]
7952 v_0 := v.Args[0]
7953 b := v.Block
7954 typ := &b.Func.Config.Types
7955
7956
7957
7958 for {
7959 t := v.Type
7960 x := v_0
7961 y := v_1
7962 if !(!shiftIsBounded(v)) {
7963 break
7964 }
7965 v.reset(OpRISCV64SRAW)
7966 v.Type = t
7967 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7968 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7969 v1.AuxInt = int64ToAuxInt(-1)
7970 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7971 v2.AuxInt = int64ToAuxInt(32)
7972 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7973 v3.AddArg(y)
7974 v2.AddArg(v3)
7975 v1.AddArg(v2)
7976 v0.AddArg2(y, v1)
7977 v.AddArg2(x, v0)
7978 return true
7979 }
7980
7981
7982
7983 for {
7984 x := v_0
7985 y := v_1
7986 if !(shiftIsBounded(v)) {
7987 break
7988 }
7989 v.reset(OpRISCV64SRAW)
7990 v.AddArg2(x, y)
7991 return true
7992 }
7993 return false
7994 }
7995 func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
7996 v_1 := v.Args[1]
7997 v_0 := v.Args[0]
7998 b := v.Block
7999
8000
8001
8002 for {
8003 t := v.Type
8004 x := v_0
8005 y := v_1
8006 if !(!shiftIsBounded(v)) {
8007 break
8008 }
8009 v.reset(OpRISCV64SRAW)
8010 v.Type = t
8011 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8012 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8013 v1.AuxInt = int64ToAuxInt(-1)
8014 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8015 v2.AuxInt = int64ToAuxInt(32)
8016 v2.AddArg(y)
8017 v1.AddArg(v2)
8018 v0.AddArg2(y, v1)
8019 v.AddArg2(x, v0)
8020 return true
8021 }
8022
8023
8024
8025 for {
8026 x := v_0
8027 y := v_1
8028 if !(shiftIsBounded(v)) {
8029 break
8030 }
8031 v.reset(OpRISCV64SRAW)
8032 v.AddArg2(x, y)
8033 return true
8034 }
8035 return false
8036 }
8037 func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
8038 v_1 := v.Args[1]
8039 v_0 := v.Args[0]
8040 b := v.Block
8041 typ := &b.Func.Config.Types
8042
8043
8044
8045 for {
8046 t := v.Type
8047 x := v_0
8048 y := v_1
8049 if !(!shiftIsBounded(v)) {
8050 break
8051 }
8052 v.reset(OpRISCV64SRAW)
8053 v.Type = t
8054 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8055 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8056 v1.AuxInt = int64ToAuxInt(-1)
8057 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8058 v2.AuxInt = int64ToAuxInt(32)
8059 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8060 v3.AddArg(y)
8061 v2.AddArg(v3)
8062 v1.AddArg(v2)
8063 v0.AddArg2(y, v1)
8064 v.AddArg2(x, v0)
8065 return true
8066 }
8067
8068
8069
8070 for {
8071 x := v_0
8072 y := v_1
8073 if !(shiftIsBounded(v)) {
8074 break
8075 }
8076 v.reset(OpRISCV64SRAW)
8077 v.AddArg2(x, y)
8078 return true
8079 }
8080 return false
8081 }
8082 func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
8083 v_1 := v.Args[1]
8084 v_0 := v.Args[0]
8085 b := v.Block
8086 typ := &b.Func.Config.Types
8087
8088
8089
8090 for {
8091 t := v.Type
8092 x := v_0
8093 y := v_1
8094 if !(!shiftIsBounded(v)) {
8095 break
8096 }
8097 v.reset(OpRISCV64AND)
8098 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8099 v0.AddArg2(x, y)
8100 v1 := b.NewValue0(v.Pos, OpNeg64, t)
8101 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8102 v2.AuxInt = int64ToAuxInt(64)
8103 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8104 v3.AddArg(y)
8105 v2.AddArg(v3)
8106 v1.AddArg(v2)
8107 v.AddArg2(v0, v1)
8108 return true
8109 }
8110
8111
8112
8113 for {
8114 x := v_0
8115 y := v_1
8116 if !(shiftIsBounded(v)) {
8117 break
8118 }
8119 v.reset(OpRISCV64SRL)
8120 v.AddArg2(x, y)
8121 return true
8122 }
8123 return false
8124 }
8125 func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
8126 v_1 := v.Args[1]
8127 v_0 := v.Args[0]
8128 b := v.Block
8129 typ := &b.Func.Config.Types
8130
8131
8132
8133 for {
8134 t := v.Type
8135 x := v_0
8136 y := v_1
8137 if !(!shiftIsBounded(v)) {
8138 break
8139 }
8140 v.reset(OpRISCV64AND)
8141 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8142 v0.AddArg2(x, y)
8143 v1 := b.NewValue0(v.Pos, OpNeg64, t)
8144 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8145 v2.AuxInt = int64ToAuxInt(64)
8146 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
8147 v3.AddArg(y)
8148 v2.AddArg(v3)
8149 v1.AddArg(v2)
8150 v.AddArg2(v0, v1)
8151 return true
8152 }
8153
8154
8155
8156 for {
8157 x := v_0
8158 y := v_1
8159 if !(shiftIsBounded(v)) {
8160 break
8161 }
8162 v.reset(OpRISCV64SRL)
8163 v.AddArg2(x, y)
8164 return true
8165 }
8166 return false
8167 }
8168 func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
8169 v_1 := v.Args[1]
8170 v_0 := v.Args[0]
8171 b := v.Block
8172
8173
8174
8175 for {
8176 t := v.Type
8177 x := v_0
8178 y := v_1
8179 if !(!shiftIsBounded(v)) {
8180 break
8181 }
8182 v.reset(OpRISCV64AND)
8183 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8184 v0.AddArg2(x, y)
8185 v1 := b.NewValue0(v.Pos, OpNeg64, t)
8186 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8187 v2.AuxInt = int64ToAuxInt(64)
8188 v2.AddArg(y)
8189 v1.AddArg(v2)
8190 v.AddArg2(v0, v1)
8191 return true
8192 }
8193
8194
8195
8196 for {
8197 x := v_0
8198 y := v_1
8199 if !(shiftIsBounded(v)) {
8200 break
8201 }
8202 v.reset(OpRISCV64SRL)
8203 v.AddArg2(x, y)
8204 return true
8205 }
8206 return false
8207 }
8208 func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
8209 v_1 := v.Args[1]
8210 v_0 := v.Args[0]
8211 b := v.Block
8212 typ := &b.Func.Config.Types
8213
8214
8215
8216 for {
8217 t := v.Type
8218 x := v_0
8219 y := v_1
8220 if !(!shiftIsBounded(v)) {
8221 break
8222 }
8223 v.reset(OpRISCV64AND)
8224 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8225 v0.AddArg2(x, y)
8226 v1 := b.NewValue0(v.Pos, OpNeg64, t)
8227 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8228 v2.AuxInt = int64ToAuxInt(64)
8229 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8230 v3.AddArg(y)
8231 v2.AddArg(v3)
8232 v1.AddArg(v2)
8233 v.AddArg2(v0, v1)
8234 return true
8235 }
8236
8237
8238
8239 for {
8240 x := v_0
8241 y := v_1
8242 if !(shiftIsBounded(v)) {
8243 break
8244 }
8245 v.reset(OpRISCV64SRL)
8246 v.AddArg2(x, y)
8247 return true
8248 }
8249 return false
8250 }
8251 func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
8252 v_1 := v.Args[1]
8253 v_0 := v.Args[0]
8254 b := v.Block
8255 typ := &b.Func.Config.Types
8256
8257
8258
8259 for {
8260 t := v.Type
8261 x := v_0
8262 y := v_1
8263 if !(!shiftIsBounded(v)) {
8264 break
8265 }
8266 v.reset(OpRISCV64SRA)
8267 v.Type = t
8268 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8269 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8270 v1.AuxInt = int64ToAuxInt(-1)
8271 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8272 v2.AuxInt = int64ToAuxInt(64)
8273 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8274 v3.AddArg(y)
8275 v2.AddArg(v3)
8276 v1.AddArg(v2)
8277 v0.AddArg2(y, v1)
8278 v.AddArg2(x, v0)
8279 return true
8280 }
8281
8282
8283
8284 for {
8285 x := v_0
8286 y := v_1
8287 if !(shiftIsBounded(v)) {
8288 break
8289 }
8290 v.reset(OpRISCV64SRA)
8291 v.AddArg2(x, y)
8292 return true
8293 }
8294 return false
8295 }
8296 func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
8297 v_1 := v.Args[1]
8298 v_0 := v.Args[0]
8299 b := v.Block
8300 typ := &b.Func.Config.Types
8301
8302
8303
8304 for {
8305 t := v.Type
8306 x := v_0
8307 y := v_1
8308 if !(!shiftIsBounded(v)) {
8309 break
8310 }
8311 v.reset(OpRISCV64SRA)
8312 v.Type = t
8313 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8314 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8315 v1.AuxInt = int64ToAuxInt(-1)
8316 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8317 v2.AuxInt = int64ToAuxInt(64)
8318 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
8319 v3.AddArg(y)
8320 v2.AddArg(v3)
8321 v1.AddArg(v2)
8322 v0.AddArg2(y, v1)
8323 v.AddArg2(x, v0)
8324 return true
8325 }
8326
8327
8328
8329 for {
8330 x := v_0
8331 y := v_1
8332 if !(shiftIsBounded(v)) {
8333 break
8334 }
8335 v.reset(OpRISCV64SRA)
8336 v.AddArg2(x, y)
8337 return true
8338 }
8339 return false
8340 }
8341 func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
8342 v_1 := v.Args[1]
8343 v_0 := v.Args[0]
8344 b := v.Block
8345
8346
8347
8348 for {
8349 t := v.Type
8350 x := v_0
8351 y := v_1
8352 if !(!shiftIsBounded(v)) {
8353 break
8354 }
8355 v.reset(OpRISCV64SRA)
8356 v.Type = t
8357 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8358 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8359 v1.AuxInt = int64ToAuxInt(-1)
8360 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8361 v2.AuxInt = int64ToAuxInt(64)
8362 v2.AddArg(y)
8363 v1.AddArg(v2)
8364 v0.AddArg2(y, v1)
8365 v.AddArg2(x, v0)
8366 return true
8367 }
8368
8369
8370
8371 for {
8372 x := v_0
8373 y := v_1
8374 if !(shiftIsBounded(v)) {
8375 break
8376 }
8377 v.reset(OpRISCV64SRA)
8378 v.AddArg2(x, y)
8379 return true
8380 }
8381 return false
8382 }
8383 func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
8384 v_1 := v.Args[1]
8385 v_0 := v.Args[0]
8386 b := v.Block
8387 typ := &b.Func.Config.Types
8388
8389
8390
8391 for {
8392 t := v.Type
8393 x := v_0
8394 y := v_1
8395 if !(!shiftIsBounded(v)) {
8396 break
8397 }
8398 v.reset(OpRISCV64SRA)
8399 v.Type = t
8400 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8401 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8402 v1.AuxInt = int64ToAuxInt(-1)
8403 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8404 v2.AuxInt = int64ToAuxInt(64)
8405 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8406 v3.AddArg(y)
8407 v2.AddArg(v3)
8408 v1.AddArg(v2)
8409 v0.AddArg2(y, v1)
8410 v.AddArg2(x, v0)
8411 return true
8412 }
8413
8414
8415
8416 for {
8417 x := v_0
8418 y := v_1
8419 if !(shiftIsBounded(v)) {
8420 break
8421 }
8422 v.reset(OpRISCV64SRA)
8423 v.AddArg2(x, y)
8424 return true
8425 }
8426 return false
8427 }
8428 func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
8429 v_1 := v.Args[1]
8430 v_0 := v.Args[0]
8431 b := v.Block
8432 typ := &b.Func.Config.Types
8433
8434
8435
8436 for {
8437 t := v.Type
8438 x := v_0
8439 y := v_1
8440 if !(!shiftIsBounded(v)) {
8441 break
8442 }
8443 v.reset(OpRISCV64AND)
8444 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8445 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8446 v1.AddArg(x)
8447 v0.AddArg2(v1, y)
8448 v2 := b.NewValue0(v.Pos, OpNeg8, t)
8449 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8450 v3.AuxInt = int64ToAuxInt(64)
8451 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8452 v4.AddArg(y)
8453 v3.AddArg(v4)
8454 v2.AddArg(v3)
8455 v.AddArg2(v0, v2)
8456 return true
8457 }
8458
8459
8460
8461 for {
8462 x := v_0
8463 y := v_1
8464 if !(shiftIsBounded(v)) {
8465 break
8466 }
8467 v.reset(OpRISCV64SRL)
8468 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8469 v0.AddArg(x)
8470 v.AddArg2(v0, y)
8471 return true
8472 }
8473 return false
8474 }
8475 func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
8476 v_1 := v.Args[1]
8477 v_0 := v.Args[0]
8478 b := v.Block
8479 typ := &b.Func.Config.Types
8480
8481
8482
8483 for {
8484 t := v.Type
8485 x := v_0
8486 y := v_1
8487 if !(!shiftIsBounded(v)) {
8488 break
8489 }
8490 v.reset(OpRISCV64AND)
8491 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8492 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8493 v1.AddArg(x)
8494 v0.AddArg2(v1, y)
8495 v2 := b.NewValue0(v.Pos, OpNeg8, t)
8496 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8497 v3.AuxInt = int64ToAuxInt(64)
8498 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
8499 v4.AddArg(y)
8500 v3.AddArg(v4)
8501 v2.AddArg(v3)
8502 v.AddArg2(v0, v2)
8503 return true
8504 }
8505
8506
8507
8508 for {
8509 x := v_0
8510 y := v_1
8511 if !(shiftIsBounded(v)) {
8512 break
8513 }
8514 v.reset(OpRISCV64SRL)
8515 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8516 v0.AddArg(x)
8517 v.AddArg2(v0, y)
8518 return true
8519 }
8520 return false
8521 }
8522 func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
8523 v_1 := v.Args[1]
8524 v_0 := v.Args[0]
8525 b := v.Block
8526 typ := &b.Func.Config.Types
8527
8528
8529
8530 for {
8531 t := v.Type
8532 x := v_0
8533 y := v_1
8534 if !(!shiftIsBounded(v)) {
8535 break
8536 }
8537 v.reset(OpRISCV64AND)
8538 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8539 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8540 v1.AddArg(x)
8541 v0.AddArg2(v1, y)
8542 v2 := b.NewValue0(v.Pos, OpNeg8, t)
8543 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8544 v3.AuxInt = int64ToAuxInt(64)
8545 v3.AddArg(y)
8546 v2.AddArg(v3)
8547 v.AddArg2(v0, v2)
8548 return true
8549 }
8550
8551
8552
8553 for {
8554 x := v_0
8555 y := v_1
8556 if !(shiftIsBounded(v)) {
8557 break
8558 }
8559 v.reset(OpRISCV64SRL)
8560 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8561 v0.AddArg(x)
8562 v.AddArg2(v0, y)
8563 return true
8564 }
8565 return false
8566 }
8567 func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
8568 v_1 := v.Args[1]
8569 v_0 := v.Args[0]
8570 b := v.Block
8571 typ := &b.Func.Config.Types
8572
8573
8574
8575 for {
8576 t := v.Type
8577 x := v_0
8578 y := v_1
8579 if !(!shiftIsBounded(v)) {
8580 break
8581 }
8582 v.reset(OpRISCV64AND)
8583 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
8584 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8585 v1.AddArg(x)
8586 v0.AddArg2(v1, y)
8587 v2 := b.NewValue0(v.Pos, OpNeg8, t)
8588 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
8589 v3.AuxInt = int64ToAuxInt(64)
8590 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8591 v4.AddArg(y)
8592 v3.AddArg(v4)
8593 v2.AddArg(v3)
8594 v.AddArg2(v0, v2)
8595 return true
8596 }
8597
8598
8599
8600 for {
8601 x := v_0
8602 y := v_1
8603 if !(shiftIsBounded(v)) {
8604 break
8605 }
8606 v.reset(OpRISCV64SRL)
8607 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8608 v0.AddArg(x)
8609 v.AddArg2(v0, y)
8610 return true
8611 }
8612 return false
8613 }
8614 func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
8615 v_1 := v.Args[1]
8616 v_0 := v.Args[0]
8617 b := v.Block
8618 typ := &b.Func.Config.Types
8619
8620
8621
8622 for {
8623 t := v.Type
8624 x := v_0
8625 y := v_1
8626 if !(!shiftIsBounded(v)) {
8627 break
8628 }
8629 v.reset(OpRISCV64SRA)
8630 v.Type = t
8631 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8632 v0.AddArg(x)
8633 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8634 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8635 v2.AuxInt = int64ToAuxInt(-1)
8636 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8637 v3.AuxInt = int64ToAuxInt(64)
8638 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
8639 v4.AddArg(y)
8640 v3.AddArg(v4)
8641 v2.AddArg(v3)
8642 v1.AddArg2(y, v2)
8643 v.AddArg2(v0, v1)
8644 return true
8645 }
8646
8647
8648
8649 for {
8650 x := v_0
8651 y := v_1
8652 if !(shiftIsBounded(v)) {
8653 break
8654 }
8655 v.reset(OpRISCV64SRA)
8656 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8657 v0.AddArg(x)
8658 v.AddArg2(v0, y)
8659 return true
8660 }
8661 return false
8662 }
8663 func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
8664 v_1 := v.Args[1]
8665 v_0 := v.Args[0]
8666 b := v.Block
8667 typ := &b.Func.Config.Types
8668
8669
8670
8671 for {
8672 t := v.Type
8673 x := v_0
8674 y := v_1
8675 if !(!shiftIsBounded(v)) {
8676 break
8677 }
8678 v.reset(OpRISCV64SRA)
8679 v.Type = t
8680 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8681 v0.AddArg(x)
8682 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8683 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8684 v2.AuxInt = int64ToAuxInt(-1)
8685 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8686 v3.AuxInt = int64ToAuxInt(64)
8687 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
8688 v4.AddArg(y)
8689 v3.AddArg(v4)
8690 v2.AddArg(v3)
8691 v1.AddArg2(y, v2)
8692 v.AddArg2(v0, v1)
8693 return true
8694 }
8695
8696
8697
8698 for {
8699 x := v_0
8700 y := v_1
8701 if !(shiftIsBounded(v)) {
8702 break
8703 }
8704 v.reset(OpRISCV64SRA)
8705 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8706 v0.AddArg(x)
8707 v.AddArg2(v0, y)
8708 return true
8709 }
8710 return false
8711 }
8712 func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
8713 v_1 := v.Args[1]
8714 v_0 := v.Args[0]
8715 b := v.Block
8716 typ := &b.Func.Config.Types
8717
8718
8719
8720 for {
8721 t := v.Type
8722 x := v_0
8723 y := v_1
8724 if !(!shiftIsBounded(v)) {
8725 break
8726 }
8727 v.reset(OpRISCV64SRA)
8728 v.Type = t
8729 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8730 v0.AddArg(x)
8731 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8732 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8733 v2.AuxInt = int64ToAuxInt(-1)
8734 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8735 v3.AuxInt = int64ToAuxInt(64)
8736 v3.AddArg(y)
8737 v2.AddArg(v3)
8738 v1.AddArg2(y, v2)
8739 v.AddArg2(v0, v1)
8740 return true
8741 }
8742
8743
8744
8745 for {
8746 x := v_0
8747 y := v_1
8748 if !(shiftIsBounded(v)) {
8749 break
8750 }
8751 v.reset(OpRISCV64SRA)
8752 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8753 v0.AddArg(x)
8754 v.AddArg2(v0, y)
8755 return true
8756 }
8757 return false
8758 }
8759 func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
8760 v_1 := v.Args[1]
8761 v_0 := v.Args[0]
8762 b := v.Block
8763 typ := &b.Func.Config.Types
8764
8765
8766
8767 for {
8768 t := v.Type
8769 x := v_0
8770 y := v_1
8771 if !(!shiftIsBounded(v)) {
8772 break
8773 }
8774 v.reset(OpRISCV64SRA)
8775 v.Type = t
8776 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8777 v0.AddArg(x)
8778 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
8779 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
8780 v2.AuxInt = int64ToAuxInt(-1)
8781 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
8782 v3.AuxInt = int64ToAuxInt(64)
8783 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
8784 v4.AddArg(y)
8785 v3.AddArg(v4)
8786 v2.AddArg(v3)
8787 v1.AddArg2(y, v2)
8788 v.AddArg2(v0, v1)
8789 return true
8790 }
8791
8792
8793
8794 for {
8795 x := v_0
8796 y := v_1
8797 if !(shiftIsBounded(v)) {
8798 break
8799 }
8800 v.reset(OpRISCV64SRA)
8801 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
8802 v0.AddArg(x)
8803 v.AddArg2(v0, y)
8804 return true
8805 }
8806 return false
8807 }
8808 func rewriteValueRISCV64_OpSelect0(v *Value) bool {
8809 v_0 := v.Args[0]
8810 b := v.Block
8811 typ := &b.Func.Config.Types
8812
8813
8814 for {
8815 if v_0.Op != OpAdd64carry {
8816 break
8817 }
8818 c := v_0.Args[2]
8819 x := v_0.Args[0]
8820 y := v_0.Args[1]
8821 v.reset(OpRISCV64ADD)
8822 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
8823 v0.AddArg2(x, y)
8824 v.AddArg2(v0, c)
8825 return true
8826 }
8827
8828
8829 for {
8830 if v_0.Op != OpSub64borrow {
8831 break
8832 }
8833 c := v_0.Args[2]
8834 x := v_0.Args[0]
8835 y := v_0.Args[1]
8836 v.reset(OpRISCV64SUB)
8837 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
8838 v0.AddArg2(x, y)
8839 v.AddArg2(v0, c)
8840 return true
8841 }
8842
8843
8844
8845 for {
8846 m := v_0
8847 if m.Op != OpRISCV64LoweredMuluhilo {
8848 break
8849 }
8850 y := m.Args[1]
8851 x := m.Args[0]
8852 if !(m.Uses == 1) {
8853 break
8854 }
8855 v.reset(OpRISCV64MULHU)
8856 v.AddArg2(x, y)
8857 return true
8858 }
8859 return false
8860 }
8861 func rewriteValueRISCV64_OpSelect1(v *Value) bool {
8862 v_0 := v.Args[0]
8863 b := v.Block
8864 typ := &b.Func.Config.Types
8865
8866
8867 for {
8868 if v_0.Op != OpAdd64carry {
8869 break
8870 }
8871 c := v_0.Args[2]
8872 x := v_0.Args[0]
8873 y := v_0.Args[1]
8874 v.reset(OpRISCV64OR)
8875 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
8876 s := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
8877 s.AddArg2(x, y)
8878 v0.AddArg2(s, x)
8879 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
8880 v3 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
8881 v3.AddArg2(s, c)
8882 v2.AddArg2(v3, s)
8883 v.AddArg2(v0, v2)
8884 return true
8885 }
8886
8887
8888 for {
8889 if v_0.Op != OpSub64borrow {
8890 break
8891 }
8892 c := v_0.Args[2]
8893 x := v_0.Args[0]
8894 y := v_0.Args[1]
8895 v.reset(OpRISCV64OR)
8896 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
8897 s := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
8898 s.AddArg2(x, y)
8899 v0.AddArg2(x, s)
8900 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
8901 v3 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
8902 v3.AddArg2(s, c)
8903 v2.AddArg2(s, v3)
8904 v.AddArg2(v0, v2)
8905 return true
8906 }
8907
8908
8909
8910 for {
8911 m := v_0
8912 if m.Op != OpRISCV64LoweredMuluhilo {
8913 break
8914 }
8915 y := m.Args[1]
8916 x := m.Args[0]
8917 if !(m.Uses == 1) {
8918 break
8919 }
8920 v.reset(OpRISCV64MUL)
8921 v.AddArg2(x, y)
8922 return true
8923 }
8924 return false
8925 }
8926 func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
8927 v_0 := v.Args[0]
8928 b := v.Block
8929
8930
8931 for {
8932 t := v.Type
8933 x := v_0
8934 v.reset(OpRISCV64SRAI)
8935 v.AuxInt = int64ToAuxInt(63)
8936 v0 := b.NewValue0(v.Pos, OpRISCV64NEG, t)
8937 v0.AddArg(x)
8938 v.AddArg(v0)
8939 return true
8940 }
8941 }
8942 func rewriteValueRISCV64_OpStore(v *Value) bool {
8943 v_2 := v.Args[2]
8944 v_1 := v.Args[1]
8945 v_0 := v.Args[0]
8946
8947
8948
8949 for {
8950 t := auxToType(v.Aux)
8951 ptr := v_0
8952 val := v_1
8953 mem := v_2
8954 if !(t.Size() == 1) {
8955 break
8956 }
8957 v.reset(OpRISCV64MOVBstore)
8958 v.AddArg3(ptr, val, mem)
8959 return true
8960 }
8961
8962
8963
8964 for {
8965 t := auxToType(v.Aux)
8966 ptr := v_0
8967 val := v_1
8968 mem := v_2
8969 if !(t.Size() == 2) {
8970 break
8971 }
8972 v.reset(OpRISCV64MOVHstore)
8973 v.AddArg3(ptr, val, mem)
8974 return true
8975 }
8976
8977
8978
8979 for {
8980 t := auxToType(v.Aux)
8981 ptr := v_0
8982 val := v_1
8983 mem := v_2
8984 if !(t.Size() == 4 && !t.IsFloat()) {
8985 break
8986 }
8987 v.reset(OpRISCV64MOVWstore)
8988 v.AddArg3(ptr, val, mem)
8989 return true
8990 }
8991
8992
8993
8994 for {
8995 t := auxToType(v.Aux)
8996 ptr := v_0
8997 val := v_1
8998 mem := v_2
8999 if !(t.Size() == 8 && !t.IsFloat()) {
9000 break
9001 }
9002 v.reset(OpRISCV64MOVDstore)
9003 v.AddArg3(ptr, val, mem)
9004 return true
9005 }
9006
9007
9008
9009 for {
9010 t := auxToType(v.Aux)
9011 ptr := v_0
9012 val := v_1
9013 mem := v_2
9014 if !(t.Size() == 4 && t.IsFloat()) {
9015 break
9016 }
9017 v.reset(OpRISCV64FMOVWstore)
9018 v.AddArg3(ptr, val, mem)
9019 return true
9020 }
9021
9022
9023
9024 for {
9025 t := auxToType(v.Aux)
9026 ptr := v_0
9027 val := v_1
9028 mem := v_2
9029 if !(t.Size() == 8 && t.IsFloat()) {
9030 break
9031 }
9032 v.reset(OpRISCV64FMOVDstore)
9033 v.AddArg3(ptr, val, mem)
9034 return true
9035 }
9036 return false
9037 }
9038 func rewriteValueRISCV64_OpZero(v *Value) bool {
9039 v_1 := v.Args[1]
9040 v_0 := v.Args[0]
9041 b := v.Block
9042 config := b.Func.Config
9043 typ := &b.Func.Config.Types
9044
9045
9046 for {
9047 if auxIntToInt64(v.AuxInt) != 0 {
9048 break
9049 }
9050 mem := v_1
9051 v.copyOf(mem)
9052 return true
9053 }
9054
9055
9056 for {
9057 if auxIntToInt64(v.AuxInt) != 1 {
9058 break
9059 }
9060 ptr := v_0
9061 mem := v_1
9062 v.reset(OpRISCV64MOVBstore)
9063 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9064 v0.AuxInt = int64ToAuxInt(0)
9065 v.AddArg3(ptr, v0, mem)
9066 return true
9067 }
9068
9069
9070
9071 for {
9072 if auxIntToInt64(v.AuxInt) != 2 {
9073 break
9074 }
9075 t := auxToType(v.Aux)
9076 ptr := v_0
9077 mem := v_1
9078 if !(t.Alignment()%2 == 0) {
9079 break
9080 }
9081 v.reset(OpRISCV64MOVHstore)
9082 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9083 v0.AuxInt = int64ToAuxInt(0)
9084 v.AddArg3(ptr, v0, mem)
9085 return true
9086 }
9087
9088
9089 for {
9090 if auxIntToInt64(v.AuxInt) != 2 {
9091 break
9092 }
9093 ptr := v_0
9094 mem := v_1
9095 v.reset(OpRISCV64MOVBstore)
9096 v.AuxInt = int32ToAuxInt(1)
9097 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9098 v0.AuxInt = int64ToAuxInt(0)
9099 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
9100 v1.AddArg3(ptr, v0, mem)
9101 v.AddArg3(ptr, v0, v1)
9102 return true
9103 }
9104
9105
9106
9107 for {
9108 if auxIntToInt64(v.AuxInt) != 4 {
9109 break
9110 }
9111 t := auxToType(v.Aux)
9112 ptr := v_0
9113 mem := v_1
9114 if !(t.Alignment()%4 == 0) {
9115 break
9116 }
9117 v.reset(OpRISCV64MOVWstore)
9118 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9119 v0.AuxInt = int64ToAuxInt(0)
9120 v.AddArg3(ptr, v0, mem)
9121 return true
9122 }
9123
9124
9125
9126 for {
9127 if auxIntToInt64(v.AuxInt) != 4 {
9128 break
9129 }
9130 t := auxToType(v.Aux)
9131 ptr := v_0
9132 mem := v_1
9133 if !(t.Alignment()%2 == 0) {
9134 break
9135 }
9136 v.reset(OpRISCV64MOVHstore)
9137 v.AuxInt = int32ToAuxInt(2)
9138 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9139 v0.AuxInt = int64ToAuxInt(0)
9140 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
9141 v1.AddArg3(ptr, v0, mem)
9142 v.AddArg3(ptr, v0, v1)
9143 return true
9144 }
9145
9146
9147 for {
9148 if auxIntToInt64(v.AuxInt) != 4 {
9149 break
9150 }
9151 ptr := v_0
9152 mem := v_1
9153 v.reset(OpRISCV64MOVBstore)
9154 v.AuxInt = int32ToAuxInt(3)
9155 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9156 v0.AuxInt = int64ToAuxInt(0)
9157 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
9158 v1.AuxInt = int32ToAuxInt(2)
9159 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
9160 v2.AuxInt = int32ToAuxInt(1)
9161 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
9162 v3.AddArg3(ptr, v0, mem)
9163 v2.AddArg3(ptr, v0, v3)
9164 v1.AddArg3(ptr, v0, v2)
9165 v.AddArg3(ptr, v0, v1)
9166 return true
9167 }
9168
9169
9170
9171 for {
9172 if auxIntToInt64(v.AuxInt) != 8 {
9173 break
9174 }
9175 t := auxToType(v.Aux)
9176 ptr := v_0
9177 mem := v_1
9178 if !(t.Alignment()%8 == 0) {
9179 break
9180 }
9181 v.reset(OpRISCV64MOVDstore)
9182 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9183 v0.AuxInt = int64ToAuxInt(0)
9184 v.AddArg3(ptr, v0, mem)
9185 return true
9186 }
9187
9188
9189
9190 for {
9191 if auxIntToInt64(v.AuxInt) != 8 {
9192 break
9193 }
9194 t := auxToType(v.Aux)
9195 ptr := v_0
9196 mem := v_1
9197 if !(t.Alignment()%4 == 0) {
9198 break
9199 }
9200 v.reset(OpRISCV64MOVWstore)
9201 v.AuxInt = int32ToAuxInt(4)
9202 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9203 v0.AuxInt = int64ToAuxInt(0)
9204 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
9205 v1.AddArg3(ptr, v0, mem)
9206 v.AddArg3(ptr, v0, v1)
9207 return true
9208 }
9209
9210
9211
9212 for {
9213 if auxIntToInt64(v.AuxInt) != 8 {
9214 break
9215 }
9216 t := auxToType(v.Aux)
9217 ptr := v_0
9218 mem := v_1
9219 if !(t.Alignment()%2 == 0) {
9220 break
9221 }
9222 v.reset(OpRISCV64MOVHstore)
9223 v.AuxInt = int32ToAuxInt(6)
9224 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9225 v0.AuxInt = int64ToAuxInt(0)
9226 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
9227 v1.AuxInt = int32ToAuxInt(4)
9228 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
9229 v2.AuxInt = int32ToAuxInt(2)
9230 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
9231 v3.AddArg3(ptr, v0, mem)
9232 v2.AddArg3(ptr, v0, v3)
9233 v1.AddArg3(ptr, v0, v2)
9234 v.AddArg3(ptr, v0, v1)
9235 return true
9236 }
9237
9238
9239 for {
9240 if auxIntToInt64(v.AuxInt) != 3 {
9241 break
9242 }
9243 ptr := v_0
9244 mem := v_1
9245 v.reset(OpRISCV64MOVBstore)
9246 v.AuxInt = int32ToAuxInt(2)
9247 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9248 v0.AuxInt = int64ToAuxInt(0)
9249 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
9250 v1.AuxInt = int32ToAuxInt(1)
9251 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
9252 v2.AddArg3(ptr, v0, mem)
9253 v1.AddArg3(ptr, v0, v2)
9254 v.AddArg3(ptr, v0, v1)
9255 return true
9256 }
9257
9258
9259
9260 for {
9261 if auxIntToInt64(v.AuxInt) != 6 {
9262 break
9263 }
9264 t := auxToType(v.Aux)
9265 ptr := v_0
9266 mem := v_1
9267 if !(t.Alignment()%2 == 0) {
9268 break
9269 }
9270 v.reset(OpRISCV64MOVHstore)
9271 v.AuxInt = int32ToAuxInt(4)
9272 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9273 v0.AuxInt = int64ToAuxInt(0)
9274 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
9275 v1.AuxInt = int32ToAuxInt(2)
9276 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
9277 v2.AddArg3(ptr, v0, mem)
9278 v1.AddArg3(ptr, v0, v2)
9279 v.AddArg3(ptr, v0, v1)
9280 return true
9281 }
9282
9283
9284
9285 for {
9286 if auxIntToInt64(v.AuxInt) != 12 {
9287 break
9288 }
9289 t := auxToType(v.Aux)
9290 ptr := v_0
9291 mem := v_1
9292 if !(t.Alignment()%4 == 0) {
9293 break
9294 }
9295 v.reset(OpRISCV64MOVWstore)
9296 v.AuxInt = int32ToAuxInt(8)
9297 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9298 v0.AuxInt = int64ToAuxInt(0)
9299 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
9300 v1.AuxInt = int32ToAuxInt(4)
9301 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
9302 v2.AddArg3(ptr, v0, mem)
9303 v1.AddArg3(ptr, v0, v2)
9304 v.AddArg3(ptr, v0, v1)
9305 return true
9306 }
9307
9308
9309
9310 for {
9311 if auxIntToInt64(v.AuxInt) != 16 {
9312 break
9313 }
9314 t := auxToType(v.Aux)
9315 ptr := v_0
9316 mem := v_1
9317 if !(t.Alignment()%8 == 0) {
9318 break
9319 }
9320 v.reset(OpRISCV64MOVDstore)
9321 v.AuxInt = int32ToAuxInt(8)
9322 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9323 v0.AuxInt = int64ToAuxInt(0)
9324 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
9325 v1.AddArg3(ptr, v0, mem)
9326 v.AddArg3(ptr, v0, v1)
9327 return true
9328 }
9329
9330
9331
9332 for {
9333 if auxIntToInt64(v.AuxInt) != 24 {
9334 break
9335 }
9336 t := auxToType(v.Aux)
9337 ptr := v_0
9338 mem := v_1
9339 if !(t.Alignment()%8 == 0) {
9340 break
9341 }
9342 v.reset(OpRISCV64MOVDstore)
9343 v.AuxInt = int32ToAuxInt(16)
9344 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9345 v0.AuxInt = int64ToAuxInt(0)
9346 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
9347 v1.AuxInt = int32ToAuxInt(8)
9348 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
9349 v2.AddArg3(ptr, v0, mem)
9350 v1.AddArg3(ptr, v0, v2)
9351 v.AddArg3(ptr, v0, v1)
9352 return true
9353 }
9354
9355
9356
9357 for {
9358 if auxIntToInt64(v.AuxInt) != 32 {
9359 break
9360 }
9361 t := auxToType(v.Aux)
9362 ptr := v_0
9363 mem := v_1
9364 if !(t.Alignment()%8 == 0) {
9365 break
9366 }
9367 v.reset(OpRISCV64MOVDstore)
9368 v.AuxInt = int32ToAuxInt(24)
9369 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9370 v0.AuxInt = int64ToAuxInt(0)
9371 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
9372 v1.AuxInt = int32ToAuxInt(16)
9373 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
9374 v2.AuxInt = int32ToAuxInt(8)
9375 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
9376 v3.AddArg3(ptr, v0, mem)
9377 v2.AddArg3(ptr, v0, v3)
9378 v1.AddArg3(ptr, v0, v2)
9379 v.AddArg3(ptr, v0, v1)
9380 return true
9381 }
9382
9383
9384
9385 for {
9386 s := auxIntToInt64(v.AuxInt)
9387 t := auxToType(v.Aux)
9388 ptr := v_0
9389 mem := v_1
9390 if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0) {
9391 break
9392 }
9393 v.reset(OpRISCV64DUFFZERO)
9394 v.AuxInt = int64ToAuxInt(8 * (128 - s/8))
9395 v.AddArg2(ptr, mem)
9396 return true
9397 }
9398
9399
9400 for {
9401 s := auxIntToInt64(v.AuxInt)
9402 t := auxToType(v.Aux)
9403 ptr := v_0
9404 mem := v_1
9405 v.reset(OpRISCV64LoweredZero)
9406 v.AuxInt = int64ToAuxInt(t.Alignment())
9407 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, ptr.Type)
9408 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
9409 v1.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
9410 v0.AddArg2(ptr, v1)
9411 v.AddArg3(ptr, v0, mem)
9412 return true
9413 }
9414 }
9415 func rewriteBlockRISCV64(b *Block) bool {
9416 typ := &b.Func.Config.Types
9417 switch b.Kind {
9418 case BlockRISCV64BEQ:
9419
9420
9421 for b.Controls[0].Op == OpRISCV64MOVDconst {
9422 v_0 := b.Controls[0]
9423 if auxIntToInt64(v_0.AuxInt) != 0 {
9424 break
9425 }
9426 cond := b.Controls[1]
9427 b.resetWithControl(BlockRISCV64BEQZ, cond)
9428 return true
9429 }
9430
9431
9432 for b.Controls[1].Op == OpRISCV64MOVDconst {
9433 cond := b.Controls[0]
9434 v_1 := b.Controls[1]
9435 if auxIntToInt64(v_1.AuxInt) != 0 {
9436 break
9437 }
9438 b.resetWithControl(BlockRISCV64BEQZ, cond)
9439 return true
9440 }
9441 case BlockRISCV64BEQZ:
9442
9443
9444 for b.Controls[0].Op == OpRISCV64SEQZ {
9445 v_0 := b.Controls[0]
9446 x := v_0.Args[0]
9447 b.resetWithControl(BlockRISCV64BNEZ, x)
9448 return true
9449 }
9450
9451
9452 for b.Controls[0].Op == OpRISCV64SNEZ {
9453 v_0 := b.Controls[0]
9454 x := v_0.Args[0]
9455 b.resetWithControl(BlockRISCV64BEQZ, x)
9456 return true
9457 }
9458
9459
9460 for b.Controls[0].Op == OpRISCV64NEG {
9461 v_0 := b.Controls[0]
9462 x := v_0.Args[0]
9463 b.resetWithControl(BlockRISCV64BEQZ, x)
9464 return true
9465 }
9466
9467
9468 for b.Controls[0].Op == OpRISCV64FNES {
9469 v_0 := b.Controls[0]
9470 t := v_0.Type
9471 _ = v_0.Args[1]
9472 v_0_0 := v_0.Args[0]
9473 v_0_1 := v_0.Args[1]
9474 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
9475 x := v_0_0
9476 y := v_0_1
9477 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
9478 v0.AddArg2(x, y)
9479 b.resetWithControl(BlockRISCV64BNEZ, v0)
9480 return true
9481 }
9482 }
9483
9484
9485 for b.Controls[0].Op == OpRISCV64FNED {
9486 v_0 := b.Controls[0]
9487 t := v_0.Type
9488 _ = v_0.Args[1]
9489 v_0_0 := v_0.Args[0]
9490 v_0_1 := v_0.Args[1]
9491 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
9492 x := v_0_0
9493 y := v_0_1
9494 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
9495 v0.AddArg2(x, y)
9496 b.resetWithControl(BlockRISCV64BNEZ, v0)
9497 return true
9498 }
9499 }
9500
9501
9502 for b.Controls[0].Op == OpRISCV64SUB {
9503 v_0 := b.Controls[0]
9504 y := v_0.Args[1]
9505 x := v_0.Args[0]
9506 b.resetWithControl2(BlockRISCV64BEQ, x, y)
9507 return true
9508 }
9509
9510
9511 for b.Controls[0].Op == OpRISCV64SLT {
9512 v_0 := b.Controls[0]
9513 y := v_0.Args[1]
9514 x := v_0.Args[0]
9515 b.resetWithControl2(BlockRISCV64BGE, x, y)
9516 return true
9517 }
9518
9519
9520 for b.Controls[0].Op == OpRISCV64SLTU {
9521 v_0 := b.Controls[0]
9522 y := v_0.Args[1]
9523 x := v_0.Args[0]
9524 b.resetWithControl2(BlockRISCV64BGEU, x, y)
9525 return true
9526 }
9527
9528
9529 for b.Controls[0].Op == OpRISCV64SLTI {
9530 v_0 := b.Controls[0]
9531 x := auxIntToInt64(v_0.AuxInt)
9532 y := v_0.Args[0]
9533 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
9534 v0.AuxInt = int64ToAuxInt(x)
9535 b.resetWithControl2(BlockRISCV64BGE, y, v0)
9536 return true
9537 }
9538
9539
9540 for b.Controls[0].Op == OpRISCV64SLTIU {
9541 v_0 := b.Controls[0]
9542 x := auxIntToInt64(v_0.AuxInt)
9543 y := v_0.Args[0]
9544 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
9545 v0.AuxInt = int64ToAuxInt(x)
9546 b.resetWithControl2(BlockRISCV64BGEU, y, v0)
9547 return true
9548 }
9549 case BlockRISCV64BGE:
9550
9551
9552 for b.Controls[0].Op == OpRISCV64MOVDconst {
9553 v_0 := b.Controls[0]
9554 if auxIntToInt64(v_0.AuxInt) != 0 {
9555 break
9556 }
9557 cond := b.Controls[1]
9558 b.resetWithControl(BlockRISCV64BLEZ, cond)
9559 return true
9560 }
9561
9562
9563 for b.Controls[1].Op == OpRISCV64MOVDconst {
9564 cond := b.Controls[0]
9565 v_1 := b.Controls[1]
9566 if auxIntToInt64(v_1.AuxInt) != 0 {
9567 break
9568 }
9569 b.resetWithControl(BlockRISCV64BGEZ, cond)
9570 return true
9571 }
9572 case BlockRISCV64BGEU:
9573
9574
9575 for b.Controls[0].Op == OpRISCV64MOVDconst {
9576 v_0 := b.Controls[0]
9577 if auxIntToInt64(v_0.AuxInt) != 0 {
9578 break
9579 }
9580 cond := b.Controls[1]
9581 b.resetWithControl(BlockRISCV64BEQZ, cond)
9582 return true
9583 }
9584 case BlockRISCV64BLT:
9585
9586
9587 for b.Controls[0].Op == OpRISCV64MOVDconst {
9588 v_0 := b.Controls[0]
9589 if auxIntToInt64(v_0.AuxInt) != 0 {
9590 break
9591 }
9592 cond := b.Controls[1]
9593 b.resetWithControl(BlockRISCV64BGTZ, cond)
9594 return true
9595 }
9596
9597
9598 for b.Controls[1].Op == OpRISCV64MOVDconst {
9599 cond := b.Controls[0]
9600 v_1 := b.Controls[1]
9601 if auxIntToInt64(v_1.AuxInt) != 0 {
9602 break
9603 }
9604 b.resetWithControl(BlockRISCV64BLTZ, cond)
9605 return true
9606 }
9607 case BlockRISCV64BLTU:
9608
9609
9610 for b.Controls[0].Op == OpRISCV64MOVDconst {
9611 v_0 := b.Controls[0]
9612 if auxIntToInt64(v_0.AuxInt) != 0 {
9613 break
9614 }
9615 cond := b.Controls[1]
9616 b.resetWithControl(BlockRISCV64BNEZ, cond)
9617 return true
9618 }
9619 case BlockRISCV64BNE:
9620
9621
9622 for b.Controls[0].Op == OpRISCV64MOVDconst {
9623 v_0 := b.Controls[0]
9624 if auxIntToInt64(v_0.AuxInt) != 0 {
9625 break
9626 }
9627 cond := b.Controls[1]
9628 b.resetWithControl(BlockRISCV64BNEZ, cond)
9629 return true
9630 }
9631
9632
9633 for b.Controls[1].Op == OpRISCV64MOVDconst {
9634 cond := b.Controls[0]
9635 v_1 := b.Controls[1]
9636 if auxIntToInt64(v_1.AuxInt) != 0 {
9637 break
9638 }
9639 b.resetWithControl(BlockRISCV64BNEZ, cond)
9640 return true
9641 }
9642 case BlockRISCV64BNEZ:
9643
9644
9645 for b.Controls[0].Op == OpRISCV64SEQZ {
9646 v_0 := b.Controls[0]
9647 x := v_0.Args[0]
9648 b.resetWithControl(BlockRISCV64BEQZ, x)
9649 return true
9650 }
9651
9652
9653 for b.Controls[0].Op == OpRISCV64SNEZ {
9654 v_0 := b.Controls[0]
9655 x := v_0.Args[0]
9656 b.resetWithControl(BlockRISCV64BNEZ, x)
9657 return true
9658 }
9659
9660
9661 for b.Controls[0].Op == OpRISCV64NEG {
9662 v_0 := b.Controls[0]
9663 x := v_0.Args[0]
9664 b.resetWithControl(BlockRISCV64BNEZ, x)
9665 return true
9666 }
9667
9668
9669 for b.Controls[0].Op == OpRISCV64FNES {
9670 v_0 := b.Controls[0]
9671 t := v_0.Type
9672 _ = v_0.Args[1]
9673 v_0_0 := v_0.Args[0]
9674 v_0_1 := v_0.Args[1]
9675 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
9676 x := v_0_0
9677 y := v_0_1
9678 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
9679 v0.AddArg2(x, y)
9680 b.resetWithControl(BlockRISCV64BEQZ, v0)
9681 return true
9682 }
9683 }
9684
9685
9686 for b.Controls[0].Op == OpRISCV64FNED {
9687 v_0 := b.Controls[0]
9688 t := v_0.Type
9689 _ = v_0.Args[1]
9690 v_0_0 := v_0.Args[0]
9691 v_0_1 := v_0.Args[1]
9692 for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
9693 x := v_0_0
9694 y := v_0_1
9695 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
9696 v0.AddArg2(x, y)
9697 b.resetWithControl(BlockRISCV64BEQZ, v0)
9698 return true
9699 }
9700 }
9701
9702
9703 for b.Controls[0].Op == OpRISCV64SUB {
9704 v_0 := b.Controls[0]
9705 y := v_0.Args[1]
9706 x := v_0.Args[0]
9707 b.resetWithControl2(BlockRISCV64BNE, x, y)
9708 return true
9709 }
9710
9711
9712 for b.Controls[0].Op == OpRISCV64SLT {
9713 v_0 := b.Controls[0]
9714 y := v_0.Args[1]
9715 x := v_0.Args[0]
9716 b.resetWithControl2(BlockRISCV64BLT, x, y)
9717 return true
9718 }
9719
9720
9721 for b.Controls[0].Op == OpRISCV64SLTU {
9722 v_0 := b.Controls[0]
9723 y := v_0.Args[1]
9724 x := v_0.Args[0]
9725 b.resetWithControl2(BlockRISCV64BLTU, x, y)
9726 return true
9727 }
9728
9729
9730 for b.Controls[0].Op == OpRISCV64SLTI {
9731 v_0 := b.Controls[0]
9732 x := auxIntToInt64(v_0.AuxInt)
9733 y := v_0.Args[0]
9734 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
9735 v0.AuxInt = int64ToAuxInt(x)
9736 b.resetWithControl2(BlockRISCV64BLT, y, v0)
9737 return true
9738 }
9739
9740
9741 for b.Controls[0].Op == OpRISCV64SLTIU {
9742 v_0 := b.Controls[0]
9743 x := auxIntToInt64(v_0.AuxInt)
9744 y := v_0.Args[0]
9745 v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
9746 v0.AuxInt = int64ToAuxInt(x)
9747 b.resetWithControl2(BlockRISCV64BLTU, y, v0)
9748 return true
9749 }
9750 case BlockIf:
9751
9752
9753 for {
9754 cond := b.Controls[0]
9755 v0 := b.NewValue0(cond.Pos, OpRISCV64MOVBUreg, typ.UInt64)
9756 v0.AddArg(cond)
9757 b.resetWithControl(BlockRISCV64BNEZ, v0)
9758 return true
9759 }
9760 }
9761 return false
9762 }
9763
View as plain text