src/cmd/compile/internal/ssa/rewriteRISCV64.go

   1 // Code generated from _gen/RISCV64.rules using 'go generate'; DO NOT EDIT.
   2
   3 package ssa
   4
   5 import "math"
   6 import "cmd/compile/internal/types"
   7
   8 func rewriteValueRISCV64(v *Value) bool {
   9         switch v.Op {
  10         case OpAbs:
  11                 v.Op = OpRISCV64FABSD
  12                 return true
  13         case OpAdd16:
  14                 v.Op = OpRISCV64ADD
  15                 return true
  16         case OpAdd32:
  17                 v.Op = OpRISCV64ADD
  18                 return true
  19         case OpAdd32F:
  20                 v.Op = OpRISCV64FADDS
  21                 return true
  22         case OpAdd64:
  23                 v.Op = OpRISCV64ADD
  24                 return true
  25         case OpAdd64F:
  26                 v.Op = OpRISCV64FADDD
  27                 return true
  28         case OpAdd8:
  29                 v.Op = OpRISCV64ADD
  30                 return true
  31         case OpAddPtr:
  32                 v.Op = OpRISCV64ADD
  33                 return true
  34         case OpAddr:
  35                 return rewriteValueRISCV64_OpAddr(v)
  36         case OpAnd16:
  37                 v.Op = OpRISCV64AND
  38                 return true
  39         case OpAnd32:
  40                 v.Op = OpRISCV64AND
  41                 return true
  42         case OpAnd64:
  43                 v.Op = OpRISCV64AND
  44                 return true
  45         case OpAnd8:
  46                 v.Op = OpRISCV64AND
  47                 return true
  48         case OpAndB:
  49                 v.Op = OpRISCV64AND
  50                 return true
  51         case OpAtomicAdd32:
  52                 v.Op = OpRISCV64LoweredAtomicAdd32
  53                 return true
  54         case OpAtomicAdd64:
  55                 v.Op = OpRISCV64LoweredAtomicAdd64
  56                 return true
  57         case OpAtomicAnd32:
  58                 v.Op = OpRISCV64LoweredAtomicAnd32
  59                 return true
  60         case OpAtomicAnd8:
  61                 return rewriteValueRISCV64_OpAtomicAnd8(v)
  62         case OpAtomicCompareAndSwap32:
  63                 return rewriteValueRISCV64_OpAtomicCompareAndSwap32(v)
  64         case OpAtomicCompareAndSwap64:
  65                 v.Op = OpRISCV64LoweredAtomicCas64
  66                 return true
  67         case OpAtomicExchange32:
  68                 v.Op = OpRISCV64LoweredAtomicExchange32
  69                 return true
  70         case OpAtomicExchange64:
  71                 v.Op = OpRISCV64LoweredAtomicExchange64
  72                 return true
  73         case OpAtomicLoad32:
  74                 v.Op = OpRISCV64LoweredAtomicLoad32
  75                 return true
  76         case OpAtomicLoad64:
  77                 v.Op = OpRISCV64LoweredAtomicLoad64
  78                 return true
  79         case OpAtomicLoad8:
  80                 v.Op = OpRISCV64LoweredAtomicLoad8
  81                 return true
  82         case OpAtomicLoadPtr:
  83                 v.Op = OpRISCV64LoweredAtomicLoad64
  84                 return true
  85         case OpAtomicOr32:
  86                 v.Op = OpRISCV64LoweredAtomicOr32
  87                 return true
  88         case OpAtomicOr8:
  89                 return rewriteValueRISCV64_OpAtomicOr8(v)
  90         case OpAtomicStore32:
  91                 v.Op = OpRISCV64LoweredAtomicStore32
  92                 return true
  93         case OpAtomicStore64:
  94                 v.Op = OpRISCV64LoweredAtomicStore64
  95                 return true
  96         case OpAtomicStore8:
  97                 v.Op = OpRISCV64LoweredAtomicStore8
  98                 return true
  99         case OpAtomicStorePtrNoWB:
 100                 v.Op = OpRISCV64LoweredAtomicStore64
 101                 return true
 102         case OpAvg64u:
 103                 return rewriteValueRISCV64_OpAvg64u(v)
 104         case OpClosureCall:
 105                 v.Op = OpRISCV64CALLclosure
 106                 return true
 107         case OpCom16:
 108                 v.Op = OpRISCV64NOT
 109                 return true
 110         case OpCom32:
 111                 v.Op = OpRISCV64NOT
 112                 return true
 113         case OpCom64:
 114                 v.Op = OpRISCV64NOT
 115                 return true
 116         case OpCom8:
 117                 v.Op = OpRISCV64NOT
 118                 return true
 119         case OpConst16:
 120                 return rewriteValueRISCV64_OpConst16(v)
 121         case OpConst32:
 122                 return rewriteValueRISCV64_OpConst32(v)
 123         case OpConst32F:
 124                 return rewriteValueRISCV64_OpConst32F(v)
 125         case OpConst64:
 126                 return rewriteValueRISCV64_OpConst64(v)
 127         case OpConst64F:
 128                 return rewriteValueRISCV64_OpConst64F(v)
 129         case OpConst8:
 130                 return rewriteValueRISCV64_OpConst8(v)
 131         case OpConstBool:
 132                 return rewriteValueRISCV64_OpConstBool(v)
 133         case OpConstNil:
 134                 return rewriteValueRISCV64_OpConstNil(v)
 135         case OpConvert:
 136                 v.Op = OpRISCV64MOVconvert
 137                 return true
 138         case OpCopysign:
 139                 v.Op = OpRISCV64FSGNJD
 140                 return true
 141         case OpCvt32Fto32:
 142                 v.Op = OpRISCV64FCVTWS
 143                 return true
 144         case OpCvt32Fto64:
 145                 v.Op = OpRISCV64FCVTLS
 146                 return true
 147         case OpCvt32Fto64F:
 148                 v.Op = OpRISCV64FCVTDS
 149                 return true
 150         case OpCvt32to32F:
 151                 v.Op = OpRISCV64FCVTSW
 152                 return true
 153         case OpCvt32to64F:
 154                 v.Op = OpRISCV64FCVTDW
 155                 return true
 156         case OpCvt64Fto32:
 157                 v.Op = OpRISCV64FCVTWD
 158                 return true
 159         case OpCvt64Fto32F:
 160                 v.Op = OpRISCV64FCVTSD
 161                 return true
 162         case OpCvt64Fto64:
 163                 v.Op = OpRISCV64FCVTLD
 164                 return true
 165         case OpCvt64to32F:
 166                 v.Op = OpRISCV64FCVTSL
 167                 return true
 168         case OpCvt64to64F:
 169                 v.Op = OpRISCV64FCVTDL
 170                 return true
 171         case OpCvtBoolToUint8:
 172                 v.Op = OpCopy
 173                 return true
 174         case OpDiv16:
 175                 return rewriteValueRISCV64_OpDiv16(v)
 176         case OpDiv16u:
 177                 return rewriteValueRISCV64_OpDiv16u(v)
 178         case OpDiv32:
 179                 return rewriteValueRISCV64_OpDiv32(v)
 180         case OpDiv32F:
 181                 v.Op = OpRISCV64FDIVS
 182                 return true
 183         case OpDiv32u:
 184                 v.Op = OpRISCV64DIVUW
 185                 return true
 186         case OpDiv64:
 187                 return rewriteValueRISCV64_OpDiv64(v)
 188         case OpDiv64F:
 189                 v.Op = OpRISCV64FDIVD
 190                 return true
 191         case OpDiv64u:
 192                 v.Op = OpRISCV64DIVU
 193                 return true
 194         case OpDiv8:
 195                 return rewriteValueRISCV64_OpDiv8(v)
 196         case OpDiv8u:
 197                 return rewriteValueRISCV64_OpDiv8u(v)
 198         case OpEq16:
 199                 return rewriteValueRISCV64_OpEq16(v)
 200         case OpEq32:
 201                 return rewriteValueRISCV64_OpEq32(v)
 202         case OpEq32F:
 203                 v.Op = OpRISCV64FEQS
 204                 return true
 205         case OpEq64:
 206                 return rewriteValueRISCV64_OpEq64(v)
 207         case OpEq64F:
 208                 v.Op = OpRISCV64FEQD
 209                 return true
 210         case OpEq8:
 211                 return rewriteValueRISCV64_OpEq8(v)
 212         case OpEqB:
 213                 return rewriteValueRISCV64_OpEqB(v)
 214         case OpEqPtr:
 215                 return rewriteValueRISCV64_OpEqPtr(v)
 216         case OpFMA:
 217                 v.Op = OpRISCV64FMADDD
 218                 return true
 219         case OpGetCallerPC:
 220                 v.Op = OpRISCV64LoweredGetCallerPC
 221                 return true
 222         case OpGetCallerSP:
 223                 v.Op = OpRISCV64LoweredGetCallerSP
 224                 return true
 225         case OpGetClosurePtr:
 226                 v.Op = OpRISCV64LoweredGetClosurePtr
 227                 return true
 228         case OpHmul32:
 229                 return rewriteValueRISCV64_OpHmul32(v)
 230         case OpHmul32u:
 231                 return rewriteValueRISCV64_OpHmul32u(v)
 232         case OpHmul64:
 233                 v.Op = OpRISCV64MULH
 234                 return true
 235         case OpHmul64u:
 236                 v.Op = OpRISCV64MULHU
 237                 return true
 238         case OpInterCall:
 239                 v.Op = OpRISCV64CALLinter
 240                 return true
 241         case OpIsInBounds:
 242                 v.Op = OpLess64U
 243                 return true
 244         case OpIsNonNil:
 245                 v.Op = OpRISCV64SNEZ
 246                 return true
 247         case OpIsSliceInBounds:
 248                 v.Op = OpLeq64U
 249                 return true
 250         case OpLeq16:
 251                 return rewriteValueRISCV64_OpLeq16(v)
 252         case OpLeq16U:
 253                 return rewriteValueRISCV64_OpLeq16U(v)
 254         case OpLeq32:
 255                 return rewriteValueRISCV64_OpLeq32(v)
 256         case OpLeq32F:
 257                 v.Op = OpRISCV64FLES
 258                 return true
 259         case OpLeq32U:
 260                 return rewriteValueRISCV64_OpLeq32U(v)
 261         case OpLeq64:
 262                 return rewriteValueRISCV64_OpLeq64(v)
 263         case OpLeq64F:
 264                 v.Op = OpRISCV64FLED
 265                 return true
 266         case OpLeq64U:
 267                 return rewriteValueRISCV64_OpLeq64U(v)
 268         case OpLeq8:
 269                 return rewriteValueRISCV64_OpLeq8(v)
 270         case OpLeq8U:
 271                 return rewriteValueRISCV64_OpLeq8U(v)
 272         case OpLess16:
 273                 return rewriteValueRISCV64_OpLess16(v)
 274         case OpLess16U:
 275                 return rewriteValueRISCV64_OpLess16U(v)
 276         case OpLess32:
 277                 return rewriteValueRISCV64_OpLess32(v)
 278         case OpLess32F:
 279                 v.Op = OpRISCV64FLTS
 280                 return true
 281         case OpLess32U:
 282                 return rewriteValueRISCV64_OpLess32U(v)
 283         case OpLess64:
 284                 v.Op = OpRISCV64SLT
 285                 return true
 286         case OpLess64F:
 287                 v.Op = OpRISCV64FLTD
 288                 return true
 289         case OpLess64U:
 290                 v.Op = OpRISCV64SLTU
 291                 return true
 292         case OpLess8:
 293                 return rewriteValueRISCV64_OpLess8(v)
 294         case OpLess8U:
 295                 return rewriteValueRISCV64_OpLess8U(v)
 296         case OpLoad:
 297                 return rewriteValueRISCV64_OpLoad(v)
 298         case OpLocalAddr:
 299                 return rewriteValueRISCV64_OpLocalAddr(v)
 300         case OpLsh16x16:
 301                 return rewriteValueRISCV64_OpLsh16x16(v)
 302         case OpLsh16x32:
 303                 return rewriteValueRISCV64_OpLsh16x32(v)
 304         case OpLsh16x64:
 305                 return rewriteValueRISCV64_OpLsh16x64(v)
 306         case OpLsh16x8:
 307                 return rewriteValueRISCV64_OpLsh16x8(v)
 308         case OpLsh32x16:
 309                 return rewriteValueRISCV64_OpLsh32x16(v)
 310         case OpLsh32x32:
 311                 return rewriteValueRISCV64_OpLsh32x32(v)
 312         case OpLsh32x64:
 313                 return rewriteValueRISCV64_OpLsh32x64(v)
 314         case OpLsh32x8:
 315                 return rewriteValueRISCV64_OpLsh32x8(v)
 316         case OpLsh64x16:
 317                 return rewriteValueRISCV64_OpLsh64x16(v)
 318         case OpLsh64x32:
 319                 return rewriteValueRISCV64_OpLsh64x32(v)
 320         case OpLsh64x64:
 321                 return rewriteValueRISCV64_OpLsh64x64(v)
 322         case OpLsh64x8:
 323                 return rewriteValueRISCV64_OpLsh64x8(v)
 324         case OpLsh8x16:
 325                 return rewriteValueRISCV64_OpLsh8x16(v)
 326         case OpLsh8x32:
 327                 return rewriteValueRISCV64_OpLsh8x32(v)
 328         case OpLsh8x64:
 329                 return rewriteValueRISCV64_OpLsh8x64(v)
 330         case OpLsh8x8:
 331                 return rewriteValueRISCV64_OpLsh8x8(v)
 332         case OpMod16:
 333                 return rewriteValueRISCV64_OpMod16(v)
 334         case OpMod16u:
 335                 return rewriteValueRISCV64_OpMod16u(v)
 336         case OpMod32:
 337                 return rewriteValueRISCV64_OpMod32(v)
 338         case OpMod32u:
 339                 v.Op = OpRISCV64REMUW
 340                 return true
 341         case OpMod64:
 342                 return rewriteValueRISCV64_OpMod64(v)
 343         case OpMod64u:
 344                 v.Op = OpRISCV64REMU
 345                 return true
 346         case OpMod8:
 347                 return rewriteValueRISCV64_OpMod8(v)
 348         case OpMod8u:
 349                 return rewriteValueRISCV64_OpMod8u(v)
 350         case OpMove:
 351                 return rewriteValueRISCV64_OpMove(v)
 352         case OpMul16:
 353                 return rewriteValueRISCV64_OpMul16(v)
 354         case OpMul32:
 355                 v.Op = OpRISCV64MULW
 356                 return true
 357         case OpMul32F:
 358                 v.Op = OpRISCV64FMULS
 359                 return true
 360         case OpMul64:
 361                 v.Op = OpRISCV64MUL
 362                 return true
 363         case OpMul64F:
 364                 v.Op = OpRISCV64FMULD
 365                 return true
 366         case OpMul64uhilo:
 367                 v.Op = OpRISCV64LoweredMuluhilo
 368                 return true
 369         case OpMul64uover:
 370                 v.Op = OpRISCV64LoweredMuluover
 371                 return true
 372         case OpMul8:
 373                 return rewriteValueRISCV64_OpMul8(v)
 374         case OpNeg16:
 375                 v.Op = OpRISCV64NEG
 376                 return true
 377         case OpNeg32:
 378                 v.Op = OpRISCV64NEG
 379                 return true
 380         case OpNeg32F:
 381                 v.Op = OpRISCV64FNEGS
 382                 return true
 383         case OpNeg64:
 384                 v.Op = OpRISCV64NEG
 385                 return true
 386         case OpNeg64F:
 387                 v.Op = OpRISCV64FNEGD
 388                 return true
 389         case OpNeg8:
 390                 v.Op = OpRISCV64NEG
 391                 return true
 392         case OpNeq16:
 393                 return rewriteValueRISCV64_OpNeq16(v)
 394         case OpNeq32:
 395                 return rewriteValueRISCV64_OpNeq32(v)
 396         case OpNeq32F:
 397                 v.Op = OpRISCV64FNES
 398                 return true
 399         case OpNeq64:
 400                 return rewriteValueRISCV64_OpNeq64(v)
 401         case OpNeq64F:
 402                 v.Op = OpRISCV64FNED
 403                 return true
 404         case OpNeq8:
 405                 return rewriteValueRISCV64_OpNeq8(v)
 406         case OpNeqB:
 407                 return rewriteValueRISCV64_OpNeqB(v)
 408         case OpNeqPtr:
 409                 return rewriteValueRISCV64_OpNeqPtr(v)
 410         case OpNilCheck:
 411                 v.Op = OpRISCV64LoweredNilCheck
 412                 return true
 413         case OpNot:
 414                 v.Op = OpRISCV64SEQZ
 415                 return true
 416         case OpOffPtr:
 417                 return rewriteValueRISCV64_OpOffPtr(v)
 418         case OpOr16:
 419                 v.Op = OpRISCV64OR
 420                 return true
 421         case OpOr32:
 422                 v.Op = OpRISCV64OR
 423                 return true
 424         case OpOr64:
 425                 v.Op = OpRISCV64OR
 426                 return true
 427         case OpOr8:
 428                 v.Op = OpRISCV64OR
 429                 return true
 430         case OpOrB:
 431                 v.Op = OpRISCV64OR
 432                 return true
 433         case OpPanicBounds:
 434                 return rewriteValueRISCV64_OpPanicBounds(v)
 435         case OpRISCV64ADD:
 436                 return rewriteValueRISCV64_OpRISCV64ADD(v)
 437         case OpRISCV64ADDI:
 438                 return rewriteValueRISCV64_OpRISCV64ADDI(v)
 439         case OpRISCV64AND:
 440                 return rewriteValueRISCV64_OpRISCV64AND(v)
 441         case OpRISCV64ANDI:
 442                 return rewriteValueRISCV64_OpRISCV64ANDI(v)
 443         case OpRISCV64FMADDD:
 444                 return rewriteValueRISCV64_OpRISCV64FMADDD(v)
 445         case OpRISCV64FMSUBD:
 446                 return rewriteValueRISCV64_OpRISCV64FMSUBD(v)
 447         case OpRISCV64FNMADDD:
 448                 return rewriteValueRISCV64_OpRISCV64FNMADDD(v)
 449         case OpRISCV64FNMSUBD:
 450                 return rewriteValueRISCV64_OpRISCV64FNMSUBD(v)
 451         case OpRISCV64MOVBUload:
 452                 return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
 453         case OpRISCV64MOVBUreg:
 454                 return rewriteValueRISCV64_OpRISCV64MOVBUreg(v)
 455         case OpRISCV64MOVBload:
 456                 return rewriteValueRISCV64_OpRISCV64MOVBload(v)
 457         case OpRISCV64MOVBreg:
 458                 return rewriteValueRISCV64_OpRISCV64MOVBreg(v)
 459         case OpRISCV64MOVBstore:
 460                 return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
 461         case OpRISCV64MOVBstorezero:
 462                 return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
 463         case OpRISCV64MOVDload:
 464                 return rewriteValueRISCV64_OpRISCV64MOVDload(v)
 465         case OpRISCV64MOVDnop:
 466                 return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
 467         case OpRISCV64MOVDreg:
 468                 return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
 469         case OpRISCV64MOVDstore:
 470                 return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
 471         case OpRISCV64MOVDstorezero:
 472                 return rewriteValueRISCV64_OpRISCV64MOVDstorezero(v)
 473         case OpRISCV64MOVHUload:
 474                 return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
 475         case OpRISCV64MOVHUreg:
 476                 return rewriteValueRISCV64_OpRISCV64MOVHUreg(v)
 477         case OpRISCV64MOVHload:
 478                 return rewriteValueRISCV64_OpRISCV64MOVHload(v)
 479         case OpRISCV64MOVHreg:
 480                 return rewriteValueRISCV64_OpRISCV64MOVHreg(v)
 481         case OpRISCV64MOVHstore:
 482                 return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
 483         case OpRISCV64MOVHstorezero:
 484                 return rewriteValueRISCV64_OpRISCV64MOVHstorezero(v)
 485         case OpRISCV64MOVWUload:
 486                 return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
 487         case OpRISCV64MOVWUreg:
 488                 return rewriteValueRISCV64_OpRISCV64MOVWUreg(v)
 489         case OpRISCV64MOVWload:
 490                 return rewriteValueRISCV64_OpRISCV64MOVWload(v)
 491         case OpRISCV64MOVWreg:
 492                 return rewriteValueRISCV64_OpRISCV64MOVWreg(v)
 493         case OpRISCV64MOVWstore:
 494                 return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
 495         case OpRISCV64MOVWstorezero:
 496                 return rewriteValueRISCV64_OpRISCV64MOVWstorezero(v)
 497         case OpRISCV64NEG:
 498                 return rewriteValueRISCV64_OpRISCV64NEG(v)
 499         case OpRISCV64NEGW:
 500                 return rewriteValueRISCV64_OpRISCV64NEGW(v)
 501         case OpRISCV64OR:
 502                 return rewriteValueRISCV64_OpRISCV64OR(v)
 503         case OpRISCV64ORI:
 504                 return rewriteValueRISCV64_OpRISCV64ORI(v)
 505         case OpRISCV64SEQZ:
 506                 return rewriteValueRISCV64_OpRISCV64SEQZ(v)
 507         case OpRISCV64SLL:
 508                 return rewriteValueRISCV64_OpRISCV64SLL(v)
 509         case OpRISCV64SLLI:
 510                 return rewriteValueRISCV64_OpRISCV64SLLI(v)
 511         case OpRISCV64SLT:
 512                 return rewriteValueRISCV64_OpRISCV64SLT(v)
 513         case OpRISCV64SLTI:
 514                 return rewriteValueRISCV64_OpRISCV64SLTI(v)
 515         case OpRISCV64SLTIU:
 516                 return rewriteValueRISCV64_OpRISCV64SLTIU(v)
 517         case OpRISCV64SLTU:
 518                 return rewriteValueRISCV64_OpRISCV64SLTU(v)
 519         case OpRISCV64SNEZ:
 520                 return rewriteValueRISCV64_OpRISCV64SNEZ(v)
 521         case OpRISCV64SRA:
 522                 return rewriteValueRISCV64_OpRISCV64SRA(v)
 523         case OpRISCV64SRAI:
 524                 return rewriteValueRISCV64_OpRISCV64SRAI(v)
 525         case OpRISCV64SRL:
 526                 return rewriteValueRISCV64_OpRISCV64SRL(v)
 527         case OpRISCV64SRLI:
 528                 return rewriteValueRISCV64_OpRISCV64SRLI(v)
 529         case OpRISCV64SUB:
 530                 return rewriteValueRISCV64_OpRISCV64SUB(v)
 531         case OpRISCV64SUBW:
 532                 return rewriteValueRISCV64_OpRISCV64SUBW(v)
 533         case OpRISCV64XOR:
 534                 return rewriteValueRISCV64_OpRISCV64XOR(v)
 535         case OpRotateLeft16:
 536                 return rewriteValueRISCV64_OpRotateLeft16(v)
 537         case OpRotateLeft32:
 538                 return rewriteValueRISCV64_OpRotateLeft32(v)
 539         case OpRotateLeft64:
 540                 return rewriteValueRISCV64_OpRotateLeft64(v)
 541         case OpRotateLeft8:
 542                 return rewriteValueRISCV64_OpRotateLeft8(v)
 543         case OpRound32F:
 544                 v.Op = OpCopy
 545                 return true
 546         case OpRound64F:
 547                 v.Op = OpCopy
 548                 return true
 549         case OpRsh16Ux16:
 550                 return rewriteValueRISCV64_OpRsh16Ux16(v)
 551         case OpRsh16Ux32:
 552                 return rewriteValueRISCV64_OpRsh16Ux32(v)
 553         case OpRsh16Ux64:
 554                 return rewriteValueRISCV64_OpRsh16Ux64(v)
 555         case OpRsh16Ux8:
 556                 return rewriteValueRISCV64_OpRsh16Ux8(v)
 557         case OpRsh16x16:
 558                 return rewriteValueRISCV64_OpRsh16x16(v)
 559         case OpRsh16x32:
 560                 return rewriteValueRISCV64_OpRsh16x32(v)
 561         case OpRsh16x64:
 562                 return rewriteValueRISCV64_OpRsh16x64(v)
 563         case OpRsh16x8:
 564                 return rewriteValueRISCV64_OpRsh16x8(v)
 565         case OpRsh32Ux16:
 566                 return rewriteValueRISCV64_OpRsh32Ux16(v)
 567         case OpRsh32Ux32:
 568                 return rewriteValueRISCV64_OpRsh32Ux32(v)
 569         case OpRsh32Ux64:
 570                 return rewriteValueRISCV64_OpRsh32Ux64(v)
 571         case OpRsh32Ux8:
 572                 return rewriteValueRISCV64_OpRsh32Ux8(v)
 573         case OpRsh32x16:
 574                 return rewriteValueRISCV64_OpRsh32x16(v)
 575         case OpRsh32x32:
 576                 return rewriteValueRISCV64_OpRsh32x32(v)
 577         case OpRsh32x64:
 578                 return rewriteValueRISCV64_OpRsh32x64(v)
 579         case OpRsh32x8:
 580                 return rewriteValueRISCV64_OpRsh32x8(v)
 581         case OpRsh64Ux16:
 582                 return rewriteValueRISCV64_OpRsh64Ux16(v)
 583         case OpRsh64Ux32:
 584                 return rewriteValueRISCV64_OpRsh64Ux32(v)
 585         case OpRsh64Ux64:
 586                 return rewriteValueRISCV64_OpRsh64Ux64(v)
 587         case OpRsh64Ux8:
 588                 return rewriteValueRISCV64_OpRsh64Ux8(v)
 589         case OpRsh64x16:
 590                 return rewriteValueRISCV64_OpRsh64x16(v)
 591         case OpRsh64x32:
 592                 return rewriteValueRISCV64_OpRsh64x32(v)
 593         case OpRsh64x64:
 594                 return rewriteValueRISCV64_OpRsh64x64(v)
 595         case OpRsh64x8:
 596                 return rewriteValueRISCV64_OpRsh64x8(v)
 597         case OpRsh8Ux16:
 598                 return rewriteValueRISCV64_OpRsh8Ux16(v)
 599         case OpRsh8Ux32:
 600                 return rewriteValueRISCV64_OpRsh8Ux32(v)
 601         case OpRsh8Ux64:
 602                 return rewriteValueRISCV64_OpRsh8Ux64(v)
 603         case OpRsh8Ux8:
 604                 return rewriteValueRISCV64_OpRsh8Ux8(v)
 605         case OpRsh8x16:
 606                 return rewriteValueRISCV64_OpRsh8x16(v)
 607         case OpRsh8x32:
 608                 return rewriteValueRISCV64_OpRsh8x32(v)
 609         case OpRsh8x64:
 610                 return rewriteValueRISCV64_OpRsh8x64(v)
 611         case OpRsh8x8:
 612                 return rewriteValueRISCV64_OpRsh8x8(v)
 613         case OpSelect0:
 614                 return rewriteValueRISCV64_OpSelect0(v)
 615         case OpSelect1:
 616                 return rewriteValueRISCV64_OpSelect1(v)
 617         case OpSignExt16to32:
 618                 v.Op = OpRISCV64MOVHreg
 619                 return true
 620         case OpSignExt16to64:
 621                 v.Op = OpRISCV64MOVHreg
 622                 return true
 623         case OpSignExt32to64:
 624                 v.Op = OpRISCV64MOVWreg
 625                 return true
 626         case OpSignExt8to16:
 627                 v.Op = OpRISCV64MOVBreg
 628                 return true
 629         case OpSignExt8to32:
 630                 v.Op = OpRISCV64MOVBreg
 631                 return true
 632         case OpSignExt8to64:
 633                 v.Op = OpRISCV64MOVBreg
 634                 return true
 635         case OpSlicemask:
 636                 return rewriteValueRISCV64_OpSlicemask(v)
 637         case OpSqrt:
 638                 v.Op = OpRISCV64FSQRTD
 639                 return true
 640         case OpSqrt32:
 641                 v.Op = OpRISCV64FSQRTS
 642                 return true
 643         case OpStaticCall:
 644                 v.Op = OpRISCV64CALLstatic
 645                 return true
 646         case OpStore:
 647                 return rewriteValueRISCV64_OpStore(v)
 648         case OpSub16:
 649                 v.Op = OpRISCV64SUB
 650                 return true
 651         case OpSub32:
 652                 v.Op = OpRISCV64SUB
 653                 return true
 654         case OpSub32F:
 655                 v.Op = OpRISCV64FSUBS
 656                 return true
 657         case OpSub64:
 658                 v.Op = OpRISCV64SUB
 659                 return true
 660         case OpSub64F:
 661                 v.Op = OpRISCV64FSUBD
 662                 return true
 663         case OpSub8:
 664                 v.Op = OpRISCV64SUB
 665                 return true
 666         case OpSubPtr:
 667                 v.Op = OpRISCV64SUB
 668                 return true
 669         case OpTailCall:
 670                 v.Op = OpRISCV64CALLtail
 671                 return true
 672         case OpTrunc16to8:
 673                 v.Op = OpCopy
 674                 return true
 675         case OpTrunc32to16:
 676                 v.Op = OpCopy
 677                 return true
 678         case OpTrunc32to8:
 679                 v.Op = OpCopy
 680                 return true
 681         case OpTrunc64to16:
 682                 v.Op = OpCopy
 683                 return true
 684         case OpTrunc64to32:
 685                 v.Op = OpCopy
 686                 return true
 687         case OpTrunc64to8:
 688                 v.Op = OpCopy
 689                 return true
 690         case OpWB:
 691                 v.Op = OpRISCV64LoweredWB
 692                 return true
 693         case OpXor16:
 694                 v.Op = OpRISCV64XOR
 695                 return true
 696         case OpXor32:
 697                 v.Op = OpRISCV64XOR
 698                 return true
 699         case OpXor64:
 700                 v.Op = OpRISCV64XOR
 701                 return true
 702         case OpXor8:
 703                 v.Op = OpRISCV64XOR
 704                 return true
 705         case OpZero:
 706                 return rewriteValueRISCV64_OpZero(v)
 707         case OpZeroExt16to32:
 708                 v.Op = OpRISCV64MOVHUreg
 709                 return true
 710         case OpZeroExt16to64:
 711                 v.Op = OpRISCV64MOVHUreg
 712                 return true
 713         case OpZeroExt32to64:
 714                 v.Op = OpRISCV64MOVWUreg
 715                 return true
 716         case OpZeroExt8to16:
 717                 v.Op = OpRISCV64MOVBUreg
 718                 return true
 719         case OpZeroExt8to32:
 720                 v.Op = OpRISCV64MOVBUreg
 721                 return true
 722         case OpZeroExt8to64:
 723                 v.Op = OpRISCV64MOVBUreg
 724                 return true
 725         }
 726         return false
 727 }
 728 func rewriteValueRISCV64_OpAddr(v *Value) bool {
 729         v_0 := v.Args[0]
 730         // match: (Addr {sym} base)
 731         // result: (MOVaddr {sym} [0] base)
 732         for {
 733                 sym := auxToSym(v.Aux)
 734                 base := v_0
 735                 v.reset(OpRISCV64MOVaddr)
 736                 v.AuxInt = int32ToAuxInt(0)
 737                 v.Aux = symToAux(sym)
 738                 v.AddArg(base)
 739                 return true
 740         }
 741 }
 742 func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool {
 743         v_2 := v.Args[2]
 744         v_1 := v.Args[1]
 745         v_0 := v.Args[0]
 746         b := v.Block
 747         typ := &b.Func.Config.Types
 748         // match: (AtomicAnd8 ptr val mem)
 749         // result: (LoweredAtomicAnd32 (ANDI <typ.Uintptr> [^3] ptr) (NOT <typ.UInt32> (SLL <typ.UInt32> (XORI <typ.UInt32> [0xff] (ZeroExt8to32 val)) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr)))) mem)
 750         for {
 751                 ptr := v_0
 752                 val := v_1
 753                 mem := v_2
 754                 v.reset(OpRISCV64LoweredAtomicAnd32)
 755                 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
 756                 v0.AuxInt = int64ToAuxInt(^3)
 757                 v0.AddArg(ptr)
 758                 v1 := b.NewValue0(v.Pos, OpRISCV64NOT, typ.UInt32)
 759                 v2 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
 760                 v3 := b.NewValue0(v.Pos, OpRISCV64XORI, typ.UInt32)
 761                 v3.AuxInt = int64ToAuxInt(0xff)
 762                 v4 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 763                 v4.AddArg(val)
 764                 v3.AddArg(v4)
 765                 v5 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
 766                 v5.AuxInt = int64ToAuxInt(3)
 767                 v6 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
 768                 v6.AuxInt = int64ToAuxInt(3)
 769                 v6.AddArg(ptr)
 770                 v5.AddArg(v6)
 771                 v2.AddArg2(v3, v5)
 772                 v1.AddArg(v2)
 773                 v.AddArg3(v0, v1, mem)
 774                 return true
 775         }
 776 }
 777 func rewriteValueRISCV64_OpAtomicCompareAndSwap32(v *Value) bool {
 778         v_3 := v.Args[3]
 779         v_2 := v.Args[2]
 780         v_1 := v.Args[1]
 781         v_0 := v.Args[0]
 782         b := v.Block
 783         typ := &b.Func.Config.Types
 784         // match: (AtomicCompareAndSwap32 ptr old new mem)
 785         // result: (LoweredAtomicCas32 ptr (SignExt32to64 old) new mem)
 786         for {
 787                 ptr := v_0
 788                 old := v_1
 789                 new := v_2
 790                 mem := v_3
 791                 v.reset(OpRISCV64LoweredAtomicCas32)
 792                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
 793                 v0.AddArg(old)
 794                 v.AddArg4(ptr, v0, new, mem)
 795                 return true
 796         }
 797 }
 798 func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool {
 799         v_2 := v.Args[2]
 800         v_1 := v.Args[1]
 801         v_0 := v.Args[0]
 802         b := v.Block
 803         typ := &b.Func.Config.Types
 804         // match: (AtomicOr8 ptr val mem)
 805         // result: (LoweredAtomicOr32 (ANDI <typ.Uintptr> [^3] ptr) (SLL <typ.UInt32> (ZeroExt8to32 val) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr))) mem)
 806         for {
 807                 ptr := v_0
 808                 val := v_1
 809                 mem := v_2
 810                 v.reset(OpRISCV64LoweredAtomicOr32)
 811                 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
 812                 v0.AuxInt = int64ToAuxInt(^3)
 813                 v0.AddArg(ptr)
 814                 v1 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
 815                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 816                 v2.AddArg(val)
 817                 v3 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
 818                 v3.AuxInt = int64ToAuxInt(3)
 819                 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
 820                 v4.AuxInt = int64ToAuxInt(3)
 821                 v4.AddArg(ptr)
 822                 v3.AddArg(v4)
 823                 v1.AddArg2(v2, v3)
 824                 v.AddArg3(v0, v1, mem)
 825                 return true
 826         }
 827 }
 828 func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
 829         v_1 := v.Args[1]
 830         v_0 := v.Args[0]
 831         b := v.Block
 832         // match: (Avg64u <t> x y)
 833         // result: (ADD (ADD <t> (SRLI <t> [1] x) (SRLI <t> [1] y)) (ANDI <t> [1] (AND <t> x y)))
 834         for {
 835                 t := v.Type
 836                 x := v_0
 837                 y := v_1
 838                 v.reset(OpRISCV64ADD)
 839                 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, t)
 840                 v1 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
 841                 v1.AuxInt = int64ToAuxInt(1)
 842                 v1.AddArg(x)
 843                 v2 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
 844                 v2.AuxInt = int64ToAuxInt(1)
 845                 v2.AddArg(y)
 846                 v0.AddArg2(v1, v2)
 847                 v3 := b.NewValue0(v.Pos, OpRISCV64ANDI, t)
 848                 v3.AuxInt = int64ToAuxInt(1)
 849                 v4 := b.NewValue0(v.Pos, OpRISCV64AND, t)
 850                 v4.AddArg2(x, y)
 851                 v3.AddArg(v4)
 852                 v.AddArg2(v0, v3)
 853                 return true
 854         }
 855 }
 856 func rewriteValueRISCV64_OpConst16(v *Value) bool {
 857         // match: (Const16 [val])
 858         // result: (MOVDconst [int64(val)])
 859         for {
 860                 val := auxIntToInt16(v.AuxInt)
 861                 v.reset(OpRISCV64MOVDconst)
 862                 v.AuxInt = int64ToAuxInt(int64(val))
 863                 return true
 864         }
 865 }
 866 func rewriteValueRISCV64_OpConst32(v *Value) bool {
 867         // match: (Const32 [val])
 868         // result: (MOVDconst [int64(val)])
 869         for {
 870                 val := auxIntToInt32(v.AuxInt)
 871                 v.reset(OpRISCV64MOVDconst)
 872                 v.AuxInt = int64ToAuxInt(int64(val))
 873                 return true
 874         }
 875 }
 876 func rewriteValueRISCV64_OpConst32F(v *Value) bool {
 877         b := v.Block
 878         typ := &b.Func.Config.Types
 879         // match: (Const32F [val])
 880         // result: (FMVSX (MOVDconst [int64(math.Float32bits(val))]))
 881         for {
 882                 val := auxIntToFloat32(v.AuxInt)
 883                 v.reset(OpRISCV64FMVSX)
 884                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
 885                 v0.AuxInt = int64ToAuxInt(int64(math.Float32bits(val)))
 886                 v.AddArg(v0)
 887                 return true
 888         }
 889 }
 890 func rewriteValueRISCV64_OpConst64(v *Value) bool {
 891         // match: (Const64 [val])
 892         // result: (MOVDconst [int64(val)])
 893         for {
 894                 val := auxIntToInt64(v.AuxInt)
 895                 v.reset(OpRISCV64MOVDconst)
 896                 v.AuxInt = int64ToAuxInt(int64(val))
 897                 return true
 898         }
 899 }
 900 func rewriteValueRISCV64_OpConst64F(v *Value) bool {
 901         b := v.Block
 902         typ := &b.Func.Config.Types
 903         // match: (Const64F [val])
 904         // result: (FMVDX (MOVDconst [int64(math.Float64bits(val))]))
 905         for {
 906                 val := auxIntToFloat64(v.AuxInt)
 907                 v.reset(OpRISCV64FMVDX)
 908                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
 909                 v0.AuxInt = int64ToAuxInt(int64(math.Float64bits(val)))
 910                 v.AddArg(v0)
 911                 return true
 912         }
 913 }
 914 func rewriteValueRISCV64_OpConst8(v *Value) bool {
 915         // match: (Const8 [val])
 916         // result: (MOVDconst [int64(val)])
 917         for {
 918                 val := auxIntToInt8(v.AuxInt)
 919                 v.reset(OpRISCV64MOVDconst)
 920                 v.AuxInt = int64ToAuxInt(int64(val))
 921                 return true
 922         }
 923 }
 924 func rewriteValueRISCV64_OpConstBool(v *Value) bool {
 925         // match: (ConstBool [val])
 926         // result: (MOVDconst [int64(b2i(val))])
 927         for {
 928                 val := auxIntToBool(v.AuxInt)
 929                 v.reset(OpRISCV64MOVDconst)
 930                 v.AuxInt = int64ToAuxInt(int64(b2i(val)))
 931                 return true
 932         }
 933 }
 934 func rewriteValueRISCV64_OpConstNil(v *Value) bool {
 935         // match: (ConstNil)
 936         // result: (MOVDconst [0])
 937         for {
 938                 v.reset(OpRISCV64MOVDconst)
 939                 v.AuxInt = int64ToAuxInt(0)
 940                 return true
 941         }
 942 }
 943 func rewriteValueRISCV64_OpDiv16(v *Value) bool {
 944         v_1 := v.Args[1]
 945         v_0 := v.Args[0]
 946         b := v.Block
 947         typ := &b.Func.Config.Types
 948         // match: (Div16 x y [false])
 949         // result: (DIVW (SignExt16to32 x) (SignExt16to32 y))
 950         for {
 951                 if auxIntToBool(v.AuxInt) != false {
 952                         break
 953                 }
 954                 x := v_0
 955                 y := v_1
 956                 v.reset(OpRISCV64DIVW)
 957                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 958                 v0.AddArg(x)
 959                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 960                 v1.AddArg(y)
 961                 v.AddArg2(v0, v1)
 962                 return true
 963         }
 964         return false
 965 }
 966 func rewriteValueRISCV64_OpDiv16u(v *Value) bool {
 967         v_1 := v.Args[1]
 968         v_0 := v.Args[0]
 969         b := v.Block
 970         typ := &b.Func.Config.Types
 971         // match: (Div16u x y)
 972         // result: (DIVUW (ZeroExt16to32 x) (ZeroExt16to32 y))
 973         for {
 974                 x := v_0
 975                 y := v_1
 976                 v.reset(OpRISCV64DIVUW)
 977                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 978                 v0.AddArg(x)
 979                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 980                 v1.AddArg(y)
 981                 v.AddArg2(v0, v1)
 982                 return true
 983         }
 984 }
 985 func rewriteValueRISCV64_OpDiv32(v *Value) bool {
 986         v_1 := v.Args[1]
 987         v_0 := v.Args[0]
 988         // match: (Div32 x y [false])
 989         // result: (DIVW x y)
 990         for {
 991                 if auxIntToBool(v.AuxInt) != false {
 992                         break
 993                 }
 994                 x := v_0
 995                 y := v_1
 996                 v.reset(OpRISCV64DIVW)
 997                 v.AddArg2(x, y)
 998                 return true
 999         }
1000         return false
1001 }
1002 func rewriteValueRISCV64_OpDiv64(v *Value) bool {
1003         v_1 := v.Args[1]
1004         v_0 := v.Args[0]
1005         // match: (Div64 x y [false])
1006         // result: (DIV x y)
1007         for {
1008                 if auxIntToBool(v.AuxInt) != false {
1009                         break
1010                 }
1011                 x := v_0
1012                 y := v_1
1013                 v.reset(OpRISCV64DIV)
1014                 v.AddArg2(x, y)
1015                 return true
1016         }
1017         return false
1018 }
1019 func rewriteValueRISCV64_OpDiv8(v *Value) bool {
1020         v_1 := v.Args[1]
1021         v_0 := v.Args[0]
1022         b := v.Block
1023         typ := &b.Func.Config.Types
1024         // match: (Div8 x y)
1025         // result: (DIVW (SignExt8to32 x) (SignExt8to32 y))
1026         for {
1027                 x := v_0
1028                 y := v_1
1029                 v.reset(OpRISCV64DIVW)
1030                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
1031                 v0.AddArg(x)
1032                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
1033                 v1.AddArg(y)
1034                 v.AddArg2(v0, v1)
1035                 return true
1036         }
1037 }
1038 func rewriteValueRISCV64_OpDiv8u(v *Value) bool {
1039         v_1 := v.Args[1]
1040         v_0 := v.Args[0]
1041         b := v.Block
1042         typ := &b.Func.Config.Types
1043         // match: (Div8u x y)
1044         // result: (DIVUW (ZeroExt8to32 x) (ZeroExt8to32 y))
1045         for {
1046                 x := v_0
1047                 y := v_1
1048                 v.reset(OpRISCV64DIVUW)
1049                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
1050                 v0.AddArg(x)
1051                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
1052                 v1.AddArg(y)
1053                 v.AddArg2(v0, v1)
1054                 return true
1055         }
1056 }
1057 func rewriteValueRISCV64_OpEq16(v *Value) bool {
1058         v_1 := v.Args[1]
1059         v_0 := v.Args[0]
1060         b := v.Block
1061         typ := &b.Func.Config.Types
1062         // match: (Eq16 x y)
1063         // result: (SEQZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
1064         for {
1065                 x := v_0
1066                 y := v_1
1067                 v.reset(OpRISCV64SEQZ)
1068                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1069                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1070                 v1.AddArg(x)
1071                 v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1072                 v2.AddArg(y)
1073                 v0.AddArg2(v1, v2)
1074                 v.AddArg(v0)
1075                 return true
1076         }
1077 }
1078 func rewriteValueRISCV64_OpEq32(v *Value) bool {
1079         v_1 := v.Args[1]
1080         v_0 := v.Args[0]
1081         b := v.Block
1082         typ := &b.Func.Config.Types
1083         // match: (Eq32 x y)
1084         // result: (SEQZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
1085         for {
1086                 x := v_0
1087                 y := v_1
1088                 v.reset(OpRISCV64SEQZ)
1089                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1090                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1091                 v1.AddArg(x)
1092                 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1093                 v2.AddArg(y)
1094                 v0.AddArg2(v1, v2)
1095                 v.AddArg(v0)
1096                 return true
1097         }
1098 }
1099 func rewriteValueRISCV64_OpEq64(v *Value) bool {
1100         v_1 := v.Args[1]
1101         v_0 := v.Args[0]
1102         b := v.Block
1103         // match: (Eq64 x y)
1104         // result: (SEQZ (SUB <x.Type> x y))
1105         for {
1106                 x := v_0
1107                 y := v_1
1108                 v.reset(OpRISCV64SEQZ)
1109                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1110                 v0.AddArg2(x, y)
1111                 v.AddArg(v0)
1112                 return true
1113         }
1114 }
1115 func rewriteValueRISCV64_OpEq8(v *Value) bool {
1116         v_1 := v.Args[1]
1117         v_0 := v.Args[0]
1118         b := v.Block
1119         typ := &b.Func.Config.Types
1120         // match: (Eq8 x y)
1121         // result: (SEQZ (SUB <x.Type> (ZeroExt8to64 x) (ZeroExt8to64 y)))
1122         for {
1123                 x := v_0
1124                 y := v_1
1125                 v.reset(OpRISCV64SEQZ)
1126                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1127                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1128                 v1.AddArg(x)
1129                 v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1130                 v2.AddArg(y)
1131                 v0.AddArg2(v1, v2)
1132                 v.AddArg(v0)
1133                 return true
1134         }
1135 }
1136 func rewriteValueRISCV64_OpEqB(v *Value) bool {
1137         v_1 := v.Args[1]
1138         v_0 := v.Args[0]
1139         b := v.Block
1140         typ := &b.Func.Config.Types
1141         // match: (EqB x y)
1142         // result: (SEQZ (SUB <typ.Bool> x y))
1143         for {
1144                 x := v_0
1145                 y := v_1
1146                 v.reset(OpRISCV64SEQZ)
1147                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
1148                 v0.AddArg2(x, y)
1149                 v.AddArg(v0)
1150                 return true
1151         }
1152 }
1153 func rewriteValueRISCV64_OpEqPtr(v *Value) bool {
1154         v_1 := v.Args[1]
1155         v_0 := v.Args[0]
1156         b := v.Block
1157         typ := &b.Func.Config.Types
1158         // match: (EqPtr x y)
1159         // result: (SEQZ (SUB <typ.Uintptr> x y))
1160         for {
1161                 x := v_0
1162                 y := v_1
1163                 v.reset(OpRISCV64SEQZ)
1164                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Uintptr)
1165                 v0.AddArg2(x, y)
1166                 v.AddArg(v0)
1167                 return true
1168         }
1169 }
1170 func rewriteValueRISCV64_OpHmul32(v *Value) bool {
1171         v_1 := v.Args[1]
1172         v_0 := v.Args[0]
1173         b := v.Block
1174         typ := &b.Func.Config.Types
1175         // match: (Hmul32 x y)
1176         // result: (SRAI [32] (MUL (SignExt32to64 x) (SignExt32to64 y)))
1177         for {
1178                 x := v_0
1179                 y := v_1
1180                 v.reset(OpRISCV64SRAI)
1181                 v.AuxInt = int64ToAuxInt(32)
1182                 v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
1183                 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1184                 v1.AddArg(x)
1185                 v2 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1186                 v2.AddArg(y)
1187                 v0.AddArg2(v1, v2)
1188                 v.AddArg(v0)
1189                 return true
1190         }
1191 }
1192 func rewriteValueRISCV64_OpHmul32u(v *Value) bool {
1193         v_1 := v.Args[1]
1194         v_0 := v.Args[0]
1195         b := v.Block
1196         typ := &b.Func.Config.Types
1197         // match: (Hmul32u x y)
1198         // result: (SRLI [32] (MUL (ZeroExt32to64 x) (ZeroExt32to64 y)))
1199         for {
1200                 x := v_0
1201                 y := v_1
1202                 v.reset(OpRISCV64SRLI)
1203                 v.AuxInt = int64ToAuxInt(32)
1204                 v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
1205                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1206                 v1.AddArg(x)
1207                 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1208                 v2.AddArg(y)
1209                 v0.AddArg2(v1, v2)
1210                 v.AddArg(v0)
1211                 return true
1212         }
1213 }
1214 func rewriteValueRISCV64_OpLeq16(v *Value) bool {
1215         v_1 := v.Args[1]
1216         v_0 := v.Args[0]
1217         b := v.Block
1218         typ := &b.Func.Config.Types
1219         // match: (Leq16 x y)
1220         // result: (Not (Less16 y x))
1221         for {
1222                 x := v_0
1223                 y := v_1
1224                 v.reset(OpNot)
1225                 v0 := b.NewValue0(v.Pos, OpLess16, typ.Bool)
1226                 v0.AddArg2(y, x)
1227                 v.AddArg(v0)
1228                 return true
1229         }
1230 }
1231 func rewriteValueRISCV64_OpLeq16U(v *Value) bool {
1232         v_1 := v.Args[1]
1233         v_0 := v.Args[0]
1234         b := v.Block
1235         typ := &b.Func.Config.Types
1236         // match: (Leq16U x y)
1237         // result: (Not (Less16U y x))
1238         for {
1239                 x := v_0
1240                 y := v_1
1241                 v.reset(OpNot)
1242                 v0 := b.NewValue0(v.Pos, OpLess16U, typ.Bool)
1243                 v0.AddArg2(y, x)
1244                 v.AddArg(v0)
1245                 return true
1246         }
1247 }
1248 func rewriteValueRISCV64_OpLeq32(v *Value) bool {
1249         v_1 := v.Args[1]
1250         v_0 := v.Args[0]
1251         b := v.Block
1252         typ := &b.Func.Config.Types
1253         // match: (Leq32 x y)
1254         // result: (Not (Less32 y x))
1255         for {
1256                 x := v_0
1257                 y := v_1
1258                 v.reset(OpNot)
1259                 v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
1260                 v0.AddArg2(y, x)
1261                 v.AddArg(v0)
1262                 return true
1263         }
1264 }
1265 func rewriteValueRISCV64_OpLeq32U(v *Value) bool {
1266         v_1 := v.Args[1]
1267         v_0 := v.Args[0]
1268         b := v.Block
1269         typ := &b.Func.Config.Types
1270         // match: (Leq32U x y)
1271         // result: (Not (Less32U y x))
1272         for {
1273                 x := v_0
1274                 y := v_1
1275                 v.reset(OpNot)
1276                 v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
1277                 v0.AddArg2(y, x)
1278                 v.AddArg(v0)
1279                 return true
1280         }
1281 }
1282 func rewriteValueRISCV64_OpLeq64(v *Value) bool {
1283         v_1 := v.Args[1]
1284         v_0 := v.Args[0]
1285         b := v.Block
1286         typ := &b.Func.Config.Types
1287         // match: (Leq64 x y)
1288         // result: (Not (Less64 y x))
1289         for {
1290                 x := v_0
1291                 y := v_1
1292                 v.reset(OpNot)
1293                 v0 := b.NewValue0(v.Pos, OpLess64, typ.Bool)
1294                 v0.AddArg2(y, x)
1295                 v.AddArg(v0)
1296                 return true
1297         }
1298 }
1299 func rewriteValueRISCV64_OpLeq64U(v *Value) bool {
1300         v_1 := v.Args[1]
1301         v_0 := v.Args[0]
1302         b := v.Block
1303         typ := &b.Func.Config.Types
1304         // match: (Leq64U x y)
1305         // result: (Not (Less64U y x))
1306         for {
1307                 x := v_0
1308                 y := v_1
1309                 v.reset(OpNot)
1310                 v0 := b.NewValue0(v.Pos, OpLess64U, typ.Bool)
1311                 v0.AddArg2(y, x)
1312                 v.AddArg(v0)
1313                 return true
1314         }
1315 }
1316 func rewriteValueRISCV64_OpLeq8(v *Value) bool {
1317         v_1 := v.Args[1]
1318         v_0 := v.Args[0]
1319         b := v.Block
1320         typ := &b.Func.Config.Types
1321         // match: (Leq8 x y)
1322         // result: (Not (Less8 y x))
1323         for {
1324                 x := v_0
1325                 y := v_1
1326                 v.reset(OpNot)
1327                 v0 := b.NewValue0(v.Pos, OpLess8, typ.Bool)
1328                 v0.AddArg2(y, x)
1329                 v.AddArg(v0)
1330                 return true
1331         }
1332 }
1333 func rewriteValueRISCV64_OpLeq8U(v *Value) bool {
1334         v_1 := v.Args[1]
1335         v_0 := v.Args[0]
1336         b := v.Block
1337         typ := &b.Func.Config.Types
1338         // match: (Leq8U x y)
1339         // result: (Not (Less8U y x))
1340         for {
1341                 x := v_0
1342                 y := v_1
1343                 v.reset(OpNot)
1344                 v0 := b.NewValue0(v.Pos, OpLess8U, typ.Bool)
1345                 v0.AddArg2(y, x)
1346                 v.AddArg(v0)
1347                 return true
1348         }
1349 }
1350 func rewriteValueRISCV64_OpLess16(v *Value) bool {
1351         v_1 := v.Args[1]
1352         v_0 := v.Args[0]
1353         b := v.Block
1354         typ := &b.Func.Config.Types
1355         // match: (Less16 x y)
1356         // result: (SLT (SignExt16to64 x) (SignExt16to64 y))
1357         for {
1358                 x := v_0
1359                 y := v_1
1360                 v.reset(OpRISCV64SLT)
1361                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1362                 v0.AddArg(x)
1363                 v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1364                 v1.AddArg(y)
1365                 v.AddArg2(v0, v1)
1366                 return true
1367         }
1368 }
1369 func rewriteValueRISCV64_OpLess16U(v *Value) bool {
1370         v_1 := v.Args[1]
1371         v_0 := v.Args[0]
1372         b := v.Block
1373         typ := &b.Func.Config.Types
1374         // match: (Less16U x y)
1375         // result: (SLTU (ZeroExt16to64 x) (ZeroExt16to64 y))
1376         for {
1377                 x := v_0
1378                 y := v_1
1379                 v.reset(OpRISCV64SLTU)
1380                 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1381                 v0.AddArg(x)
1382                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1383                 v1.AddArg(y)
1384                 v.AddArg2(v0, v1)
1385                 return true
1386         }
1387 }
1388 func rewriteValueRISCV64_OpLess32(v *Value) bool {
1389         v_1 := v.Args[1]
1390         v_0 := v.Args[0]
1391         b := v.Block
1392         typ := &b.Func.Config.Types
1393         // match: (Less32 x y)
1394         // result: (SLT (SignExt32to64 x) (SignExt32to64 y))
1395         for {
1396                 x := v_0
1397                 y := v_1
1398                 v.reset(OpRISCV64SLT)
1399                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1400                 v0.AddArg(x)
1401                 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1402                 v1.AddArg(y)
1403                 v.AddArg2(v0, v1)
1404                 return true
1405         }
1406 }
1407 func rewriteValueRISCV64_OpLess32U(v *Value) bool {
1408         v_1 := v.Args[1]
1409         v_0 := v.Args[0]
1410         b := v.Block
1411         typ := &b.Func.Config.Types
1412         // match: (Less32U x y)
1413         // result: (SLTU (ZeroExt32to64 x) (ZeroExt32to64 y))
1414         for {
1415                 x := v_0
1416                 y := v_1
1417                 v.reset(OpRISCV64SLTU)
1418                 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1419                 v0.AddArg(x)
1420                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1421                 v1.AddArg(y)
1422                 v.AddArg2(v0, v1)
1423                 return true
1424         }
1425 }
1426 func rewriteValueRISCV64_OpLess8(v *Value) bool {
1427         v_1 := v.Args[1]
1428         v_0 := v.Args[0]
1429         b := v.Block
1430         typ := &b.Func.Config.Types
1431         // match: (Less8 x y)
1432         // result: (SLT (SignExt8to64 x) (SignExt8to64 y))
1433         for {
1434                 x := v_0
1435                 y := v_1
1436                 v.reset(OpRISCV64SLT)
1437                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1438                 v0.AddArg(x)
1439                 v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1440                 v1.AddArg(y)
1441                 v.AddArg2(v0, v1)
1442                 return true
1443         }
1444 }
1445 func rewriteValueRISCV64_OpLess8U(v *Value) bool {
1446         v_1 := v.Args[1]
1447         v_0 := v.Args[0]
1448         b := v.Block
1449         typ := &b.Func.Config.Types
1450         // match: (Less8U x y)
1451         // result: (SLTU (ZeroExt8to64 x) (ZeroExt8to64 y))
1452         for {
1453                 x := v_0
1454                 y := v_1
1455                 v.reset(OpRISCV64SLTU)
1456                 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1457                 v0.AddArg(x)
1458                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1459                 v1.AddArg(y)
1460                 v.AddArg2(v0, v1)
1461                 return true
1462         }
1463 }
1464 func rewriteValueRISCV64_OpLoad(v *Value) bool {
1465         v_1 := v.Args[1]
1466         v_0 := v.Args[0]
1467         // match: (Load <t> ptr mem)
1468         // cond: t.IsBoolean()
1469         // result: (MOVBUload ptr mem)
1470         for {
1471                 t := v.Type
1472                 ptr := v_0
1473                 mem := v_1
1474                 if !(t.IsBoolean()) {
1475                         break
1476                 }
1477                 v.reset(OpRISCV64MOVBUload)
1478                 v.AddArg2(ptr, mem)
1479                 return true
1480         }
1481         // match: (Load <t> ptr mem)
1482         // cond: ( is8BitInt(t) && t.IsSigned())
1483         // result: (MOVBload ptr mem)
1484         for {
1485                 t := v.Type
1486                 ptr := v_0
1487                 mem := v_1
1488                 if !(is8BitInt(t) && t.IsSigned()) {
1489                         break
1490                 }
1491                 v.reset(OpRISCV64MOVBload)
1492                 v.AddArg2(ptr, mem)
1493                 return true
1494         }
1495         // match: (Load <t> ptr mem)
1496         // cond: ( is8BitInt(t) && !t.IsSigned())
1497         // result: (MOVBUload ptr mem)
1498         for {
1499                 t := v.Type
1500                 ptr := v_0
1501                 mem := v_1
1502                 if !(is8BitInt(t) && !t.IsSigned()) {
1503                         break
1504                 }
1505                 v.reset(OpRISCV64MOVBUload)
1506                 v.AddArg2(ptr, mem)
1507                 return true
1508         }
1509         // match: (Load <t> ptr mem)
1510         // cond: (is16BitInt(t) && t.IsSigned())
1511         // result: (MOVHload ptr mem)
1512         for {
1513                 t := v.Type
1514                 ptr := v_0
1515                 mem := v_1
1516                 if !(is16BitInt(t) && t.IsSigned()) {
1517                         break
1518                 }
1519                 v.reset(OpRISCV64MOVHload)
1520                 v.AddArg2(ptr, mem)
1521                 return true
1522         }
1523         // match: (Load <t> ptr mem)
1524         // cond: (is16BitInt(t) && !t.IsSigned())
1525         // result: (MOVHUload ptr mem)
1526         for {
1527                 t := v.Type
1528                 ptr := v_0
1529                 mem := v_1
1530                 if !(is16BitInt(t) && !t.IsSigned()) {
1531                         break
1532                 }
1533                 v.reset(OpRISCV64MOVHUload)
1534                 v.AddArg2(ptr, mem)
1535                 return true
1536         }
1537         // match: (Load <t> ptr mem)
1538         // cond: (is32BitInt(t) && t.IsSigned())
1539         // result: (MOVWload ptr mem)
1540         for {
1541                 t := v.Type
1542                 ptr := v_0
1543                 mem := v_1
1544                 if !(is32BitInt(t) && t.IsSigned()) {
1545                         break
1546                 }
1547                 v.reset(OpRISCV64MOVWload)
1548                 v.AddArg2(ptr, mem)
1549                 return true
1550         }
1551         // match: (Load <t> ptr mem)
1552         // cond: (is32BitInt(t) && !t.IsSigned())
1553         // result: (MOVWUload ptr mem)
1554         for {
1555                 t := v.Type
1556                 ptr := v_0
1557                 mem := v_1
1558                 if !(is32BitInt(t) && !t.IsSigned()) {
1559                         break
1560                 }
1561                 v.reset(OpRISCV64MOVWUload)
1562                 v.AddArg2(ptr, mem)
1563                 return true
1564         }
1565         // match: (Load <t> ptr mem)
1566         // cond: (is64BitInt(t) || isPtr(t))
1567         // result: (MOVDload ptr mem)
1568         for {
1569                 t := v.Type
1570                 ptr := v_0
1571                 mem := v_1
1572                 if !(is64BitInt(t) || isPtr(t)) {
1573                         break
1574                 }
1575                 v.reset(OpRISCV64MOVDload)
1576                 v.AddArg2(ptr, mem)
1577                 return true
1578         }
1579         // match: (Load <t> ptr mem)
1580         // cond: is32BitFloat(t)
1581         // result: (FMOVWload ptr mem)
1582         for {
1583                 t := v.Type
1584                 ptr := v_0
1585                 mem := v_1
1586                 if !(is32BitFloat(t)) {
1587                         break
1588                 }
1589                 v.reset(OpRISCV64FMOVWload)
1590                 v.AddArg2(ptr, mem)
1591                 return true
1592         }
1593         // match: (Load <t> ptr mem)
1594         // cond: is64BitFloat(t)
1595         // result: (FMOVDload ptr mem)
1596         for {
1597                 t := v.Type
1598                 ptr := v_0
1599                 mem := v_1
1600                 if !(is64BitFloat(t)) {
1601                         break
1602                 }
1603                 v.reset(OpRISCV64FMOVDload)
1604                 v.AddArg2(ptr, mem)
1605                 return true
1606         }
1607         return false
1608 }
1609 func rewriteValueRISCV64_OpLocalAddr(v *Value) bool {
1610         v_1 := v.Args[1]
1611         v_0 := v.Args[0]
1612         b := v.Block
1613         typ := &b.Func.Config.Types
1614         // match: (LocalAddr <t> {sym} base mem)
1615         // cond: t.Elem().HasPointers()
1616         // result: (MOVaddr {sym} (SPanchored base mem))
1617         for {
1618                 t := v.Type
1619                 sym := auxToSym(v.Aux)
1620                 base := v_0
1621                 mem := v_1
1622                 if !(t.Elem().HasPointers()) {
1623                         break
1624                 }
1625                 v.reset(OpRISCV64MOVaddr)
1626                 v.Aux = symToAux(sym)
1627                 v0 := b.NewValue0(v.Pos, OpSPanchored, typ.Uintptr)
1628                 v0.AddArg2(base, mem)
1629                 v.AddArg(v0)
1630                 return true
1631         }
1632         // match: (LocalAddr <t> {sym} base _)
1633         // cond: !t.Elem().HasPointers()
1634         // result: (MOVaddr {sym} base)
1635         for {
1636                 t := v.Type
1637                 sym := auxToSym(v.Aux)
1638                 base := v_0
1639                 if !(!t.Elem().HasPointers()) {
1640                         break
1641                 }
1642                 v.reset(OpRISCV64MOVaddr)
1643                 v.Aux = symToAux(sym)
1644                 v.AddArg(base)
1645                 return true
1646         }
1647         return false
1648 }
1649 func rewriteValueRISCV64_OpLsh16x16(v *Value) bool {
1650         v_1 := v.Args[1]
1651         v_0 := v.Args[0]
1652         b := v.Block
1653         typ := &b.Func.Config.Types
1654         // match: (Lsh16x16 <t> x y)
1655         // cond: !shiftIsBounded(v)
1656         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1657         for {
1658                 t := v.Type
1659                 x := v_0
1660                 y := v_1
1661                 if !(!shiftIsBounded(v)) {
1662                         break
1663                 }
1664                 v.reset(OpRISCV64AND)
1665                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1666                 v0.AddArg2(x, y)
1667                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1668                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1669                 v2.AuxInt = int64ToAuxInt(64)
1670                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1671                 v3.AddArg(y)
1672                 v2.AddArg(v3)
1673                 v1.AddArg(v2)
1674                 v.AddArg2(v0, v1)
1675                 return true
1676         }
1677         // match: (Lsh16x16 x y)
1678         // cond: shiftIsBounded(v)
1679         // result: (SLL x y)
1680         for {
1681                 x := v_0
1682                 y := v_1
1683                 if !(shiftIsBounded(v)) {
1684                         break
1685                 }
1686                 v.reset(OpRISCV64SLL)
1687                 v.AddArg2(x, y)
1688                 return true
1689         }
1690         return false
1691 }
1692 func rewriteValueRISCV64_OpLsh16x32(v *Value) bool {
1693         v_1 := v.Args[1]
1694         v_0 := v.Args[0]
1695         b := v.Block
1696         typ := &b.Func.Config.Types
1697         // match: (Lsh16x32 <t> x y)
1698         // cond: !shiftIsBounded(v)
1699         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
1700         for {
1701                 t := v.Type
1702                 x := v_0
1703                 y := v_1
1704                 if !(!shiftIsBounded(v)) {
1705                         break
1706                 }
1707                 v.reset(OpRISCV64AND)
1708                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1709                 v0.AddArg2(x, y)
1710                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1711                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1712                 v2.AuxInt = int64ToAuxInt(64)
1713                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1714                 v3.AddArg(y)
1715                 v2.AddArg(v3)
1716                 v1.AddArg(v2)
1717                 v.AddArg2(v0, v1)
1718                 return true
1719         }
1720         // match: (Lsh16x32 x y)
1721         // cond: shiftIsBounded(v)
1722         // result: (SLL x y)
1723         for {
1724                 x := v_0
1725                 y := v_1
1726                 if !(shiftIsBounded(v)) {
1727                         break
1728                 }
1729                 v.reset(OpRISCV64SLL)
1730                 v.AddArg2(x, y)
1731                 return true
1732         }
1733         return false
1734 }
1735 func rewriteValueRISCV64_OpLsh16x64(v *Value) bool {
1736         v_1 := v.Args[1]
1737         v_0 := v.Args[0]
1738         b := v.Block
1739         // match: (Lsh16x64 <t> x y)
1740         // cond: !shiftIsBounded(v)
1741         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] y)))
1742         for {
1743                 t := v.Type
1744                 x := v_0
1745                 y := v_1
1746                 if !(!shiftIsBounded(v)) {
1747                         break
1748                 }
1749                 v.reset(OpRISCV64AND)
1750                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1751                 v0.AddArg2(x, y)
1752                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1753                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1754                 v2.AuxInt = int64ToAuxInt(64)
1755                 v2.AddArg(y)
1756                 v1.AddArg(v2)
1757                 v.AddArg2(v0, v1)
1758                 return true
1759         }
1760         // match: (Lsh16x64 x y)
1761         // cond: shiftIsBounded(v)
1762         // result: (SLL x y)
1763         for {
1764                 x := v_0
1765                 y := v_1
1766                 if !(shiftIsBounded(v)) {
1767                         break
1768                 }
1769                 v.reset(OpRISCV64SLL)
1770                 v.AddArg2(x, y)
1771                 return true
1772         }
1773         return false
1774 }
1775 func rewriteValueRISCV64_OpLsh16x8(v *Value) bool {
1776         v_1 := v.Args[1]
1777         v_0 := v.Args[0]
1778         b := v.Block
1779         typ := &b.Func.Config.Types
1780         // match: (Lsh16x8 <t> x y)
1781         // cond: !shiftIsBounded(v)
1782         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
1783         for {
1784                 t := v.Type
1785                 x := v_0
1786                 y := v_1
1787                 if !(!shiftIsBounded(v)) {
1788                         break
1789                 }
1790                 v.reset(OpRISCV64AND)
1791                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1792                 v0.AddArg2(x, y)
1793                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1794                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1795                 v2.AuxInt = int64ToAuxInt(64)
1796                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1797                 v3.AddArg(y)
1798                 v2.AddArg(v3)
1799                 v1.AddArg(v2)
1800                 v.AddArg2(v0, v1)
1801                 return true
1802         }
1803         // match: (Lsh16x8 x y)
1804         // cond: shiftIsBounded(v)
1805         // result: (SLL x y)
1806         for {
1807                 x := v_0
1808                 y := v_1
1809                 if !(shiftIsBounded(v)) {
1810                         break
1811                 }
1812                 v.reset(OpRISCV64SLL)
1813                 v.AddArg2(x, y)
1814                 return true
1815         }
1816         return false
1817 }
1818 func rewriteValueRISCV64_OpLsh32x16(v *Value) bool {
1819         v_1 := v.Args[1]
1820         v_0 := v.Args[0]
1821         b := v.Block
1822         typ := &b.Func.Config.Types
1823         // match: (Lsh32x16 <t> x y)
1824         // cond: !shiftIsBounded(v)
1825         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1826         for {
1827                 t := v.Type
1828                 x := v_0
1829                 y := v_1
1830                 if !(!shiftIsBounded(v)) {
1831                         break
1832                 }
1833                 v.reset(OpRISCV64AND)
1834                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1835                 v0.AddArg2(x, y)
1836                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1837                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1838                 v2.AuxInt = int64ToAuxInt(64)
1839                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1840                 v3.AddArg(y)
1841                 v2.AddArg(v3)
1842                 v1.AddArg(v2)
1843                 v.AddArg2(v0, v1)
1844                 return true
1845         }
1846         // match: (Lsh32x16 x y)
1847         // cond: shiftIsBounded(v)
1848         // result: (SLL x y)
1849         for {
1850                 x := v_0
1851                 y := v_1
1852                 if !(shiftIsBounded(v)) {
1853                         break
1854                 }
1855                 v.reset(OpRISCV64SLL)
1856                 v.AddArg2(x, y)
1857                 return true
1858         }
1859         return false
1860 }
1861 func rewriteValueRISCV64_OpLsh32x32(v *Value) bool {
1862         v_1 := v.Args[1]
1863         v_0 := v.Args[0]
1864         b := v.Block
1865         typ := &b.Func.Config.Types
1866         // match: (Lsh32x32 <t> x y)
1867         // cond: !shiftIsBounded(v)
1868         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
1869         for {
1870                 t := v.Type
1871                 x := v_0
1872                 y := v_1
1873                 if !(!shiftIsBounded(v)) {
1874                         break
1875                 }
1876                 v.reset(OpRISCV64AND)
1877                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1878                 v0.AddArg2(x, y)
1879                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1880                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1881                 v2.AuxInt = int64ToAuxInt(64)
1882                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1883                 v3.AddArg(y)
1884                 v2.AddArg(v3)
1885                 v1.AddArg(v2)
1886                 v.AddArg2(v0, v1)
1887                 return true
1888         }
1889         // match: (Lsh32x32 x y)
1890         // cond: shiftIsBounded(v)
1891         // result: (SLL x y)
1892         for {
1893                 x := v_0
1894                 y := v_1
1895                 if !(shiftIsBounded(v)) {
1896                         break
1897                 }
1898                 v.reset(OpRISCV64SLL)
1899                 v.AddArg2(x, y)
1900                 return true
1901         }
1902         return false
1903 }
1904 func rewriteValueRISCV64_OpLsh32x64(v *Value) bool {
1905         v_1 := v.Args[1]
1906         v_0 := v.Args[0]
1907         b := v.Block
1908         // match: (Lsh32x64 <t> x y)
1909         // cond: !shiftIsBounded(v)
1910         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] y)))
1911         for {
1912                 t := v.Type
1913                 x := v_0
1914                 y := v_1
1915                 if !(!shiftIsBounded(v)) {
1916                         break
1917                 }
1918                 v.reset(OpRISCV64AND)
1919                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1920                 v0.AddArg2(x, y)
1921                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1922                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1923                 v2.AuxInt = int64ToAuxInt(64)
1924                 v2.AddArg(y)
1925                 v1.AddArg(v2)
1926                 v.AddArg2(v0, v1)
1927                 return true
1928         }
1929         // match: (Lsh32x64 x y)
1930         // cond: shiftIsBounded(v)
1931         // result: (SLL x y)
1932         for {
1933                 x := v_0
1934                 y := v_1
1935                 if !(shiftIsBounded(v)) {
1936                         break
1937                 }
1938                 v.reset(OpRISCV64SLL)
1939                 v.AddArg2(x, y)
1940                 return true
1941         }
1942         return false
1943 }
1944 func rewriteValueRISCV64_OpLsh32x8(v *Value) bool {
1945         v_1 := v.Args[1]
1946         v_0 := v.Args[0]
1947         b := v.Block
1948         typ := &b.Func.Config.Types
1949         // match: (Lsh32x8 <t> x y)
1950         // cond: !shiftIsBounded(v)
1951         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
1952         for {
1953                 t := v.Type
1954                 x := v_0
1955                 y := v_1
1956                 if !(!shiftIsBounded(v)) {
1957                         break
1958                 }
1959                 v.reset(OpRISCV64AND)
1960                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1961                 v0.AddArg2(x, y)
1962                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1963                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1964                 v2.AuxInt = int64ToAuxInt(64)
1965                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1966                 v3.AddArg(y)
1967                 v2.AddArg(v3)
1968                 v1.AddArg(v2)
1969                 v.AddArg2(v0, v1)
1970                 return true
1971         }
1972         // match: (Lsh32x8 x y)
1973         // cond: shiftIsBounded(v)
1974         // result: (SLL x y)
1975         for {
1976                 x := v_0
1977                 y := v_1
1978                 if !(shiftIsBounded(v)) {
1979                         break
1980                 }
1981                 v.reset(OpRISCV64SLL)
1982                 v.AddArg2(x, y)
1983                 return true
1984         }
1985         return false
1986 }
1987 func rewriteValueRISCV64_OpLsh64x16(v *Value) bool {
1988         v_1 := v.Args[1]
1989         v_0 := v.Args[0]
1990         b := v.Block
1991         typ := &b.Func.Config.Types
1992         // match: (Lsh64x16 <t> x y)
1993         // cond: !shiftIsBounded(v)
1994         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1995         for {
1996                 t := v.Type
1997                 x := v_0
1998                 y := v_1
1999                 if !(!shiftIsBounded(v)) {
2000                         break
2001                 }
2002                 v.reset(OpRISCV64AND)
2003                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2004                 v0.AddArg2(x, y)
2005                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2006                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2007                 v2.AuxInt = int64ToAuxInt(64)
2008                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2009                 v3.AddArg(y)
2010                 v2.AddArg(v3)
2011                 v1.AddArg(v2)
2012                 v.AddArg2(v0, v1)
2013                 return true
2014         }
2015         // match: (Lsh64x16 x y)
2016         // cond: shiftIsBounded(v)
2017         // result: (SLL x y)
2018         for {
2019                 x := v_0
2020                 y := v_1
2021                 if !(shiftIsBounded(v)) {
2022                         break
2023                 }
2024                 v.reset(OpRISCV64SLL)
2025                 v.AddArg2(x, y)
2026                 return true
2027         }
2028         return false
2029 }
2030 func rewriteValueRISCV64_OpLsh64x32(v *Value) bool {
2031         v_1 := v.Args[1]
2032         v_0 := v.Args[0]
2033         b := v.Block
2034         typ := &b.Func.Config.Types
2035         // match: (Lsh64x32 <t> x y)
2036         // cond: !shiftIsBounded(v)
2037         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
2038         for {
2039                 t := v.Type
2040                 x := v_0
2041                 y := v_1
2042                 if !(!shiftIsBounded(v)) {
2043                         break
2044                 }
2045                 v.reset(OpRISCV64AND)
2046                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2047                 v0.AddArg2(x, y)
2048                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2049                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2050                 v2.AuxInt = int64ToAuxInt(64)
2051                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2052                 v3.AddArg(y)
2053                 v2.AddArg(v3)
2054                 v1.AddArg(v2)
2055                 v.AddArg2(v0, v1)
2056                 return true
2057         }
2058         // match: (Lsh64x32 x y)
2059         // cond: shiftIsBounded(v)
2060         // result: (SLL x y)
2061         for {
2062                 x := v_0
2063                 y := v_1
2064                 if !(shiftIsBounded(v)) {
2065                         break
2066                 }
2067                 v.reset(OpRISCV64SLL)
2068                 v.AddArg2(x, y)
2069                 return true
2070         }
2071         return false
2072 }
2073 func rewriteValueRISCV64_OpLsh64x64(v *Value) bool {
2074         v_1 := v.Args[1]
2075         v_0 := v.Args[0]
2076         b := v.Block
2077         // match: (Lsh64x64 <t> x y)
2078         // cond: !shiftIsBounded(v)
2079         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] y)))
2080         for {
2081                 t := v.Type
2082                 x := v_0
2083                 y := v_1
2084                 if !(!shiftIsBounded(v)) {
2085                         break
2086                 }
2087                 v.reset(OpRISCV64AND)
2088                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2089                 v0.AddArg2(x, y)
2090                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2091                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2092                 v2.AuxInt = int64ToAuxInt(64)
2093                 v2.AddArg(y)
2094                 v1.AddArg(v2)
2095                 v.AddArg2(v0, v1)
2096                 return true
2097         }
2098         // match: (Lsh64x64 x y)
2099         // cond: shiftIsBounded(v)
2100         // result: (SLL x y)
2101         for {
2102                 x := v_0
2103                 y := v_1
2104                 if !(shiftIsBounded(v)) {
2105                         break
2106                 }
2107                 v.reset(OpRISCV64SLL)
2108                 v.AddArg2(x, y)
2109                 return true
2110         }
2111         return false
2112 }
2113 func rewriteValueRISCV64_OpLsh64x8(v *Value) bool {
2114         v_1 := v.Args[1]
2115         v_0 := v.Args[0]
2116         b := v.Block
2117         typ := &b.Func.Config.Types
2118         // match: (Lsh64x8 <t> x y)
2119         // cond: !shiftIsBounded(v)
2120         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
2121         for {
2122                 t := v.Type
2123                 x := v_0
2124                 y := v_1
2125                 if !(!shiftIsBounded(v)) {
2126                         break
2127                 }
2128                 v.reset(OpRISCV64AND)
2129                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2130                 v0.AddArg2(x, y)
2131                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
2132                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2133                 v2.AuxInt = int64ToAuxInt(64)
2134                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2135                 v3.AddArg(y)
2136                 v2.AddArg(v3)
2137                 v1.AddArg(v2)
2138                 v.AddArg2(v0, v1)
2139                 return true
2140         }
2141         // match: (Lsh64x8 x y)
2142         // cond: shiftIsBounded(v)
2143         // result: (SLL x y)
2144         for {
2145                 x := v_0
2146                 y := v_1
2147                 if !(shiftIsBounded(v)) {
2148                         break
2149                 }
2150                 v.reset(OpRISCV64SLL)
2151                 v.AddArg2(x, y)
2152                 return true
2153         }
2154         return false
2155 }
2156 func rewriteValueRISCV64_OpLsh8x16(v *Value) bool {
2157         v_1 := v.Args[1]
2158         v_0 := v.Args[0]
2159         b := v.Block
2160         typ := &b.Func.Config.Types
2161         // match: (Lsh8x16 <t> x y)
2162         // cond: !shiftIsBounded(v)
2163         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
2164         for {
2165                 t := v.Type
2166                 x := v_0
2167                 y := v_1
2168                 if !(!shiftIsBounded(v)) {
2169                         break
2170                 }
2171                 v.reset(OpRISCV64AND)
2172                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2173                 v0.AddArg2(x, y)
2174                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2175                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2176                 v2.AuxInt = int64ToAuxInt(64)
2177                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2178                 v3.AddArg(y)
2179                 v2.AddArg(v3)
2180                 v1.AddArg(v2)
2181                 v.AddArg2(v0, v1)
2182                 return true
2183         }
2184         // match: (Lsh8x16 x y)
2185         // cond: shiftIsBounded(v)
2186         // result: (SLL x y)
2187         for {
2188                 x := v_0
2189                 y := v_1
2190                 if !(shiftIsBounded(v)) {
2191                         break
2192                 }
2193                 v.reset(OpRISCV64SLL)
2194                 v.AddArg2(x, y)
2195                 return true
2196         }
2197         return false
2198 }
2199 func rewriteValueRISCV64_OpLsh8x32(v *Value) bool {
2200         v_1 := v.Args[1]
2201         v_0 := v.Args[0]
2202         b := v.Block
2203         typ := &b.Func.Config.Types
2204         // match: (Lsh8x32 <t> x y)
2205         // cond: !shiftIsBounded(v)
2206         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
2207         for {
2208                 t := v.Type
2209                 x := v_0
2210                 y := v_1
2211                 if !(!shiftIsBounded(v)) {
2212                         break
2213                 }
2214                 v.reset(OpRISCV64AND)
2215                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2216                 v0.AddArg2(x, y)
2217                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2218                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2219                 v2.AuxInt = int64ToAuxInt(64)
2220                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2221                 v3.AddArg(y)
2222                 v2.AddArg(v3)
2223                 v1.AddArg(v2)
2224                 v.AddArg2(v0, v1)
2225                 return true
2226         }
2227         // match: (Lsh8x32 x y)
2228         // cond: shiftIsBounded(v)
2229         // result: (SLL x y)
2230         for {
2231                 x := v_0
2232                 y := v_1
2233                 if !(shiftIsBounded(v)) {
2234                         break
2235                 }
2236                 v.reset(OpRISCV64SLL)
2237                 v.AddArg2(x, y)
2238                 return true
2239         }
2240         return false
2241 }
2242 func rewriteValueRISCV64_OpLsh8x64(v *Value) bool {
2243         v_1 := v.Args[1]
2244         v_0 := v.Args[0]
2245         b := v.Block
2246         // match: (Lsh8x64 <t> x y)
2247         // cond: !shiftIsBounded(v)
2248         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] y)))
2249         for {
2250                 t := v.Type
2251                 x := v_0
2252                 y := v_1
2253                 if !(!shiftIsBounded(v)) {
2254                         break
2255                 }
2256                 v.reset(OpRISCV64AND)
2257                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2258                 v0.AddArg2(x, y)
2259                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2260                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2261                 v2.AuxInt = int64ToAuxInt(64)
2262                 v2.AddArg(y)
2263                 v1.AddArg(v2)
2264                 v.AddArg2(v0, v1)
2265                 return true
2266         }
2267         // match: (Lsh8x64 x y)
2268         // cond: shiftIsBounded(v)
2269         // result: (SLL x y)
2270         for {
2271                 x := v_0
2272                 y := v_1
2273                 if !(shiftIsBounded(v)) {
2274                         break
2275                 }
2276                 v.reset(OpRISCV64SLL)
2277                 v.AddArg2(x, y)
2278                 return true
2279         }
2280         return false
2281 }
2282 func rewriteValueRISCV64_OpLsh8x8(v *Value) bool {
2283         v_1 := v.Args[1]
2284         v_0 := v.Args[0]
2285         b := v.Block
2286         typ := &b.Func.Config.Types
2287         // match: (Lsh8x8 <t> x y)
2288         // cond: !shiftIsBounded(v)
2289         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
2290         for {
2291                 t := v.Type
2292                 x := v_0
2293                 y := v_1
2294                 if !(!shiftIsBounded(v)) {
2295                         break
2296                 }
2297                 v.reset(OpRISCV64AND)
2298                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
2299                 v0.AddArg2(x, y)
2300                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
2301                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
2302                 v2.AuxInt = int64ToAuxInt(64)
2303                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2304                 v3.AddArg(y)
2305                 v2.AddArg(v3)
2306                 v1.AddArg(v2)
2307                 v.AddArg2(v0, v1)
2308                 return true
2309         }
2310         // match: (Lsh8x8 x y)
2311         // cond: shiftIsBounded(v)
2312         // result: (SLL x y)
2313         for {
2314                 x := v_0
2315                 y := v_1
2316                 if !(shiftIsBounded(v)) {
2317                         break
2318                 }
2319                 v.reset(OpRISCV64SLL)
2320                 v.AddArg2(x, y)
2321                 return true
2322         }
2323         return false
2324 }
2325 func rewriteValueRISCV64_OpMod16(v *Value) bool {
2326         v_1 := v.Args[1]
2327         v_0 := v.Args[0]
2328         b := v.Block
2329         typ := &b.Func.Config.Types
2330         // match: (Mod16 x y [false])
2331         // result: (REMW (SignExt16to32 x) (SignExt16to32 y))
2332         for {
2333                 if auxIntToBool(v.AuxInt) != false {
2334                         break
2335                 }
2336                 x := v_0
2337                 y := v_1
2338                 v.reset(OpRISCV64REMW)
2339                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2340                 v0.AddArg(x)
2341                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2342                 v1.AddArg(y)
2343                 v.AddArg2(v0, v1)
2344                 return true
2345         }
2346         return false
2347 }
2348 func rewriteValueRISCV64_OpMod16u(v *Value) bool {
2349         v_1 := v.Args[1]
2350         v_0 := v.Args[0]
2351         b := v.Block
2352         typ := &b.Func.Config.Types
2353         // match: (Mod16u x y)
2354         // result: (REMUW (ZeroExt16to32 x) (ZeroExt16to32 y))
2355         for {
2356                 x := v_0
2357                 y := v_1
2358                 v.reset(OpRISCV64REMUW)
2359                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
2360                 v0.AddArg(x)
2361                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
2362                 v1.AddArg(y)
2363                 v.AddArg2(v0, v1)
2364                 return true
2365         }
2366 }
2367 func rewriteValueRISCV64_OpMod32(v *Value) bool {
2368         v_1 := v.Args[1]
2369         v_0 := v.Args[0]
2370         // match: (Mod32 x y [false])
2371         // result: (REMW x y)
2372         for {
2373                 if auxIntToBool(v.AuxInt) != false {
2374                         break
2375                 }
2376                 x := v_0
2377                 y := v_1
2378                 v.reset(OpRISCV64REMW)
2379                 v.AddArg2(x, y)
2380                 return true
2381         }
2382         return false
2383 }
2384 func rewriteValueRISCV64_OpMod64(v *Value) bool {
2385         v_1 := v.Args[1]
2386         v_0 := v.Args[0]
2387         // match: (Mod64 x y [false])
2388         // result: (REM x y)
2389         for {
2390                 if auxIntToBool(v.AuxInt) != false {
2391                         break
2392                 }
2393                 x := v_0
2394                 y := v_1
2395                 v.reset(OpRISCV64REM)
2396                 v.AddArg2(x, y)
2397                 return true
2398         }
2399         return false
2400 }
2401 func rewriteValueRISCV64_OpMod8(v *Value) bool {
2402         v_1 := v.Args[1]
2403         v_0 := v.Args[0]
2404         b := v.Block
2405         typ := &b.Func.Config.Types
2406         // match: (Mod8 x y)
2407         // result: (REMW (SignExt8to32 x) (SignExt8to32 y))
2408         for {
2409                 x := v_0
2410                 y := v_1
2411                 v.reset(OpRISCV64REMW)
2412                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2413                 v0.AddArg(x)
2414                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2415                 v1.AddArg(y)
2416                 v.AddArg2(v0, v1)
2417                 return true
2418         }
2419 }
2420 func rewriteValueRISCV64_OpMod8u(v *Value) bool {
2421         v_1 := v.Args[1]
2422         v_0 := v.Args[0]
2423         b := v.Block
2424         typ := &b.Func.Config.Types
2425         // match: (Mod8u x y)
2426         // result: (REMUW (ZeroExt8to32 x) (ZeroExt8to32 y))
2427         for {
2428                 x := v_0
2429                 y := v_1
2430                 v.reset(OpRISCV64REMUW)
2431                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
2432                 v0.AddArg(x)
2433                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
2434                 v1.AddArg(y)
2435                 v.AddArg2(v0, v1)
2436                 return true
2437         }
2438 }
2439 func rewriteValueRISCV64_OpMove(v *Value) bool {
2440         v_2 := v.Args[2]
2441         v_1 := v.Args[1]
2442         v_0 := v.Args[0]
2443         b := v.Block
2444         config := b.Func.Config
2445         typ := &b.Func.Config.Types
2446         // match: (Move [0] _ _ mem)
2447         // result: mem
2448         for {
2449                 if auxIntToInt64(v.AuxInt) != 0 {
2450                         break
2451                 }
2452                 mem := v_2
2453                 v.copyOf(mem)
2454                 return true
2455         }
2456         // match: (Move [1] dst src mem)
2457         // result: (MOVBstore dst (MOVBload src mem) mem)
2458         for {
2459                 if auxIntToInt64(v.AuxInt) != 1 {
2460                         break
2461                 }
2462                 dst := v_0
2463                 src := v_1
2464                 mem := v_2
2465                 v.reset(OpRISCV64MOVBstore)
2466                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2467                 v0.AddArg2(src, mem)
2468                 v.AddArg3(dst, v0, mem)
2469                 return true
2470         }
2471         // match: (Move [2] {t} dst src mem)
2472         // cond: t.Alignment()%2 == 0
2473         // result: (MOVHstore dst (MOVHload src mem) mem)
2474         for {
2475                 if auxIntToInt64(v.AuxInt) != 2 {
2476                         break
2477                 }
2478                 t := auxToType(v.Aux)
2479                 dst := v_0
2480                 src := v_1
2481                 mem := v_2
2482                 if !(t.Alignment()%2 == 0) {
2483                         break
2484                 }
2485                 v.reset(OpRISCV64MOVHstore)
2486                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2487                 v0.AddArg2(src, mem)
2488                 v.AddArg3(dst, v0, mem)
2489                 return true
2490         }
2491         // match: (Move [2] dst src mem)
2492         // result: (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))
2493         for {
2494                 if auxIntToInt64(v.AuxInt) != 2 {
2495                         break
2496                 }
2497                 dst := v_0
2498                 src := v_1
2499                 mem := v_2
2500                 v.reset(OpRISCV64MOVBstore)
2501                 v.AuxInt = int32ToAuxInt(1)
2502                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2503                 v0.AuxInt = int32ToAuxInt(1)
2504                 v0.AddArg2(src, mem)
2505                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2506                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2507                 v2.AddArg2(src, mem)
2508                 v1.AddArg3(dst, v2, mem)
2509                 v.AddArg3(dst, v0, v1)
2510                 return true
2511         }
2512         // match: (Move [4] {t} dst src mem)
2513         // cond: t.Alignment()%4 == 0
2514         // result: (MOVWstore dst (MOVWload src mem) mem)
2515         for {
2516                 if auxIntToInt64(v.AuxInt) != 4 {
2517                         break
2518                 }
2519                 t := auxToType(v.Aux)
2520                 dst := v_0
2521                 src := v_1
2522                 mem := v_2
2523                 if !(t.Alignment()%4 == 0) {
2524                         break
2525                 }
2526                 v.reset(OpRISCV64MOVWstore)
2527                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2528                 v0.AddArg2(src, mem)
2529                 v.AddArg3(dst, v0, mem)
2530                 return true
2531         }
2532         // match: (Move [4] {t} dst src mem)
2533         // cond: t.Alignment()%2 == 0
2534         // result: (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))
2535         for {
2536                 if auxIntToInt64(v.AuxInt) != 4 {
2537                         break
2538                 }
2539                 t := auxToType(v.Aux)
2540                 dst := v_0
2541                 src := v_1
2542                 mem := v_2
2543                 if !(t.Alignment()%2 == 0) {
2544                         break
2545                 }
2546                 v.reset(OpRISCV64MOVHstore)
2547                 v.AuxInt = int32ToAuxInt(2)
2548                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2549                 v0.AuxInt = int32ToAuxInt(2)
2550                 v0.AddArg2(src, mem)
2551                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2552                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2553                 v2.AddArg2(src, mem)
2554                 v1.AddArg3(dst, v2, mem)
2555                 v.AddArg3(dst, v0, v1)
2556                 return true
2557         }
2558         // match: (Move [4] dst src mem)
2559         // result: (MOVBstore [3] dst (MOVBload [3] src mem) (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))))
2560         for {
2561                 if auxIntToInt64(v.AuxInt) != 4 {
2562                         break
2563                 }
2564                 dst := v_0
2565                 src := v_1
2566                 mem := v_2
2567                 v.reset(OpRISCV64MOVBstore)
2568                 v.AuxInt = int32ToAuxInt(3)
2569                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2570                 v0.AuxInt = int32ToAuxInt(3)
2571                 v0.AddArg2(src, mem)
2572                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2573                 v1.AuxInt = int32ToAuxInt(2)
2574                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2575                 v2.AuxInt = int32ToAuxInt(2)
2576                 v2.AddArg2(src, mem)
2577                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2578                 v3.AuxInt = int32ToAuxInt(1)
2579                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2580                 v4.AuxInt = int32ToAuxInt(1)
2581                 v4.AddArg2(src, mem)
2582                 v5 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2583                 v6 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2584                 v6.AddArg2(src, mem)
2585                 v5.AddArg3(dst, v6, mem)
2586                 v3.AddArg3(dst, v4, v5)
2587                 v1.AddArg3(dst, v2, v3)
2588                 v.AddArg3(dst, v0, v1)
2589                 return true
2590         }
2591         // match: (Move [8] {t} dst src mem)
2592         // cond: t.Alignment()%8 == 0
2593         // result: (MOVDstore dst (MOVDload src mem) mem)
2594         for {
2595                 if auxIntToInt64(v.AuxInt) != 8 {
2596                         break
2597                 }
2598                 t := auxToType(v.Aux)
2599                 dst := v_0
2600                 src := v_1
2601                 mem := v_2
2602                 if !(t.Alignment()%8 == 0) {
2603                         break
2604                 }
2605                 v.reset(OpRISCV64MOVDstore)
2606                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2607                 v0.AddArg2(src, mem)
2608                 v.AddArg3(dst, v0, mem)
2609                 return true
2610         }
2611         // match: (Move [8] {t} dst src mem)
2612         // cond: t.Alignment()%4 == 0
2613         // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem))
2614         for {
2615                 if auxIntToInt64(v.AuxInt) != 8 {
2616                         break
2617                 }
2618                 t := auxToType(v.Aux)
2619                 dst := v_0
2620                 src := v_1
2621                 mem := v_2
2622                 if !(t.Alignment()%4 == 0) {
2623                         break
2624                 }
2625                 v.reset(OpRISCV64MOVWstore)
2626                 v.AuxInt = int32ToAuxInt(4)
2627                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2628                 v0.AuxInt = int32ToAuxInt(4)
2629                 v0.AddArg2(src, mem)
2630                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
2631                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2632                 v2.AddArg2(src, mem)
2633                 v1.AddArg3(dst, v2, mem)
2634                 v.AddArg3(dst, v0, v1)
2635                 return true
2636         }
2637         // match: (Move [8] {t} dst src mem)
2638         // cond: t.Alignment()%2 == 0
2639         // result: (MOVHstore [6] dst (MOVHload [6] src mem) (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))))
2640         for {
2641                 if auxIntToInt64(v.AuxInt) != 8 {
2642                         break
2643                 }
2644                 t := auxToType(v.Aux)
2645                 dst := v_0
2646                 src := v_1
2647                 mem := v_2
2648                 if !(t.Alignment()%2 == 0) {
2649                         break
2650                 }
2651                 v.reset(OpRISCV64MOVHstore)
2652                 v.AuxInt = int32ToAuxInt(6)
2653                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2654                 v0.AuxInt = int32ToAuxInt(6)
2655                 v0.AddArg2(src, mem)
2656                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2657                 v1.AuxInt = int32ToAuxInt(4)
2658                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2659                 v2.AuxInt = int32ToAuxInt(4)
2660                 v2.AddArg2(src, mem)
2661                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2662                 v3.AuxInt = int32ToAuxInt(2)
2663                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2664                 v4.AuxInt = int32ToAuxInt(2)
2665                 v4.AddArg2(src, mem)
2666                 v5 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2667                 v6 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2668                 v6.AddArg2(src, mem)
2669                 v5.AddArg3(dst, v6, mem)
2670                 v3.AddArg3(dst, v4, v5)
2671                 v1.AddArg3(dst, v2, v3)
2672                 v.AddArg3(dst, v0, v1)
2673                 return true
2674         }
2675         // match: (Move [3] dst src mem)
2676         // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
2677         for {
2678                 if auxIntToInt64(v.AuxInt) != 3 {
2679                         break
2680                 }
2681                 dst := v_0
2682                 src := v_1
2683                 mem := v_2
2684                 v.reset(OpRISCV64MOVBstore)
2685                 v.AuxInt = int32ToAuxInt(2)
2686                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2687                 v0.AuxInt = int32ToAuxInt(2)
2688                 v0.AddArg2(src, mem)
2689                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2690                 v1.AuxInt = int32ToAuxInt(1)
2691                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2692                 v2.AuxInt = int32ToAuxInt(1)
2693                 v2.AddArg2(src, mem)
2694                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2695                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2696                 v4.AddArg2(src, mem)
2697                 v3.AddArg3(dst, v4, mem)
2698                 v1.AddArg3(dst, v2, v3)
2699                 v.AddArg3(dst, v0, v1)
2700                 return true
2701         }
2702         // match: (Move [6] {t} dst src mem)
2703         // cond: t.Alignment()%2 == 0
2704         // result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
2705         for {
2706                 if auxIntToInt64(v.AuxInt) != 6 {
2707                         break
2708                 }
2709                 t := auxToType(v.Aux)
2710                 dst := v_0
2711                 src := v_1
2712                 mem := v_2
2713                 if !(t.Alignment()%2 == 0) {
2714                         break
2715                 }
2716                 v.reset(OpRISCV64MOVHstore)
2717                 v.AuxInt = int32ToAuxInt(4)
2718                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2719                 v0.AuxInt = int32ToAuxInt(4)
2720                 v0.AddArg2(src, mem)
2721                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2722                 v1.AuxInt = int32ToAuxInt(2)
2723                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2724                 v2.AuxInt = int32ToAuxInt(2)
2725                 v2.AddArg2(src, mem)
2726                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2727                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2728                 v4.AddArg2(src, mem)
2729                 v3.AddArg3(dst, v4, mem)
2730                 v1.AddArg3(dst, v2, v3)
2731                 v.AddArg3(dst, v0, v1)
2732                 return true
2733         }
2734         // match: (Move [12] {t} dst src mem)
2735         // cond: t.Alignment()%4 == 0
2736         // result: (MOVWstore [8] dst (MOVWload [8] src mem) (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem)))
2737         for {
2738                 if auxIntToInt64(v.AuxInt) != 12 {
2739                         break
2740                 }
2741                 t := auxToType(v.Aux)
2742                 dst := v_0
2743                 src := v_1
2744                 mem := v_2
2745                 if !(t.Alignment()%4 == 0) {
2746                         break
2747                 }
2748                 v.reset(OpRISCV64MOVWstore)
2749                 v.AuxInt = int32ToAuxInt(8)
2750                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2751                 v0.AuxInt = int32ToAuxInt(8)
2752                 v0.AddArg2(src, mem)
2753                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
2754                 v1.AuxInt = int32ToAuxInt(4)
2755                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2756                 v2.AuxInt = int32ToAuxInt(4)
2757                 v2.AddArg2(src, mem)
2758                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
2759                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2760                 v4.AddArg2(src, mem)
2761                 v3.AddArg3(dst, v4, mem)
2762                 v1.AddArg3(dst, v2, v3)
2763                 v.AddArg3(dst, v0, v1)
2764                 return true
2765         }
2766         // match: (Move [16] {t} dst src mem)
2767         // cond: t.Alignment()%8 == 0
2768         // result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
2769         for {
2770                 if auxIntToInt64(v.AuxInt) != 16 {
2771                         break
2772                 }
2773                 t := auxToType(v.Aux)
2774                 dst := v_0
2775                 src := v_1
2776                 mem := v_2
2777                 if !(t.Alignment()%8 == 0) {
2778                         break
2779                 }
2780                 v.reset(OpRISCV64MOVDstore)
2781                 v.AuxInt = int32ToAuxInt(8)
2782                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2783                 v0.AuxInt = int32ToAuxInt(8)
2784                 v0.AddArg2(src, mem)
2785                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2786                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2787                 v2.AddArg2(src, mem)
2788                 v1.AddArg3(dst, v2, mem)
2789                 v.AddArg3(dst, v0, v1)
2790                 return true
2791         }
2792         // match: (Move [24] {t} dst src mem)
2793         // cond: t.Alignment()%8 == 0
2794         // result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
2795         for {
2796                 if auxIntToInt64(v.AuxInt) != 24 {
2797                         break
2798                 }
2799                 t := auxToType(v.Aux)
2800                 dst := v_0
2801                 src := v_1
2802                 mem := v_2
2803                 if !(t.Alignment()%8 == 0) {
2804                         break
2805                 }
2806                 v.reset(OpRISCV64MOVDstore)
2807                 v.AuxInt = int32ToAuxInt(16)
2808                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2809                 v0.AuxInt = int32ToAuxInt(16)
2810                 v0.AddArg2(src, mem)
2811                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2812                 v1.AuxInt = int32ToAuxInt(8)
2813                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2814                 v2.AuxInt = int32ToAuxInt(8)
2815                 v2.AddArg2(src, mem)
2816                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2817                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2818                 v4.AddArg2(src, mem)
2819                 v3.AddArg3(dst, v4, mem)
2820                 v1.AddArg3(dst, v2, v3)
2821                 v.AddArg3(dst, v0, v1)
2822                 return true
2823         }
2824         // match: (Move [32] {t} dst src mem)
2825         // cond: t.Alignment()%8 == 0
2826         // result: (MOVDstore [24] dst (MOVDload [24] src mem) (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))))
2827         for {
2828                 if auxIntToInt64(v.AuxInt) != 32 {
2829                         break
2830                 }
2831                 t := auxToType(v.Aux)
2832                 dst := v_0
2833                 src := v_1
2834                 mem := v_2
2835                 if !(t.Alignment()%8 == 0) {
2836                         break
2837                 }
2838                 v.reset(OpRISCV64MOVDstore)
2839                 v.AuxInt = int32ToAuxInt(24)
2840                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2841                 v0.AuxInt = int32ToAuxInt(24)
2842                 v0.AddArg2(src, mem)
2843                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2844                 v1.AuxInt = int32ToAuxInt(16)
2845                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2846                 v2.AuxInt = int32ToAuxInt(16)
2847                 v2.AddArg2(src, mem)
2848                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2849                 v3.AuxInt = int32ToAuxInt(8)
2850                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2851                 v4.AuxInt = int32ToAuxInt(8)
2852                 v4.AddArg2(src, mem)
2853                 v5 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2854                 v6 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2855                 v6.AddArg2(src, mem)
2856                 v5.AddArg3(dst, v6, mem)
2857                 v3.AddArg3(dst, v4, v5)
2858                 v1.AddArg3(dst, v2, v3)
2859                 v.AddArg3(dst, v0, v1)
2860                 return true
2861         }
2862         // match: (Move [s] {t} dst src mem)
2863         // cond: s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice && logLargeCopy(v, s)
2864         // result: (DUFFCOPY [16 * (128 - s/8)] dst src mem)
2865         for {
2866                 s := auxIntToInt64(v.AuxInt)
2867                 t := auxToType(v.Aux)
2868                 dst := v_0
2869                 src := v_1
2870                 mem := v_2
2871                 if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice && logLargeCopy(v, s)) {
2872                         break
2873                 }
2874                 v.reset(OpRISCV64DUFFCOPY)
2875                 v.AuxInt = int64ToAuxInt(16 * (128 - s/8))
2876                 v.AddArg3(dst, src, mem)
2877                 return true
2878         }
2879         // match: (Move [s] {t} dst src mem)
2880         // cond: (s <= 16 || logLargeCopy(v, s))
2881         // result: (LoweredMove [t.Alignment()] dst src (ADDI <src.Type> [s-moveSize(t.Alignment(), config)] src) mem)
2882         for {
2883                 s := auxIntToInt64(v.AuxInt)
2884                 t := auxToType(v.Aux)
2885                 dst := v_0
2886                 src := v_1
2887                 mem := v_2
2888                 if !(s <= 16 || logLargeCopy(v, s)) {
2889                         break
2890                 }
2891                 v.reset(OpRISCV64LoweredMove)
2892                 v.AuxInt = int64ToAuxInt(t.Alignment())
2893                 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, src.Type)
2894                 v0.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
2895                 v0.AddArg(src)
2896                 v.AddArg4(dst, src, v0, mem)
2897                 return true
2898         }
2899         return false
2900 }
2901 func rewriteValueRISCV64_OpMul16(v *Value) bool {
2902         v_1 := v.Args[1]
2903         v_0 := v.Args[0]
2904         b := v.Block
2905         typ := &b.Func.Config.Types
2906         // match: (Mul16 x y)
2907         // result: (MULW (SignExt16to32 x) (SignExt16to32 y))
2908         for {
2909                 x := v_0
2910                 y := v_1
2911                 v.reset(OpRISCV64MULW)
2912                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2913                 v0.AddArg(x)
2914                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2915                 v1.AddArg(y)
2916                 v.AddArg2(v0, v1)
2917                 return true
2918         }
2919 }
2920 func rewriteValueRISCV64_OpMul8(v *Value) bool {
2921         v_1 := v.Args[1]
2922         v_0 := v.Args[0]
2923         b := v.Block
2924         typ := &b.Func.Config.Types
2925         // match: (Mul8 x y)
2926         // result: (MULW (SignExt8to32 x) (SignExt8to32 y))
2927         for {
2928                 x := v_0
2929                 y := v_1
2930                 v.reset(OpRISCV64MULW)
2931                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2932                 v0.AddArg(x)
2933                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2934                 v1.AddArg(y)
2935                 v.AddArg2(v0, v1)
2936                 return true
2937         }
2938 }
2939 func rewriteValueRISCV64_OpNeq16(v *Value) bool {
2940         v_1 := v.Args[1]
2941         v_0 := v.Args[0]
2942         b := v.Block
2943         typ := &b.Func.Config.Types
2944         // match: (Neq16 x y)
2945         // result: (SNEZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
2946         for {
2947                 x := v_0
2948                 y := v_1
2949                 v.reset(OpRISCV64SNEZ)
2950                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2951                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2952                 v1.AddArg(x)
2953                 v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2954                 v2.AddArg(y)
2955                 v0.AddArg2(v1, v2)
2956                 v.AddArg(v0)
2957                 return true
2958         }
2959 }
2960 func rewriteValueRISCV64_OpNeq32(v *Value) bool {
2961         v_1 := v.Args[1]
2962         v_0 := v.Args[0]
2963         b := v.Block
2964         typ := &b.Func.Config.Types
2965         // match: (Neq32 x y)
2966         // result: (SNEZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
2967         for {
2968                 x := v_0
2969                 y := v_1
2970                 v.reset(OpRISCV64SNEZ)
2971                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2972                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2973                 v1.AddArg(x)
2974                 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2975                 v2.AddArg(y)
2976                 v0.AddArg2(v1, v2)
2977                 v.AddArg(v0)
2978                 return true
2979         }
2980 }
2981 func rewriteValueRISCV64_OpNeq64(v *Value) bool {
2982         v_1 := v.Args[1]
2983         v_0 := v.Args[0]
2984         b := v.Block
2985         // match: (Neq64 x y)
2986         // result: (SNEZ (SUB <x.Type> x y))
2987         for {
2988                 x := v_0
2989                 y := v_1
2990                 v.reset(OpRISCV64SNEZ)
2991                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2992                 v0.AddArg2(x, y)
2993                 v.AddArg(v0)
2994                 return true
2995         }
2996 }
2997 func rewriteValueRISCV64_OpNeq8(v *Value) bool {
2998         v_1 := v.Args[1]
2999         v_0 := v.Args[0]
3000         b := v.Block
3001         typ := &b.Func.Config.Types
3002         // match: (Neq8 x y)
3003         // result: (SNEZ (SUB <x.Type> (ZeroExt8to64 x) (ZeroExt8to64 y)))
3004         for {
3005                 x := v_0
3006                 y := v_1
3007                 v.reset(OpRISCV64SNEZ)
3008                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
3009                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3010                 v1.AddArg(x)
3011                 v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
3012                 v2.AddArg(y)
3013                 v0.AddArg2(v1, v2)
3014                 v.AddArg(v0)
3015                 return true
3016         }
3017 }
3018 func rewriteValueRISCV64_OpNeqB(v *Value) bool {
3019         v_1 := v.Args[1]
3020         v_0 := v.Args[0]
3021         b := v.Block
3022         typ := &b.Func.Config.Types
3023         // match: (NeqB x y)
3024         // result: (SNEZ (SUB <typ.Bool> x y))
3025         for {
3026                 x := v_0
3027                 y := v_1
3028                 v.reset(OpRISCV64SNEZ)
3029                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Bool)
3030                 v0.AddArg2(x, y)
3031                 v.AddArg(v0)
3032                 return true
3033         }
3034 }
3035 func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
3036         v_1 := v.Args[1]
3037         v_0 := v.Args[0]
3038         b := v.Block
3039         typ := &b.Func.Config.Types
3040         // match: (NeqPtr x y)
3041         // result: (SNEZ (SUB <typ.Uintptr> x y))
3042         for {
3043                 x := v_0
3044                 y := v_1
3045                 v.reset(OpRISCV64SNEZ)
3046                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.Uintptr)
3047                 v0.AddArg2(x, y)
3048                 v.AddArg(v0)
3049                 return true
3050         }
3051 }
3052 func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
3053         v_0 := v.Args[0]
3054         b := v.Block
3055         typ := &b.Func.Config.Types
3056         // match: (OffPtr [off] ptr:(SP))
3057         // cond: is32Bit(off)
3058         // result: (MOVaddr [int32(off)] ptr)
3059         for {
3060                 off := auxIntToInt64(v.AuxInt)
3061                 ptr := v_0
3062                 if ptr.Op != OpSP || !(is32Bit(off)) {
3063                         break
3064                 }
3065                 v.reset(OpRISCV64MOVaddr)
3066                 v.AuxInt = int32ToAuxInt(int32(off))
3067                 v.AddArg(ptr)
3068                 return true
3069         }
3070         // match: (OffPtr [off] ptr)
3071         // cond: is32Bit(off)
3072         // result: (ADDI [off] ptr)
3073         for {
3074                 off := auxIntToInt64(v.AuxInt)
3075                 ptr := v_0
3076                 if !(is32Bit(off)) {
3077                         break
3078                 }
3079                 v.reset(OpRISCV64ADDI)
3080                 v.AuxInt = int64ToAuxInt(off)
3081                 v.AddArg(ptr)
3082                 return true
3083         }
3084         // match: (OffPtr [off] ptr)
3085         // result: (ADD (MOVDconst [off]) ptr)
3086         for {
3087                 off := auxIntToInt64(v.AuxInt)
3088                 ptr := v_0
3089                 v.reset(OpRISCV64ADD)
3090                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
3091                 v0.AuxInt = int64ToAuxInt(off)
3092                 v.AddArg2(v0, ptr)
3093                 return true
3094         }
3095 }
3096 func rewriteValueRISCV64_OpPanicBounds(v *Value) bool {
3097         v_2 := v.Args[2]
3098         v_1 := v.Args[1]
3099         v_0 := v.Args[0]
3100         // match: (PanicBounds [kind] x y mem)
3101         // cond: boundsABI(kind) == 0
3102         // result: (LoweredPanicBoundsA [kind] x y mem)
3103         for {
3104                 kind := auxIntToInt64(v.AuxInt)
3105                 x := v_0
3106                 y := v_1
3107                 mem := v_2
3108                 if !(boundsABI(kind) == 0) {
3109                         break
3110                 }
3111                 v.reset(OpRISCV64LoweredPanicBoundsA)
3112                 v.AuxInt = int64ToAuxInt(kind)
3113                 v.AddArg3(x, y, mem)
3114                 return true
3115         }
3116         // match: (PanicBounds [kind] x y mem)
3117         // cond: boundsABI(kind) == 1
3118         // result: (LoweredPanicBoundsB [kind] x y mem)
3119         for {
3120                 kind := auxIntToInt64(v.AuxInt)
3121                 x := v_0
3122                 y := v_1
3123                 mem := v_2
3124                 if !(boundsABI(kind) == 1) {
3125                         break
3126                 }
3127                 v.reset(OpRISCV64LoweredPanicBoundsB)
3128                 v.AuxInt = int64ToAuxInt(kind)
3129                 v.AddArg3(x, y, mem)
3130                 return true
3131         }
3132         // match: (PanicBounds [kind] x y mem)
3133         // cond: boundsABI(kind) == 2
3134         // result: (LoweredPanicBoundsC [kind] x y mem)
3135         for {
3136                 kind := auxIntToInt64(v.AuxInt)
3137                 x := v_0
3138                 y := v_1
3139                 mem := v_2
3140                 if !(boundsABI(kind) == 2) {
3141                         break
3142                 }
3143                 v.reset(OpRISCV64LoweredPanicBoundsC)
3144                 v.AuxInt = int64ToAuxInt(kind)
3145                 v.AddArg3(x, y, mem)
3146                 return true
3147         }
3148         return false
3149 }
3150 func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
3151         v_1 := v.Args[1]
3152         v_0 := v.Args[0]
3153         // match: (ADD (MOVDconst <t> [val]) x)
3154         // cond: is32Bit(val) && !t.IsPtr()
3155         // result: (ADDI [val] x)
3156         for {
3157                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3158                         if v_0.Op != OpRISCV64MOVDconst {
3159                                 continue
3160                         }
3161                         t := v_0.Type
3162                         val := auxIntToInt64(v_0.AuxInt)
3163                         x := v_1
3164                         if !(is32Bit(val) && !t.IsPtr()) {
3165                                 continue
3166                         }
3167                         v.reset(OpRISCV64ADDI)
3168                         v.AuxInt = int64ToAuxInt(val)
3169                         v.AddArg(x)
3170                         return true
3171                 }
3172                 break
3173         }
3174         return false
3175 }
3176 func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
3177         v_0 := v.Args[0]
3178         // match: (ADDI [c] (MOVaddr [d] {s} x))
3179         // cond: is32Bit(c+int64(d))
3180         // result: (MOVaddr [int32(c)+d] {s} x)
3181         for {
3182                 c := auxIntToInt64(v.AuxInt)
3183                 if v_0.Op != OpRISCV64MOVaddr {
3184                         break
3185                 }
3186                 d := auxIntToInt32(v_0.AuxInt)
3187                 s := auxToSym(v_0.Aux)
3188                 x := v_0.Args[0]
3189                 if !(is32Bit(c + int64(d))) {
3190                         break
3191                 }
3192                 v.reset(OpRISCV64MOVaddr)
3193                 v.AuxInt = int32ToAuxInt(int32(c) + d)
3194                 v.Aux = symToAux(s)
3195                 v.AddArg(x)
3196                 return true
3197         }
3198         // match: (ADDI [0] x)
3199         // result: x
3200         for {
3201                 if auxIntToInt64(v.AuxInt) != 0 {
3202                         break
3203                 }
3204                 x := v_0
3205                 v.copyOf(x)
3206                 return true
3207         }
3208         // match: (ADDI [x] (MOVDconst [y]))
3209         // cond: is32Bit(x + y)
3210         // result: (MOVDconst [x + y])
3211         for {
3212                 x := auxIntToInt64(v.AuxInt)
3213                 if v_0.Op != OpRISCV64MOVDconst {
3214                         break
3215                 }
3216                 y := auxIntToInt64(v_0.AuxInt)
3217                 if !(is32Bit(x + y)) {
3218                         break
3219                 }
3220                 v.reset(OpRISCV64MOVDconst)
3221                 v.AuxInt = int64ToAuxInt(x + y)
3222                 return true
3223         }
3224         // match: (ADDI [x] (ADDI [y] z))
3225         // cond: is32Bit(x + y)
3226         // result: (ADDI [x + y] z)
3227         for {
3228                 x := auxIntToInt64(v.AuxInt)
3229                 if v_0.Op != OpRISCV64ADDI {
3230                         break
3231                 }
3232                 y := auxIntToInt64(v_0.AuxInt)
3233                 z := v_0.Args[0]
3234                 if !(is32Bit(x + y)) {
3235                         break
3236                 }
3237                 v.reset(OpRISCV64ADDI)
3238                 v.AuxInt = int64ToAuxInt(x + y)
3239                 v.AddArg(z)
3240                 return true
3241         }
3242         return false
3243 }
3244 func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
3245         v_1 := v.Args[1]
3246         v_0 := v.Args[0]
3247         // match: (AND (MOVDconst [val]) x)
3248         // cond: is32Bit(val)
3249         // result: (ANDI [val] x)
3250         for {
3251                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3252                         if v_0.Op != OpRISCV64MOVDconst {
3253                                 continue
3254                         }
3255                         val := auxIntToInt64(v_0.AuxInt)
3256                         x := v_1
3257                         if !(is32Bit(val)) {
3258                                 continue
3259                         }
3260                         v.reset(OpRISCV64ANDI)
3261                         v.AuxInt = int64ToAuxInt(val)
3262                         v.AddArg(x)
3263                         return true
3264                 }
3265                 break
3266         }
3267         return false
3268 }
3269 func rewriteValueRISCV64_OpRISCV64ANDI(v *Value) bool {
3270         v_0 := v.Args[0]
3271         // match: (ANDI [0] x)
3272         // result: (MOVDconst [0])
3273         for {
3274                 if auxIntToInt64(v.AuxInt) != 0 {
3275                         break
3276                 }
3277                 v.reset(OpRISCV64MOVDconst)
3278                 v.AuxInt = int64ToAuxInt(0)
3279                 return true
3280         }
3281         // match: (ANDI [-1] x)
3282         // result: x
3283         for {
3284                 if auxIntToInt64(v.AuxInt) != -1 {
3285                         break
3286                 }
3287                 x := v_0
3288                 v.copyOf(x)
3289                 return true
3290         }
3291         // match: (ANDI [x] (MOVDconst [y]))
3292         // result: (MOVDconst [x & y])
3293         for {
3294                 x := auxIntToInt64(v.AuxInt)
3295                 if v_0.Op != OpRISCV64MOVDconst {
3296                         break
3297                 }
3298                 y := auxIntToInt64(v_0.AuxInt)
3299                 v.reset(OpRISCV64MOVDconst)
3300                 v.AuxInt = int64ToAuxInt(x & y)
3301                 return true
3302         }
3303         // match: (ANDI [x] (ANDI [y] z))
3304         // result: (ANDI [x & y] z)
3305         for {
3306                 x := auxIntToInt64(v.AuxInt)
3307                 if v_0.Op != OpRISCV64ANDI {
3308                         break
3309                 }
3310                 y := auxIntToInt64(v_0.AuxInt)
3311                 z := v_0.Args[0]
3312                 v.reset(OpRISCV64ANDI)
3313                 v.AuxInt = int64ToAuxInt(x & y)
3314                 v.AddArg(z)
3315                 return true
3316         }
3317         return false
3318 }
3319 func rewriteValueRISCV64_OpRISCV64FMADDD(v *Value) bool {
3320         v_2 := v.Args[2]
3321         v_1 := v.Args[1]
3322         v_0 := v.Args[0]
3323         // match: (FMADDD neg:(FNEGD x) y z)
3324         // cond: neg.Uses == 1
3325         // result: (FNMSUBD x y z)
3326         for {
3327                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3328                         neg := v_0
3329                         if neg.Op != OpRISCV64FNEGD {
3330                                 continue
3331                         }
3332                         x := neg.Args[0]
3333                         y := v_1
3334                         z := v_2
3335                         if !(neg.Uses == 1) {
3336                                 continue
3337                         }
3338                         v.reset(OpRISCV64FNMSUBD)
3339                         v.AddArg3(x, y, z)
3340                         return true
3341                 }
3342                 break
3343         }
3344         // match: (FMADDD x y neg:(FNEGD z))
3345         // cond: neg.Uses == 1
3346         // result: (FMSUBD x y z)
3347         for {
3348                 x := v_0
3349                 y := v_1
3350                 neg := v_2
3351                 if neg.Op != OpRISCV64FNEGD {
3352                         break
3353                 }
3354                 z := neg.Args[0]
3355                 if !(neg.Uses == 1) {
3356                         break
3357                 }
3358                 v.reset(OpRISCV64FMSUBD)
3359                 v.AddArg3(x, y, z)
3360                 return true
3361         }
3362         return false
3363 }
3364 func rewriteValueRISCV64_OpRISCV64FMSUBD(v *Value) bool {
3365         v_2 := v.Args[2]
3366         v_1 := v.Args[1]
3367         v_0 := v.Args[0]
3368         // match: (FMSUBD neg:(FNEGD x) y z)
3369         // cond: neg.Uses == 1
3370         // result: (FNMADDD x y z)
3371         for {
3372                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3373                         neg := v_0
3374                         if neg.Op != OpRISCV64FNEGD {
3375                                 continue
3376                         }
3377                         x := neg.Args[0]
3378                         y := v_1
3379                         z := v_2
3380                         if !(neg.Uses == 1) {
3381                                 continue
3382                         }
3383                         v.reset(OpRISCV64FNMADDD)
3384                         v.AddArg3(x, y, z)
3385                         return true
3386                 }
3387                 break
3388         }
3389         // match: (FMSUBD x y neg:(FNEGD z))
3390         // cond: neg.Uses == 1
3391         // result: (FMADDD x y z)
3392         for {
3393                 x := v_0
3394                 y := v_1
3395                 neg := v_2
3396                 if neg.Op != OpRISCV64FNEGD {
3397                         break
3398                 }
3399                 z := neg.Args[0]
3400                 if !(neg.Uses == 1) {
3401                         break
3402                 }
3403                 v.reset(OpRISCV64FMADDD)
3404                 v.AddArg3(x, y, z)
3405                 return true
3406         }
3407         return false
3408 }
3409 func rewriteValueRISCV64_OpRISCV64FNMADDD(v *Value) bool {
3410         v_2 := v.Args[2]
3411         v_1 := v.Args[1]
3412         v_0 := v.Args[0]
3413         // match: (FNMADDD neg:(FNEGD x) y z)
3414         // cond: neg.Uses == 1
3415         // result: (FMSUBD x y z)
3416         for {
3417                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3418                         neg := v_0
3419                         if neg.Op != OpRISCV64FNEGD {
3420                                 continue
3421                         }
3422                         x := neg.Args[0]
3423                         y := v_1
3424                         z := v_2
3425                         if !(neg.Uses == 1) {
3426                                 continue
3427                         }
3428                         v.reset(OpRISCV64FMSUBD)
3429                         v.AddArg3(x, y, z)
3430                         return true
3431                 }
3432                 break
3433         }
3434         // match: (FNMADDD x y neg:(FNEGD z))
3435         // cond: neg.Uses == 1
3436         // result: (FNMSUBD x y z)
3437         for {
3438                 x := v_0
3439                 y := v_1
3440                 neg := v_2
3441                 if neg.Op != OpRISCV64FNEGD {
3442                         break
3443                 }
3444                 z := neg.Args[0]
3445                 if !(neg.Uses == 1) {
3446                         break
3447                 }
3448                 v.reset(OpRISCV64FNMSUBD)
3449                 v.AddArg3(x, y, z)
3450                 return true
3451         }
3452         return false
3453 }
3454 func rewriteValueRISCV64_OpRISCV64FNMSUBD(v *Value) bool {
3455         v_2 := v.Args[2]
3456         v_1 := v.Args[1]
3457         v_0 := v.Args[0]
3458         // match: (FNMSUBD neg:(FNEGD x) y z)
3459         // cond: neg.Uses == 1
3460         // result: (FMADDD x y z)
3461         for {
3462                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
3463                         neg := v_0
3464                         if neg.Op != OpRISCV64FNEGD {
3465                                 continue
3466                         }
3467                         x := neg.Args[0]
3468                         y := v_1
3469                         z := v_2
3470                         if !(neg.Uses == 1) {
3471                                 continue
3472                         }
3473                         v.reset(OpRISCV64FMADDD)
3474                         v.AddArg3(x, y, z)
3475                         return true
3476                 }
3477                 break
3478         }
3479         // match: (FNMSUBD x y neg:(FNEGD z))
3480         // cond: neg.Uses == 1
3481         // result: (FNMADDD x y z)
3482         for {
3483                 x := v_0
3484                 y := v_1
3485                 neg := v_2
3486                 if neg.Op != OpRISCV64FNEGD {
3487                         break
3488                 }
3489                 z := neg.Args[0]
3490                 if !(neg.Uses == 1) {
3491                         break
3492                 }
3493                 v.reset(OpRISCV64FNMADDD)
3494                 v.AddArg3(x, y, z)
3495                 return true
3496         }
3497         return false
3498 }
3499 func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
3500         v_1 := v.Args[1]
3501         v_0 := v.Args[0]
3502         // match: (MOVBUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
3503         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3504         // result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
3505         for {
3506                 off1 := auxIntToInt32(v.AuxInt)
3507                 sym1 := auxToSym(v.Aux)
3508                 if v_0.Op != OpRISCV64MOVaddr {
3509                         break
3510                 }
3511                 off2 := auxIntToInt32(v_0.AuxInt)
3512                 sym2 := auxToSym(v_0.Aux)
3513                 base := v_0.Args[0]
3514                 mem := v_1
3515                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3516                         break
3517                 }
3518                 v.reset(OpRISCV64MOVBUload)
3519                 v.AuxInt = int32ToAuxInt(off1 + off2)
3520                 v.Aux = symToAux(mergeSym(sym1, sym2))
3521                 v.AddArg2(base, mem)
3522                 return true
3523         }
3524         // match: (MOVBUload [off1] {sym} (ADDI [off2] base) mem)
3525         // cond: is32Bit(int64(off1)+off2)
3526         // result: (MOVBUload [off1+int32(off2)] {sym} base mem)
3527         for {
3528                 off1 := auxIntToInt32(v.AuxInt)
3529                 sym := auxToSym(v.Aux)
3530                 if v_0.Op != OpRISCV64ADDI {
3531                         break
3532                 }
3533                 off2 := auxIntToInt64(v_0.AuxInt)
3534                 base := v_0.Args[0]
3535                 mem := v_1
3536                 if !(is32Bit(int64(off1) + off2)) {
3537                         break
3538                 }
3539                 v.reset(OpRISCV64MOVBUload)
3540                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3541                 v.Aux = symToAux(sym)
3542                 v.AddArg2(base, mem)
3543                 return true
3544         }
3545         return false
3546 }
3547 func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
3548         v_0 := v.Args[0]
3549         b := v.Block
3550         // match: (MOVBUreg x:(FLES _ _))
3551         // result: x
3552         for {
3553                 x := v_0
3554                 if x.Op != OpRISCV64FLES {
3555                         break
3556                 }
3557                 v.copyOf(x)
3558                 return true
3559         }
3560         // match: (MOVBUreg x:(FLTS _ _))
3561         // result: x
3562         for {
3563                 x := v_0
3564                 if x.Op != OpRISCV64FLTS {
3565                         break
3566                 }
3567                 v.copyOf(x)
3568                 return true
3569         }
3570         // match: (MOVBUreg x:(FEQS _ _))
3571         // result: x
3572         for {
3573                 x := v_0
3574                 if x.Op != OpRISCV64FEQS {
3575                         break
3576                 }
3577                 v.copyOf(x)
3578                 return true
3579         }
3580         // match: (MOVBUreg x:(FNES _ _))
3581         // result: x
3582         for {
3583                 x := v_0
3584                 if x.Op != OpRISCV64FNES {
3585                         break
3586                 }
3587                 v.copyOf(x)
3588                 return true
3589         }
3590         // match: (MOVBUreg x:(FLED _ _))
3591         // result: x
3592         for {
3593                 x := v_0
3594                 if x.Op != OpRISCV64FLED {
3595                         break
3596                 }
3597                 v.copyOf(x)
3598                 return true
3599         }
3600         // match: (MOVBUreg x:(FLTD _ _))
3601         // result: x
3602         for {
3603                 x := v_0
3604                 if x.Op != OpRISCV64FLTD {
3605                         break
3606                 }
3607                 v.copyOf(x)
3608                 return true
3609         }
3610         // match: (MOVBUreg x:(FEQD _ _))
3611         // result: x
3612         for {
3613                 x := v_0
3614                 if x.Op != OpRISCV64FEQD {
3615                         break
3616                 }
3617                 v.copyOf(x)
3618                 return true
3619         }
3620         // match: (MOVBUreg x:(FNED _ _))
3621         // result: x
3622         for {
3623                 x := v_0
3624                 if x.Op != OpRISCV64FNED {
3625                         break
3626                 }
3627                 v.copyOf(x)
3628                 return true
3629         }
3630         // match: (MOVBUreg x:(SEQZ _))
3631         // result: x
3632         for {
3633                 x := v_0
3634                 if x.Op != OpRISCV64SEQZ {
3635                         break
3636                 }
3637                 v.copyOf(x)
3638                 return true
3639         }
3640         // match: (MOVBUreg x:(SNEZ _))
3641         // result: x
3642         for {
3643                 x := v_0
3644                 if x.Op != OpRISCV64SNEZ {
3645                         break
3646                 }
3647                 v.copyOf(x)
3648                 return true
3649         }
3650         // match: (MOVBUreg x:(SLT _ _))
3651         // result: x
3652         for {
3653                 x := v_0
3654                 if x.Op != OpRISCV64SLT {
3655                         break
3656                 }
3657                 v.copyOf(x)
3658                 return true
3659         }
3660         // match: (MOVBUreg x:(SLTU _ _))
3661         // result: x
3662         for {
3663                 x := v_0
3664                 if x.Op != OpRISCV64SLTU {
3665                         break
3666                 }
3667                 v.copyOf(x)
3668                 return true
3669         }
3670         // match: (MOVBUreg x:(ANDI [c] y))
3671         // cond: c >= 0 && int64(uint8(c)) == c
3672         // result: x
3673         for {
3674                 x := v_0
3675                 if x.Op != OpRISCV64ANDI {
3676                         break
3677                 }
3678                 c := auxIntToInt64(x.AuxInt)
3679                 if !(c >= 0 && int64(uint8(c)) == c) {
3680                         break
3681                 }
3682                 v.copyOf(x)
3683                 return true
3684         }
3685         // match: (MOVBUreg (ANDI [c] x))
3686         // cond: c < 0
3687         // result: (ANDI [int64(uint8(c))] x)
3688         for {
3689                 if v_0.Op != OpRISCV64ANDI {
3690                         break
3691                 }
3692                 c := auxIntToInt64(v_0.AuxInt)
3693                 x := v_0.Args[0]
3694                 if !(c < 0) {
3695                         break
3696                 }
3697                 v.reset(OpRISCV64ANDI)
3698                 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
3699                 v.AddArg(x)
3700                 return true
3701         }
3702         // match: (MOVBUreg (MOVDconst [c]))
3703         // result: (MOVDconst [int64(uint8(c))])
3704         for {
3705                 if v_0.Op != OpRISCV64MOVDconst {
3706                         break
3707                 }
3708                 c := auxIntToInt64(v_0.AuxInt)
3709                 v.reset(OpRISCV64MOVDconst)
3710                 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
3711                 return true
3712         }
3713         // match: (MOVBUreg x:(MOVBUload _ _))
3714         // result: (MOVDreg x)
3715         for {
3716                 x := v_0
3717                 if x.Op != OpRISCV64MOVBUload {
3718                         break
3719                 }
3720                 v.reset(OpRISCV64MOVDreg)
3721                 v.AddArg(x)
3722                 return true
3723         }
3724         // match: (MOVBUreg x:(Select0 (LoweredAtomicLoad8 _ _)))
3725         // result: (MOVDreg x)
3726         for {
3727                 x := v_0
3728                 if x.Op != OpSelect0 {
3729                         break
3730                 }
3731                 x_0 := x.Args[0]
3732                 if x_0.Op != OpRISCV64LoweredAtomicLoad8 {
3733                         break
3734                 }
3735                 v.reset(OpRISCV64MOVDreg)
3736                 v.AddArg(x)
3737                 return true
3738         }
3739         // match: (MOVBUreg x:(Select0 (LoweredAtomicCas32 _ _ _ _)))
3740         // result: (MOVDreg x)
3741         for {
3742                 x := v_0
3743                 if x.Op != OpSelect0 {
3744                         break
3745                 }
3746                 x_0 := x.Args[0]
3747                 if x_0.Op != OpRISCV64LoweredAtomicCas32 {
3748                         break
3749                 }
3750                 v.reset(OpRISCV64MOVDreg)
3751                 v.AddArg(x)
3752                 return true
3753         }
3754         // match: (MOVBUreg x:(Select0 (LoweredAtomicCas64 _ _ _ _)))
3755         // result: (MOVDreg x)
3756         for {
3757                 x := v_0
3758                 if x.Op != OpSelect0 {
3759                         break
3760                 }
3761                 x_0 := x.Args[0]
3762                 if x_0.Op != OpRISCV64LoweredAtomicCas64 {
3763                         break
3764                 }
3765                 v.reset(OpRISCV64MOVDreg)
3766                 v.AddArg(x)
3767                 return true
3768         }
3769         // match: (MOVBUreg x:(MOVBUreg _))
3770         // result: (MOVDreg x)
3771         for {
3772                 x := v_0
3773                 if x.Op != OpRISCV64MOVBUreg {
3774                         break
3775                 }
3776                 v.reset(OpRISCV64MOVDreg)
3777                 v.AddArg(x)
3778                 return true
3779         }
3780         // match: (MOVBUreg <t> x:(MOVBload [off] {sym} ptr mem))
3781         // cond: x.Uses == 1 && clobber(x)
3782         // result: @x.Block (MOVBUload <t> [off] {sym} ptr mem)
3783         for {
3784                 t := v.Type
3785                 x := v_0
3786                 if x.Op != OpRISCV64MOVBload {
3787                         break
3788                 }
3789                 off := auxIntToInt32(x.AuxInt)
3790                 sym := auxToSym(x.Aux)
3791                 mem := x.Args[1]
3792                 ptr := x.Args[0]
3793                 if !(x.Uses == 1 && clobber(x)) {
3794                         break
3795                 }
3796                 b = x.Block
3797                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBUload, t)
3798                 v.copyOf(v0)
3799                 v0.AuxInt = int32ToAuxInt(off)
3800                 v0.Aux = symToAux(sym)
3801                 v0.AddArg2(ptr, mem)
3802                 return true
3803         }
3804         return false
3805 }
3806 func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
3807         v_1 := v.Args[1]
3808         v_0 := v.Args[0]
3809         // match: (MOVBload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
3810         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3811         // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
3812         for {
3813                 off1 := auxIntToInt32(v.AuxInt)
3814                 sym1 := auxToSym(v.Aux)
3815                 if v_0.Op != OpRISCV64MOVaddr {
3816                         break
3817                 }
3818                 off2 := auxIntToInt32(v_0.AuxInt)
3819                 sym2 := auxToSym(v_0.Aux)
3820                 base := v_0.Args[0]
3821                 mem := v_1
3822                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3823                         break
3824                 }
3825                 v.reset(OpRISCV64MOVBload)
3826                 v.AuxInt = int32ToAuxInt(off1 + off2)
3827                 v.Aux = symToAux(mergeSym(sym1, sym2))
3828                 v.AddArg2(base, mem)
3829                 return true
3830         }
3831         // match: (MOVBload [off1] {sym} (ADDI [off2] base) mem)
3832         // cond: is32Bit(int64(off1)+off2)
3833         // result: (MOVBload [off1+int32(off2)] {sym} base mem)
3834         for {
3835                 off1 := auxIntToInt32(v.AuxInt)
3836                 sym := auxToSym(v.Aux)
3837                 if v_0.Op != OpRISCV64ADDI {
3838                         break
3839                 }
3840                 off2 := auxIntToInt64(v_0.AuxInt)
3841                 base := v_0.Args[0]
3842                 mem := v_1
3843                 if !(is32Bit(int64(off1) + off2)) {
3844                         break
3845                 }
3846                 v.reset(OpRISCV64MOVBload)
3847                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3848                 v.Aux = symToAux(sym)
3849                 v.AddArg2(base, mem)
3850                 return true
3851         }
3852         return false
3853 }
3854 func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
3855         v_0 := v.Args[0]
3856         b := v.Block
3857         // match: (MOVBreg x:(ANDI [c] y))
3858         // cond: c >= 0 && int64(int8(c)) == c
3859         // result: x
3860         for {
3861                 x := v_0
3862                 if x.Op != OpRISCV64ANDI {
3863                         break
3864                 }
3865                 c := auxIntToInt64(x.AuxInt)
3866                 if !(c >= 0 && int64(int8(c)) == c) {
3867                         break
3868                 }
3869                 v.copyOf(x)
3870                 return true
3871         }
3872         // match: (MOVBreg (MOVDconst [c]))
3873         // result: (MOVDconst [int64(int8(c))])
3874         for {
3875                 if v_0.Op != OpRISCV64MOVDconst {
3876                         break
3877                 }
3878                 c := auxIntToInt64(v_0.AuxInt)
3879                 v.reset(OpRISCV64MOVDconst)
3880                 v.AuxInt = int64ToAuxInt(int64(int8(c)))
3881                 return true
3882         }
3883         // match: (MOVBreg x:(MOVBload _ _))
3884         // result: (MOVDreg x)
3885         for {
3886                 x := v_0
3887                 if x.Op != OpRISCV64MOVBload {
3888                         break
3889                 }
3890                 v.reset(OpRISCV64MOVDreg)
3891                 v.AddArg(x)
3892                 return true
3893         }
3894         // match: (MOVBreg x:(MOVBreg _))
3895         // result: (MOVDreg x)
3896         for {
3897                 x := v_0
3898                 if x.Op != OpRISCV64MOVBreg {
3899                         break
3900                 }
3901                 v.reset(OpRISCV64MOVDreg)
3902                 v.AddArg(x)
3903                 return true
3904         }
3905         // match: (MOVBreg <t> x:(MOVBUload [off] {sym} ptr mem))
3906         // cond: x.Uses == 1 && clobber(x)
3907         // result: @x.Block (MOVBload <t> [off] {sym} ptr mem)
3908         for {
3909                 t := v.Type
3910                 x := v_0
3911                 if x.Op != OpRISCV64MOVBUload {
3912                         break
3913                 }
3914                 off := auxIntToInt32(x.AuxInt)
3915                 sym := auxToSym(x.Aux)
3916                 mem := x.Args[1]
3917                 ptr := x.Args[0]
3918                 if !(x.Uses == 1 && clobber(x)) {
3919                         break
3920                 }
3921                 b = x.Block
3922                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBload, t)
3923                 v.copyOf(v0)
3924                 v0.AuxInt = int32ToAuxInt(off)
3925                 v0.Aux = symToAux(sym)
3926                 v0.AddArg2(ptr, mem)
3927                 return true
3928         }
3929         return false
3930 }
3931 func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
3932         v_2 := v.Args[2]
3933         v_1 := v.Args[1]
3934         v_0 := v.Args[0]
3935         // match: (MOVBstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
3936         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3937         // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
3938         for {
3939                 off1 := auxIntToInt32(v.AuxInt)
3940                 sym1 := auxToSym(v.Aux)
3941                 if v_0.Op != OpRISCV64MOVaddr {
3942                         break
3943                 }
3944                 off2 := auxIntToInt32(v_0.AuxInt)
3945                 sym2 := auxToSym(v_0.Aux)
3946                 base := v_0.Args[0]
3947                 val := v_1
3948                 mem := v_2
3949                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3950                         break
3951                 }
3952                 v.reset(OpRISCV64MOVBstore)
3953                 v.AuxInt = int32ToAuxInt(off1 + off2)
3954                 v.Aux = symToAux(mergeSym(sym1, sym2))
3955                 v.AddArg3(base, val, mem)
3956                 return true
3957         }
3958         // match: (MOVBstore [off1] {sym} (ADDI [off2] base) val mem)
3959         // cond: is32Bit(int64(off1)+off2)
3960         // result: (MOVBstore [off1+int32(off2)] {sym} base val mem)
3961         for {
3962                 off1 := auxIntToInt32(v.AuxInt)
3963                 sym := auxToSym(v.Aux)
3964                 if v_0.Op != OpRISCV64ADDI {
3965                         break
3966                 }
3967                 off2 := auxIntToInt64(v_0.AuxInt)
3968                 base := v_0.Args[0]
3969                 val := v_1
3970                 mem := v_2
3971                 if !(is32Bit(int64(off1) + off2)) {
3972                         break
3973                 }
3974                 v.reset(OpRISCV64MOVBstore)
3975                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3976                 v.Aux = symToAux(sym)
3977                 v.AddArg3(base, val, mem)
3978                 return true
3979         }
3980         // match: (MOVBstore [off] {sym} ptr (MOVDconst [0]) mem)
3981         // result: (MOVBstorezero [off] {sym} ptr mem)
3982         for {
3983                 off := auxIntToInt32(v.AuxInt)
3984                 sym := auxToSym(v.Aux)
3985                 ptr := v_0
3986                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
3987                         break
3988                 }
3989                 mem := v_2
3990                 v.reset(OpRISCV64MOVBstorezero)
3991                 v.AuxInt = int32ToAuxInt(off)
3992                 v.Aux = symToAux(sym)
3993                 v.AddArg2(ptr, mem)
3994                 return true
3995         }
3996         // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
3997         // result: (MOVBstore [off] {sym} ptr x mem)
3998         for {
3999                 off := auxIntToInt32(v.AuxInt)
4000                 sym := auxToSym(v.Aux)
4001                 ptr := v_0
4002                 if v_1.Op != OpRISCV64MOVBreg {
4003                         break
4004                 }
4005                 x := v_1.Args[0]
4006                 mem := v_2
4007                 v.reset(OpRISCV64MOVBstore)
4008                 v.AuxInt = int32ToAuxInt(off)
4009                 v.Aux = symToAux(sym)
4010                 v.AddArg3(ptr, x, mem)
4011                 return true
4012         }
4013         // match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem)
4014         // result: (MOVBstore [off] {sym} ptr x mem)
4015         for {
4016                 off := auxIntToInt32(v.AuxInt)
4017                 sym := auxToSym(v.Aux)
4018                 ptr := v_0
4019                 if v_1.Op != OpRISCV64MOVHreg {
4020                         break
4021                 }
4022                 x := v_1.Args[0]
4023                 mem := v_2
4024                 v.reset(OpRISCV64MOVBstore)
4025                 v.AuxInt = int32ToAuxInt(off)
4026                 v.Aux = symToAux(sym)
4027                 v.AddArg3(ptr, x, mem)
4028                 return true
4029         }
4030         // match: (MOVBstore [off] {sym} ptr (MOVWreg x) mem)
4031         // result: (MOVBstore [off] {sym} ptr x mem)
4032         for {
4033                 off := auxIntToInt32(v.AuxInt)
4034                 sym := auxToSym(v.Aux)
4035                 ptr := v_0
4036                 if v_1.Op != OpRISCV64MOVWreg {
4037                         break
4038                 }
4039                 x := v_1.Args[0]
4040                 mem := v_2
4041                 v.reset(OpRISCV64MOVBstore)
4042                 v.AuxInt = int32ToAuxInt(off)
4043                 v.Aux = symToAux(sym)
4044                 v.AddArg3(ptr, x, mem)
4045                 return true
4046         }
4047         // match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem)
4048         // result: (MOVBstore [off] {sym} ptr x mem)
4049         for {
4050                 off := auxIntToInt32(v.AuxInt)
4051                 sym := auxToSym(v.Aux)
4052                 ptr := v_0
4053                 if v_1.Op != OpRISCV64MOVBUreg {
4054                         break
4055                 }
4056                 x := v_1.Args[0]
4057                 mem := v_2
4058                 v.reset(OpRISCV64MOVBstore)
4059                 v.AuxInt = int32ToAuxInt(off)
4060                 v.Aux = symToAux(sym)
4061                 v.AddArg3(ptr, x, mem)
4062                 return true
4063         }
4064         // match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem)
4065         // result: (MOVBstore [off] {sym} ptr x mem)
4066         for {
4067                 off := auxIntToInt32(v.AuxInt)
4068                 sym := auxToSym(v.Aux)
4069                 ptr := v_0
4070                 if v_1.Op != OpRISCV64MOVHUreg {
4071                         break
4072                 }
4073                 x := v_1.Args[0]
4074                 mem := v_2
4075                 v.reset(OpRISCV64MOVBstore)
4076                 v.AuxInt = int32ToAuxInt(off)
4077                 v.Aux = symToAux(sym)
4078                 v.AddArg3(ptr, x, mem)
4079                 return true
4080         }
4081         // match: (MOVBstore [off] {sym} ptr (MOVWUreg x) mem)
4082         // result: (MOVBstore [off] {sym} ptr x mem)
4083         for {
4084                 off := auxIntToInt32(v.AuxInt)
4085                 sym := auxToSym(v.Aux)
4086                 ptr := v_0
4087                 if v_1.Op != OpRISCV64MOVWUreg {
4088                         break
4089                 }
4090                 x := v_1.Args[0]
4091                 mem := v_2
4092                 v.reset(OpRISCV64MOVBstore)
4093                 v.AuxInt = int32ToAuxInt(off)
4094                 v.Aux = symToAux(sym)
4095                 v.AddArg3(ptr, x, mem)
4096                 return true
4097         }
4098         return false
4099 }
4100 func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
4101         v_1 := v.Args[1]
4102         v_0 := v.Args[0]
4103         // match: (MOVBstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
4104         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
4105         // result: (MOVBstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
4106         for {
4107                 off1 := auxIntToInt32(v.AuxInt)
4108                 sym1 := auxToSym(v.Aux)
4109                 if v_0.Op != OpRISCV64MOVaddr {
4110                         break
4111                 }
4112                 off2 := auxIntToInt32(v_0.AuxInt)
4113                 sym2 := auxToSym(v_0.Aux)
4114                 ptr := v_0.Args[0]
4115                 mem := v_1
4116                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
4117                         break
4118                 }
4119                 v.reset(OpRISCV64MOVBstorezero)
4120                 v.AuxInt = int32ToAuxInt(off1 + off2)
4121                 v.Aux = symToAux(mergeSym(sym1, sym2))
4122                 v.AddArg2(ptr, mem)
4123                 return true
4124         }
4125         // match: (MOVBstorezero [off1] {sym} (ADDI [off2] ptr) mem)
4126         // cond: is32Bit(int64(off1)+off2)
4127         // result: (MOVBstorezero [off1+int32(off2)] {sym} ptr mem)
4128         for {
4129                 off1 := auxIntToInt32(v.AuxInt)
4130                 sym := auxToSym(v.Aux)
4131                 if v_0.Op != OpRISCV64ADDI {
4132                         break
4133                 }
4134                 off2 := auxIntToInt64(v_0.AuxInt)
4135                 ptr := v_0.Args[0]
4136                 mem := v_1
4137                 if !(is32Bit(int64(off1) + off2)) {
4138                         break
4139                 }
4140                 v.reset(OpRISCV64MOVBstorezero)
4141                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4142                 v.Aux = symToAux(sym)
4143                 v.AddArg2(ptr, mem)
4144                 return true
4145         }
4146         return false
4147 }
4148 func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
4149         v_1 := v.Args[1]
4150         v_0 := v.Args[0]
4151         // match: (MOVDload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
4152         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4153         // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
4154         for {
4155                 off1 := auxIntToInt32(v.AuxInt)
4156                 sym1 := auxToSym(v.Aux)
4157                 if v_0.Op != OpRISCV64MOVaddr {
4158                         break
4159                 }
4160                 off2 := auxIntToInt32(v_0.AuxInt)
4161                 sym2 := auxToSym(v_0.Aux)
4162                 base := v_0.Args[0]
4163                 mem := v_1
4164                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4165                         break
4166                 }
4167                 v.reset(OpRISCV64MOVDload)
4168                 v.AuxInt = int32ToAuxInt(off1 + off2)
4169                 v.Aux = symToAux(mergeSym(sym1, sym2))
4170                 v.AddArg2(base, mem)
4171                 return true
4172         }
4173         // match: (MOVDload [off1] {sym} (ADDI [off2] base) mem)
4174         // cond: is32Bit(int64(off1)+off2)
4175         // result: (MOVDload [off1+int32(off2)] {sym} base mem)
4176         for {
4177                 off1 := auxIntToInt32(v.AuxInt)
4178                 sym := auxToSym(v.Aux)
4179                 if v_0.Op != OpRISCV64ADDI {
4180                         break
4181                 }
4182                 off2 := auxIntToInt64(v_0.AuxInt)
4183                 base := v_0.Args[0]
4184                 mem := v_1
4185                 if !(is32Bit(int64(off1) + off2)) {
4186                         break
4187                 }
4188                 v.reset(OpRISCV64MOVDload)
4189                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4190                 v.Aux = symToAux(sym)
4191                 v.AddArg2(base, mem)
4192                 return true
4193         }
4194         return false
4195 }
4196 func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
4197         v_0 := v.Args[0]
4198         // match: (MOVDnop (MOVDconst [c]))
4199         // result: (MOVDconst [c])
4200         for {
4201                 if v_0.Op != OpRISCV64MOVDconst {
4202                         break
4203                 }
4204                 c := auxIntToInt64(v_0.AuxInt)
4205                 v.reset(OpRISCV64MOVDconst)
4206                 v.AuxInt = int64ToAuxInt(c)
4207                 return true
4208         }
4209         return false
4210 }
4211 func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
4212         v_0 := v.Args[0]
4213         // match: (MOVDreg x)
4214         // cond: x.Uses == 1
4215         // result: (MOVDnop x)
4216         for {
4217                 x := v_0
4218                 if !(x.Uses == 1) {
4219                         break
4220                 }
4221                 v.reset(OpRISCV64MOVDnop)
4222                 v.AddArg(x)
4223                 return true
4224         }
4225         return false
4226 }
4227 func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
4228         v_2 := v.Args[2]
4229         v_1 := v.Args[1]
4230         v_0 := v.Args[0]
4231         // match: (MOVDstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
4232         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4233         // result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
4234         for {
4235                 off1 := auxIntToInt32(v.AuxInt)
4236                 sym1 := auxToSym(v.Aux)
4237                 if v_0.Op != OpRISCV64MOVaddr {
4238                         break
4239                 }
4240                 off2 := auxIntToInt32(v_0.AuxInt)
4241                 sym2 := auxToSym(v_0.Aux)
4242                 base := v_0.Args[0]
4243                 val := v_1
4244                 mem := v_2
4245                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4246                         break
4247                 }
4248                 v.reset(OpRISCV64MOVDstore)
4249                 v.AuxInt = int32ToAuxInt(off1 + off2)
4250                 v.Aux = symToAux(mergeSym(sym1, sym2))
4251                 v.AddArg3(base, val, mem)
4252                 return true
4253         }
4254         // match: (MOVDstore [off1] {sym} (ADDI [off2] base) val mem)
4255         // cond: is32Bit(int64(off1)+off2)
4256         // result: (MOVDstore [off1+int32(off2)] {sym} base val mem)
4257         for {
4258                 off1 := auxIntToInt32(v.AuxInt)
4259                 sym := auxToSym(v.Aux)
4260                 if v_0.Op != OpRISCV64ADDI {
4261                         break
4262                 }
4263                 off2 := auxIntToInt64(v_0.AuxInt)
4264                 base := v_0.Args[0]
4265                 val := v_1
4266                 mem := v_2
4267                 if !(is32Bit(int64(off1) + off2)) {
4268                         break
4269                 }
4270                 v.reset(OpRISCV64MOVDstore)
4271                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4272                 v.Aux = symToAux(sym)
4273                 v.AddArg3(base, val, mem)
4274                 return true
4275         }
4276         // match: (MOVDstore [off] {sym} ptr (MOVDconst [0]) mem)
4277         // result: (MOVDstorezero [off] {sym} ptr mem)
4278         for {
4279                 off := auxIntToInt32(v.AuxInt)
4280                 sym := auxToSym(v.Aux)
4281                 ptr := v_0
4282                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4283                         break
4284                 }
4285                 mem := v_2
4286                 v.reset(OpRISCV64MOVDstorezero)
4287                 v.AuxInt = int32ToAuxInt(off)
4288                 v.Aux = symToAux(sym)
4289                 v.AddArg2(ptr, mem)
4290                 return true
4291         }
4292         return false
4293 }
4294 func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool {
4295         v_1 := v.Args[1]
4296         v_0 := v.Args[0]
4297         // match: (MOVDstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
4298         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
4299         // result: (MOVDstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
4300         for {
4301                 off1 := auxIntToInt32(v.AuxInt)
4302                 sym1 := auxToSym(v.Aux)
4303                 if v_0.Op != OpRISCV64MOVaddr {
4304                         break
4305                 }
4306                 off2 := auxIntToInt32(v_0.AuxInt)
4307                 sym2 := auxToSym(v_0.Aux)
4308                 ptr := v_0.Args[0]
4309                 mem := v_1
4310                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
4311                         break
4312                 }
4313                 v.reset(OpRISCV64MOVDstorezero)
4314                 v.AuxInt = int32ToAuxInt(off1 + off2)
4315                 v.Aux = symToAux(mergeSym(sym1, sym2))
4316                 v.AddArg2(ptr, mem)
4317                 return true
4318         }
4319         // match: (MOVDstorezero [off1] {sym} (ADDI [off2] ptr) mem)
4320         // cond: is32Bit(int64(off1)+off2)
4321         // result: (MOVDstorezero [off1+int32(off2)] {sym} ptr mem)
4322         for {
4323                 off1 := auxIntToInt32(v.AuxInt)
4324                 sym := auxToSym(v.Aux)
4325                 if v_0.Op != OpRISCV64ADDI {
4326                         break
4327                 }
4328                 off2 := auxIntToInt64(v_0.AuxInt)
4329                 ptr := v_0.Args[0]
4330                 mem := v_1
4331                 if !(is32Bit(int64(off1) + off2)) {
4332                         break
4333                 }
4334                 v.reset(OpRISCV64MOVDstorezero)
4335                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4336                 v.Aux = symToAux(sym)
4337                 v.AddArg2(ptr, mem)
4338                 return true
4339         }
4340         return false
4341 }
4342 func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
4343         v_1 := v.Args[1]
4344         v_0 := v.Args[0]
4345         // match: (MOVHUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
4346         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4347         // result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
4348         for {
4349                 off1 := auxIntToInt32(v.AuxInt)
4350                 sym1 := auxToSym(v.Aux)
4351                 if v_0.Op != OpRISCV64MOVaddr {
4352                         break
4353                 }
4354                 off2 := auxIntToInt32(v_0.AuxInt)
4355                 sym2 := auxToSym(v_0.Aux)
4356                 base := v_0.Args[0]
4357                 mem := v_1
4358                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4359                         break
4360                 }
4361                 v.reset(OpRISCV64MOVHUload)
4362                 v.AuxInt = int32ToAuxInt(off1 + off2)
4363                 v.Aux = symToAux(mergeSym(sym1, sym2))
4364                 v.AddArg2(base, mem)
4365                 return true
4366         }
4367         // match: (MOVHUload [off1] {sym} (ADDI [off2] base) mem)
4368         // cond: is32Bit(int64(off1)+off2)
4369         // result: (MOVHUload [off1+int32(off2)] {sym} base mem)
4370         for {
4371                 off1 := auxIntToInt32(v.AuxInt)
4372                 sym := auxToSym(v.Aux)
4373                 if v_0.Op != OpRISCV64ADDI {
4374                         break
4375                 }
4376                 off2 := auxIntToInt64(v_0.AuxInt)
4377                 base := v_0.Args[0]
4378                 mem := v_1
4379                 if !(is32Bit(int64(off1) + off2)) {
4380                         break
4381                 }
4382                 v.reset(OpRISCV64MOVHUload)
4383                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4384                 v.Aux = symToAux(sym)
4385                 v.AddArg2(base, mem)
4386                 return true
4387         }
4388         return false
4389 }
4390 func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
4391         v_0 := v.Args[0]
4392         b := v.Block
4393         // match: (MOVHUreg x:(ANDI [c] y))
4394         // cond: c >= 0 && int64(uint16(c)) == c
4395         // result: x
4396         for {
4397                 x := v_0
4398                 if x.Op != OpRISCV64ANDI {
4399                         break
4400                 }
4401                 c := auxIntToInt64(x.AuxInt)
4402                 if !(c >= 0 && int64(uint16(c)) == c) {
4403                         break
4404                 }
4405                 v.copyOf(x)
4406                 return true
4407         }
4408         // match: (MOVHUreg (ANDI [c] x))
4409         // cond: c < 0
4410         // result: (ANDI [int64(uint16(c))] x)
4411         for {
4412                 if v_0.Op != OpRISCV64ANDI {
4413                         break
4414                 }
4415                 c := auxIntToInt64(v_0.AuxInt)
4416                 x := v_0.Args[0]
4417                 if !(c < 0) {
4418                         break
4419                 }
4420                 v.reset(OpRISCV64ANDI)
4421                 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
4422                 v.AddArg(x)
4423                 return true
4424         }
4425         // match: (MOVHUreg (MOVDconst [c]))
4426         // result: (MOVDconst [int64(uint16(c))])
4427         for {
4428                 if v_0.Op != OpRISCV64MOVDconst {
4429                         break
4430                 }
4431                 c := auxIntToInt64(v_0.AuxInt)
4432                 v.reset(OpRISCV64MOVDconst)
4433                 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
4434                 return true
4435         }
4436         // match: (MOVHUreg x:(MOVBUload _ _))
4437         // result: (MOVDreg x)
4438         for {
4439                 x := v_0
4440                 if x.Op != OpRISCV64MOVBUload {
4441                         break
4442                 }
4443                 v.reset(OpRISCV64MOVDreg)
4444                 v.AddArg(x)
4445                 return true
4446         }
4447         // match: (MOVHUreg x:(MOVHUload _ _))
4448         // result: (MOVDreg x)
4449         for {
4450                 x := v_0
4451                 if x.Op != OpRISCV64MOVHUload {
4452                         break
4453                 }
4454                 v.reset(OpRISCV64MOVDreg)
4455                 v.AddArg(x)
4456                 return true
4457         }
4458         // match: (MOVHUreg x:(MOVBUreg _))
4459         // result: (MOVDreg x)
4460         for {
4461                 x := v_0
4462                 if x.Op != OpRISCV64MOVBUreg {
4463                         break
4464                 }
4465                 v.reset(OpRISCV64MOVDreg)
4466                 v.AddArg(x)
4467                 return true
4468         }
4469         // match: (MOVHUreg x:(MOVHUreg _))
4470         // result: (MOVDreg x)
4471         for {
4472                 x := v_0
4473                 if x.Op != OpRISCV64MOVHUreg {
4474                         break
4475                 }
4476                 v.reset(OpRISCV64MOVDreg)
4477                 v.AddArg(x)
4478                 return true
4479         }
4480         // match: (MOVHUreg <t> x:(MOVHload [off] {sym} ptr mem))
4481         // cond: x.Uses == 1 && clobber(x)
4482         // result: @x.Block (MOVHUload <t> [off] {sym} ptr mem)
4483         for {
4484                 t := v.Type
4485                 x := v_0
4486                 if x.Op != OpRISCV64MOVHload {
4487                         break
4488                 }
4489                 off := auxIntToInt32(x.AuxInt)
4490                 sym := auxToSym(x.Aux)
4491                 mem := x.Args[1]
4492                 ptr := x.Args[0]
4493                 if !(x.Uses == 1 && clobber(x)) {
4494                         break
4495                 }
4496                 b = x.Block
4497                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHUload, t)
4498                 v.copyOf(v0)
4499                 v0.AuxInt = int32ToAuxInt(off)
4500                 v0.Aux = symToAux(sym)
4501                 v0.AddArg2(ptr, mem)
4502                 return true
4503         }
4504         return false
4505 }
4506 func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
4507         v_1 := v.Args[1]
4508         v_0 := v.Args[0]
4509         // match: (MOVHload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
4510         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4511         // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} base mem)
4512         for {
4513                 off1 := auxIntToInt32(v.AuxInt)
4514                 sym1 := auxToSym(v.Aux)
4515                 if v_0.Op != OpRISCV64MOVaddr {
4516                         break
4517                 }
4518                 off2 := auxIntToInt32(v_0.AuxInt)
4519                 sym2 := auxToSym(v_0.Aux)
4520                 base := v_0.Args[0]
4521                 mem := v_1
4522                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4523                         break
4524                 }
4525                 v.reset(OpRISCV64MOVHload)
4526                 v.AuxInt = int32ToAuxInt(off1 + off2)
4527                 v.Aux = symToAux(mergeSym(sym1, sym2))
4528                 v.AddArg2(base, mem)
4529                 return true
4530         }
4531         // match: (MOVHload [off1] {sym} (ADDI [off2] base) mem)
4532         // cond: is32Bit(int64(off1)+off2)
4533         // result: (MOVHload [off1+int32(off2)] {sym} base mem)
4534         for {
4535                 off1 := auxIntToInt32(v.AuxInt)
4536                 sym := auxToSym(v.Aux)
4537                 if v_0.Op != OpRISCV64ADDI {
4538                         break
4539                 }
4540                 off2 := auxIntToInt64(v_0.AuxInt)
4541                 base := v_0.Args[0]
4542                 mem := v_1
4543                 if !(is32Bit(int64(off1) + off2)) {
4544                         break
4545                 }
4546                 v.reset(OpRISCV64MOVHload)
4547                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4548                 v.Aux = symToAux(sym)
4549                 v.AddArg2(base, mem)
4550                 return true
4551         }
4552         return false
4553 }
4554 func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
4555         v_0 := v.Args[0]
4556         b := v.Block
4557         // match: (MOVHreg x:(ANDI [c] y))
4558         // cond: c >= 0 && int64(int16(c)) == c
4559         // result: x
4560         for {
4561                 x := v_0
4562                 if x.Op != OpRISCV64ANDI {
4563                         break
4564                 }
4565                 c := auxIntToInt64(x.AuxInt)
4566                 if !(c >= 0 && int64(int16(c)) == c) {
4567                         break
4568                 }
4569                 v.copyOf(x)
4570                 return true
4571         }
4572         // match: (MOVHreg (MOVDconst [c]))
4573         // result: (MOVDconst [int64(int16(c))])
4574         for {
4575                 if v_0.Op != OpRISCV64MOVDconst {
4576                         break
4577                 }
4578                 c := auxIntToInt64(v_0.AuxInt)
4579                 v.reset(OpRISCV64MOVDconst)
4580                 v.AuxInt = int64ToAuxInt(int64(int16(c)))
4581                 return true
4582         }
4583         // match: (MOVHreg x:(MOVBload _ _))
4584         // result: (MOVDreg x)
4585         for {
4586                 x := v_0
4587                 if x.Op != OpRISCV64MOVBload {
4588                         break
4589                 }
4590                 v.reset(OpRISCV64MOVDreg)
4591                 v.AddArg(x)
4592                 return true
4593         }
4594         // match: (MOVHreg x:(MOVBUload _ _))
4595         // result: (MOVDreg x)
4596         for {
4597                 x := v_0
4598                 if x.Op != OpRISCV64MOVBUload {
4599                         break
4600                 }
4601                 v.reset(OpRISCV64MOVDreg)
4602                 v.AddArg(x)
4603                 return true
4604         }
4605         // match: (MOVHreg x:(MOVHload _ _))
4606         // result: (MOVDreg x)
4607         for {
4608                 x := v_0
4609                 if x.Op != OpRISCV64MOVHload {
4610                         break
4611                 }
4612                 v.reset(OpRISCV64MOVDreg)
4613                 v.AddArg(x)
4614                 return true
4615         }
4616         // match: (MOVHreg x:(MOVBreg _))
4617         // result: (MOVDreg x)
4618         for {
4619                 x := v_0
4620                 if x.Op != OpRISCV64MOVBreg {
4621                         break
4622                 }
4623                 v.reset(OpRISCV64MOVDreg)
4624                 v.AddArg(x)
4625                 return true
4626         }
4627         // match: (MOVHreg x:(MOVBUreg _))
4628         // result: (MOVDreg x)
4629         for {
4630                 x := v_0
4631                 if x.Op != OpRISCV64MOVBUreg {
4632                         break
4633                 }
4634                 v.reset(OpRISCV64MOVDreg)
4635                 v.AddArg(x)
4636                 return true
4637         }
4638         // match: (MOVHreg x:(MOVHreg _))
4639         // result: (MOVDreg x)
4640         for {
4641                 x := v_0
4642                 if x.Op != OpRISCV64MOVHreg {
4643                         break
4644                 }
4645                 v.reset(OpRISCV64MOVDreg)
4646                 v.AddArg(x)
4647                 return true
4648         }
4649         // match: (MOVHreg <t> x:(MOVHUload [off] {sym} ptr mem))
4650         // cond: x.Uses == 1 && clobber(x)
4651         // result: @x.Block (MOVHload <t> [off] {sym} ptr mem)
4652         for {
4653                 t := v.Type
4654                 x := v_0
4655                 if x.Op != OpRISCV64MOVHUload {
4656                         break
4657                 }
4658                 off := auxIntToInt32(x.AuxInt)
4659                 sym := auxToSym(x.Aux)
4660                 mem := x.Args[1]
4661                 ptr := x.Args[0]
4662                 if !(x.Uses == 1 && clobber(x)) {
4663                         break
4664                 }
4665                 b = x.Block
4666                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHload, t)
4667                 v.copyOf(v0)
4668                 v0.AuxInt = int32ToAuxInt(off)
4669                 v0.Aux = symToAux(sym)
4670                 v0.AddArg2(ptr, mem)
4671                 return true
4672         }
4673         return false
4674 }
4675 func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
4676         v_2 := v.Args[2]
4677         v_1 := v.Args[1]
4678         v_0 := v.Args[0]
4679         // match: (MOVHstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
4680         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4681         // result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
4682         for {
4683                 off1 := auxIntToInt32(v.AuxInt)
4684                 sym1 := auxToSym(v.Aux)
4685                 if v_0.Op != OpRISCV64MOVaddr {
4686                         break
4687                 }
4688                 off2 := auxIntToInt32(v_0.AuxInt)
4689                 sym2 := auxToSym(v_0.Aux)
4690                 base := v_0.Args[0]
4691                 val := v_1
4692                 mem := v_2
4693                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4694                         break
4695                 }
4696                 v.reset(OpRISCV64MOVHstore)
4697                 v.AuxInt = int32ToAuxInt(off1 + off2)
4698                 v.Aux = symToAux(mergeSym(sym1, sym2))
4699                 v.AddArg3(base, val, mem)
4700                 return true
4701         }
4702         // match: (MOVHstore [off1] {sym} (ADDI [off2] base) val mem)
4703         // cond: is32Bit(int64(off1)+off2)
4704         // result: (MOVHstore [off1+int32(off2)] {sym} base val mem)
4705         for {
4706                 off1 := auxIntToInt32(v.AuxInt)
4707                 sym := auxToSym(v.Aux)
4708                 if v_0.Op != OpRISCV64ADDI {
4709                         break
4710                 }
4711                 off2 := auxIntToInt64(v_0.AuxInt)
4712                 base := v_0.Args[0]
4713                 val := v_1
4714                 mem := v_2
4715                 if !(is32Bit(int64(off1) + off2)) {
4716                         break
4717                 }
4718                 v.reset(OpRISCV64MOVHstore)
4719                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4720                 v.Aux = symToAux(sym)
4721                 v.AddArg3(base, val, mem)
4722                 return true
4723         }
4724         // match: (MOVHstore [off] {sym} ptr (MOVDconst [0]) mem)
4725         // result: (MOVHstorezero [off] {sym} ptr mem)
4726         for {
4727                 off := auxIntToInt32(v.AuxInt)
4728                 sym := auxToSym(v.Aux)
4729                 ptr := v_0
4730                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4731                         break
4732                 }
4733                 mem := v_2
4734                 v.reset(OpRISCV64MOVHstorezero)
4735                 v.AuxInt = int32ToAuxInt(off)
4736                 v.Aux = symToAux(sym)
4737                 v.AddArg2(ptr, mem)
4738                 return true
4739         }
4740         // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
4741         // result: (MOVHstore [off] {sym} ptr x mem)
4742         for {
4743                 off := auxIntToInt32(v.AuxInt)
4744                 sym := auxToSym(v.Aux)
4745                 ptr := v_0
4746                 if v_1.Op != OpRISCV64MOVHreg {
4747                         break
4748                 }
4749                 x := v_1.Args[0]
4750                 mem := v_2
4751                 v.reset(OpRISCV64MOVHstore)
4752                 v.AuxInt = int32ToAuxInt(off)
4753                 v.Aux = symToAux(sym)
4754                 v.AddArg3(ptr, x, mem)
4755                 return true
4756         }
4757         // match: (MOVHstore [off] {sym} ptr (MOVWreg x) mem)
4758         // result: (MOVHstore [off] {sym} ptr x mem)
4759         for {
4760                 off := auxIntToInt32(v.AuxInt)
4761                 sym := auxToSym(v.Aux)
4762                 ptr := v_0
4763                 if v_1.Op != OpRISCV64MOVWreg {
4764                         break
4765                 }
4766                 x := v_1.Args[0]
4767                 mem := v_2
4768                 v.reset(OpRISCV64MOVHstore)
4769                 v.AuxInt = int32ToAuxInt(off)
4770                 v.Aux = symToAux(sym)
4771                 v.AddArg3(ptr, x, mem)
4772                 return true
4773         }
4774         // match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem)
4775         // result: (MOVHstore [off] {sym} ptr x mem)
4776         for {
4777                 off := auxIntToInt32(v.AuxInt)
4778                 sym := auxToSym(v.Aux)
4779                 ptr := v_0
4780                 if v_1.Op != OpRISCV64MOVHUreg {
4781                         break
4782                 }
4783                 x := v_1.Args[0]
4784                 mem := v_2
4785                 v.reset(OpRISCV64MOVHstore)
4786                 v.AuxInt = int32ToAuxInt(off)
4787                 v.Aux = symToAux(sym)
4788                 v.AddArg3(ptr, x, mem)
4789                 return true
4790         }
4791         // match: (MOVHstore [off] {sym} ptr (MOVWUreg x) mem)
4792         // result: (MOVHstore [off] {sym} ptr x mem)
4793         for {
4794                 off := auxIntToInt32(v.AuxInt)
4795                 sym := auxToSym(v.Aux)
4796                 ptr := v_0
4797                 if v_1.Op != OpRISCV64MOVWUreg {
4798                         break
4799                 }
4800                 x := v_1.Args[0]
4801                 mem := v_2
4802                 v.reset(OpRISCV64MOVHstore)
4803                 v.AuxInt = int32ToAuxInt(off)
4804                 v.Aux = symToAux(sym)
4805                 v.AddArg3(ptr, x, mem)
4806                 return true
4807         }
4808         return false
4809 }
4810 func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool {
4811         v_1 := v.Args[1]
4812         v_0 := v.Args[0]
4813         // match: (MOVHstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
4814         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
4815         // result: (MOVHstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
4816         for {
4817                 off1 := auxIntToInt32(v.AuxInt)
4818                 sym1 := auxToSym(v.Aux)
4819                 if v_0.Op != OpRISCV64MOVaddr {
4820                         break
4821                 }
4822                 off2 := auxIntToInt32(v_0.AuxInt)
4823                 sym2 := auxToSym(v_0.Aux)
4824                 ptr := v_0.Args[0]
4825                 mem := v_1
4826                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
4827                         break
4828                 }
4829                 v.reset(OpRISCV64MOVHstorezero)
4830                 v.AuxInt = int32ToAuxInt(off1 + off2)
4831                 v.Aux = symToAux(mergeSym(sym1, sym2))
4832                 v.AddArg2(ptr, mem)
4833                 return true
4834         }
4835         // match: (MOVHstorezero [off1] {sym} (ADDI [off2] ptr) mem)
4836         // cond: is32Bit(int64(off1)+off2)
4837         // result: (MOVHstorezero [off1+int32(off2)] {sym} ptr mem)
4838         for {
4839                 off1 := auxIntToInt32(v.AuxInt)
4840                 sym := auxToSym(v.Aux)
4841                 if v_0.Op != OpRISCV64ADDI {
4842                         break
4843                 }
4844                 off2 := auxIntToInt64(v_0.AuxInt)
4845                 ptr := v_0.Args[0]
4846                 mem := v_1
4847                 if !(is32Bit(int64(off1) + off2)) {
4848                         break
4849                 }
4850                 v.reset(OpRISCV64MOVHstorezero)
4851                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4852                 v.Aux = symToAux(sym)
4853                 v.AddArg2(ptr, mem)
4854                 return true
4855         }
4856         return false
4857 }
4858 func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
4859         v_1 := v.Args[1]
4860         v_0 := v.Args[0]
4861         // match: (MOVWUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
4862         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4863         // result: (MOVWUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
4864         for {
4865                 off1 := auxIntToInt32(v.AuxInt)
4866                 sym1 := auxToSym(v.Aux)
4867                 if v_0.Op != OpRISCV64MOVaddr {
4868                         break
4869                 }
4870                 off2 := auxIntToInt32(v_0.AuxInt)
4871                 sym2 := auxToSym(v_0.Aux)
4872                 base := v_0.Args[0]
4873                 mem := v_1
4874                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4875                         break
4876                 }
4877                 v.reset(OpRISCV64MOVWUload)
4878                 v.AuxInt = int32ToAuxInt(off1 + off2)
4879                 v.Aux = symToAux(mergeSym(sym1, sym2))
4880                 v.AddArg2(base, mem)
4881                 return true
4882         }
4883         // match: (MOVWUload [off1] {sym} (ADDI [off2] base) mem)
4884         // cond: is32Bit(int64(off1)+off2)
4885         // result: (MOVWUload [off1+int32(off2)] {sym} base mem)
4886         for {
4887                 off1 := auxIntToInt32(v.AuxInt)
4888                 sym := auxToSym(v.Aux)
4889                 if v_0.Op != OpRISCV64ADDI {
4890                         break
4891                 }
4892                 off2 := auxIntToInt64(v_0.AuxInt)
4893                 base := v_0.Args[0]
4894                 mem := v_1
4895                 if !(is32Bit(int64(off1) + off2)) {
4896                         break
4897                 }
4898                 v.reset(OpRISCV64MOVWUload)
4899                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4900                 v.Aux = symToAux(sym)
4901                 v.AddArg2(base, mem)
4902                 return true
4903         }
4904         return false
4905 }
4906 func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
4907         v_0 := v.Args[0]
4908         b := v.Block
4909         typ := &b.Func.Config.Types
4910         // match: (MOVWUreg x:(ANDI [c] y))
4911         // cond: c >= 0 && int64(uint32(c)) == c
4912         // result: x
4913         for {
4914                 x := v_0
4915                 if x.Op != OpRISCV64ANDI {
4916                         break
4917                 }
4918                 c := auxIntToInt64(x.AuxInt)
4919                 if !(c >= 0 && int64(uint32(c)) == c) {
4920                         break
4921                 }
4922                 v.copyOf(x)
4923                 return true
4924         }
4925         // match: (MOVWUreg (ANDI [c] x))
4926         // cond: c < 0
4927         // result: (AND (MOVDconst [int64(uint32(c))]) x)
4928         for {
4929                 if v_0.Op != OpRISCV64ANDI {
4930                         break
4931                 }
4932                 c := auxIntToInt64(v_0.AuxInt)
4933                 x := v_0.Args[0]
4934                 if !(c < 0) {
4935                         break
4936                 }
4937                 v.reset(OpRISCV64AND)
4938                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4939                 v0.AuxInt = int64ToAuxInt(int64(uint32(c)))
4940                 v.AddArg2(v0, x)
4941                 return true
4942         }
4943         // match: (MOVWUreg (MOVDconst [c]))
4944         // result: (MOVDconst [int64(uint32(c))])
4945         for {
4946                 if v_0.Op != OpRISCV64MOVDconst {
4947                         break
4948                 }
4949                 c := auxIntToInt64(v_0.AuxInt)
4950                 v.reset(OpRISCV64MOVDconst)
4951                 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
4952                 return true
4953         }
4954         // match: (MOVWUreg x:(MOVBUload _ _))
4955         // result: (MOVDreg x)
4956         for {
4957                 x := v_0
4958                 if x.Op != OpRISCV64MOVBUload {
4959                         break
4960                 }
4961                 v.reset(OpRISCV64MOVDreg)
4962                 v.AddArg(x)
4963                 return true
4964         }
4965         // match: (MOVWUreg x:(MOVHUload _ _))
4966         // result: (MOVDreg x)
4967         for {
4968                 x := v_0
4969                 if x.Op != OpRISCV64MOVHUload {
4970                         break
4971                 }
4972                 v.reset(OpRISCV64MOVDreg)
4973                 v.AddArg(x)
4974                 return true
4975         }
4976         // match: (MOVWUreg x:(MOVWUload _ _))
4977         // result: (MOVDreg x)
4978         for {
4979                 x := v_0
4980                 if x.Op != OpRISCV64MOVWUload {
4981                         break
4982                 }
4983                 v.reset(OpRISCV64MOVDreg)
4984                 v.AddArg(x)
4985                 return true
4986         }
4987         // match: (MOVWUreg x:(MOVBUreg _))
4988         // result: (MOVDreg x)
4989         for {
4990                 x := v_0
4991                 if x.Op != OpRISCV64MOVBUreg {
4992                         break
4993                 }
4994                 v.reset(OpRISCV64MOVDreg)
4995                 v.AddArg(x)
4996                 return true
4997         }
4998         // match: (MOVWUreg x:(MOVHUreg _))
4999         // result: (MOVDreg x)
5000         for {
5001                 x := v_0
5002                 if x.Op != OpRISCV64MOVHUreg {
5003                         break
5004                 }
5005                 v.reset(OpRISCV64MOVDreg)
5006                 v.AddArg(x)
5007                 return true
5008         }
5009         // match: (MOVWUreg x:(MOVWUreg _))
5010         // result: (MOVDreg x)
5011         for {
5012                 x := v_0
5013                 if x.Op != OpRISCV64MOVWUreg {
5014                         break
5015                 }
5016                 v.reset(OpRISCV64MOVDreg)
5017                 v.AddArg(x)
5018                 return true
5019         }
5020         // match: (MOVWUreg <t> x:(MOVWload [off] {sym} ptr mem))
5021         // cond: x.Uses == 1 && clobber(x)
5022         // result: @x.Block (MOVWUload <t> [off] {sym} ptr mem)
5023         for {
5024                 t := v.Type
5025                 x := v_0
5026                 if x.Op != OpRISCV64MOVWload {
5027                         break
5028                 }
5029                 off := auxIntToInt32(x.AuxInt)
5030                 sym := auxToSym(x.Aux)
5031                 mem := x.Args[1]
5032                 ptr := x.Args[0]
5033                 if !(x.Uses == 1 && clobber(x)) {
5034                         break
5035                 }
5036                 b = x.Block
5037                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWUload, t)
5038                 v.copyOf(v0)
5039                 v0.AuxInt = int32ToAuxInt(off)
5040                 v0.Aux = symToAux(sym)
5041                 v0.AddArg2(ptr, mem)
5042                 return true
5043         }
5044         return false
5045 }
5046 func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
5047         v_1 := v.Args[1]
5048         v_0 := v.Args[0]
5049         // match: (MOVWload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
5050         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
5051         // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem)
5052         for {
5053                 off1 := auxIntToInt32(v.AuxInt)
5054                 sym1 := auxToSym(v.Aux)
5055                 if v_0.Op != OpRISCV64MOVaddr {
5056                         break
5057                 }
5058                 off2 := auxIntToInt32(v_0.AuxInt)
5059                 sym2 := auxToSym(v_0.Aux)
5060                 base := v_0.Args[0]
5061                 mem := v_1
5062                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
5063                         break
5064                 }
5065                 v.reset(OpRISCV64MOVWload)
5066                 v.AuxInt = int32ToAuxInt(off1 + off2)
5067                 v.Aux = symToAux(mergeSym(sym1, sym2))
5068                 v.AddArg2(base, mem)
5069                 return true
5070         }
5071         // match: (MOVWload [off1] {sym} (ADDI [off2] base) mem)
5072         // cond: is32Bit(int64(off1)+off2)
5073         // result: (MOVWload [off1+int32(off2)] {sym} base mem)
5074         for {
5075                 off1 := auxIntToInt32(v.AuxInt)
5076                 sym := auxToSym(v.Aux)
5077                 if v_0.Op != OpRISCV64ADDI {
5078                         break
5079                 }
5080                 off2 := auxIntToInt64(v_0.AuxInt)
5081                 base := v_0.Args[0]
5082                 mem := v_1
5083                 if !(is32Bit(int64(off1) + off2)) {
5084                         break
5085                 }
5086                 v.reset(OpRISCV64MOVWload)
5087                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5088                 v.Aux = symToAux(sym)
5089                 v.AddArg2(base, mem)
5090                 return true
5091         }
5092         return false
5093 }
5094 func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
5095         v_0 := v.Args[0]
5096         b := v.Block
5097         // match: (MOVWreg x:(ANDI [c] y))
5098         // cond: c >= 0 && int64(int32(c)) == c
5099         // result: x
5100         for {
5101                 x := v_0
5102                 if x.Op != OpRISCV64ANDI {
5103                         break
5104                 }
5105                 c := auxIntToInt64(x.AuxInt)
5106                 if !(c >= 0 && int64(int32(c)) == c) {
5107                         break
5108                 }
5109                 v.copyOf(x)
5110                 return true
5111         }
5112         // match: (MOVWreg (MOVDconst [c]))
5113         // result: (MOVDconst [int64(int32(c))])
5114         for {
5115                 if v_0.Op != OpRISCV64MOVDconst {
5116                         break
5117                 }
5118                 c := auxIntToInt64(v_0.AuxInt)
5119                 v.reset(OpRISCV64MOVDconst)
5120                 v.AuxInt = int64ToAuxInt(int64(int32(c)))
5121                 return true
5122         }
5123         // match: (MOVWreg x:(MOVBload _ _))
5124         // result: (MOVDreg x)
5125         for {
5126                 x := v_0
5127                 if x.Op != OpRISCV64MOVBload {
5128                         break
5129                 }
5130                 v.reset(OpRISCV64MOVDreg)
5131                 v.AddArg(x)
5132                 return true
5133         }
5134         // match: (MOVWreg x:(MOVBUload _ _))
5135         // result: (MOVDreg x)
5136         for {
5137                 x := v_0
5138                 if x.Op != OpRISCV64MOVBUload {
5139                         break
5140                 }
5141                 v.reset(OpRISCV64MOVDreg)
5142                 v.AddArg(x)
5143                 return true
5144         }
5145         // match: (MOVWreg x:(MOVHload _ _))
5146         // result: (MOVDreg x)
5147         for {
5148                 x := v_0
5149                 if x.Op != OpRISCV64MOVHload {
5150                         break
5151                 }
5152                 v.reset(OpRISCV64MOVDreg)
5153                 v.AddArg(x)
5154                 return true
5155         }
5156         // match: (MOVWreg x:(MOVHUload _ _))
5157         // result: (MOVDreg x)
5158         for {
5159                 x := v_0
5160                 if x.Op != OpRISCV64MOVHUload {
5161                         break
5162                 }
5163                 v.reset(OpRISCV64MOVDreg)
5164                 v.AddArg(x)
5165                 return true
5166         }
5167         // match: (MOVWreg x:(MOVWload _ _))
5168         // result: (MOVDreg x)
5169         for {
5170                 x := v_0
5171                 if x.Op != OpRISCV64MOVWload {
5172                         break
5173                 }
5174                 v.reset(OpRISCV64MOVDreg)
5175                 v.AddArg(x)
5176                 return true
5177         }
5178         // match: (MOVWreg x:(ADDIW _))
5179         // result: (MOVDreg x)
5180         for {
5181                 x := v_0
5182                 if x.Op != OpRISCV64ADDIW {
5183                         break
5184                 }
5185                 v.reset(OpRISCV64MOVDreg)
5186                 v.AddArg(x)
5187                 return true
5188         }
5189         // match: (MOVWreg x:(SUBW _ _))
5190         // result: (MOVDreg x)
5191         for {
5192                 x := v_0
5193                 if x.Op != OpRISCV64SUBW {
5194                         break
5195                 }
5196                 v.reset(OpRISCV64MOVDreg)
5197                 v.AddArg(x)
5198                 return true
5199         }
5200         // match: (MOVWreg x:(NEGW _))
5201         // result: (MOVDreg x)
5202         for {
5203                 x := v_0
5204                 if x.Op != OpRISCV64NEGW {
5205                         break
5206                 }
5207                 v.reset(OpRISCV64MOVDreg)
5208                 v.AddArg(x)
5209                 return true
5210         }
5211         // match: (MOVWreg x:(MULW _ _))
5212         // result: (MOVDreg x)
5213         for {
5214                 x := v_0
5215                 if x.Op != OpRISCV64MULW {
5216                         break
5217                 }
5218                 v.reset(OpRISCV64MOVDreg)
5219                 v.AddArg(x)
5220                 return true
5221         }
5222         // match: (MOVWreg x:(DIVW _ _))
5223         // result: (MOVDreg x)
5224         for {
5225                 x := v_0
5226                 if x.Op != OpRISCV64DIVW {
5227                         break
5228                 }
5229                 v.reset(OpRISCV64MOVDreg)
5230                 v.AddArg(x)
5231                 return true
5232         }
5233         // match: (MOVWreg x:(DIVUW _ _))
5234         // result: (MOVDreg x)
5235         for {
5236                 x := v_0
5237                 if x.Op != OpRISCV64DIVUW {
5238                         break
5239                 }
5240                 v.reset(OpRISCV64MOVDreg)
5241                 v.AddArg(x)
5242                 return true
5243         }
5244         // match: (MOVWreg x:(REMW _ _))
5245         // result: (MOVDreg x)
5246         for {
5247                 x := v_0
5248                 if x.Op != OpRISCV64REMW {
5249                         break
5250                 }
5251                 v.reset(OpRISCV64MOVDreg)
5252                 v.AddArg(x)
5253                 return true
5254         }
5255         // match: (MOVWreg x:(REMUW _ _))
5256         // result: (MOVDreg x)
5257         for {
5258                 x := v_0
5259                 if x.Op != OpRISCV64REMUW {
5260                         break
5261                 }
5262                 v.reset(OpRISCV64MOVDreg)
5263                 v.AddArg(x)
5264                 return true
5265         }
5266         // match: (MOVWreg x:(MOVBreg _))
5267         // result: (MOVDreg x)
5268         for {
5269                 x := v_0
5270                 if x.Op != OpRISCV64MOVBreg {
5271                         break
5272                 }
5273                 v.reset(OpRISCV64MOVDreg)
5274                 v.AddArg(x)
5275                 return true
5276         }
5277         // match: (MOVWreg x:(MOVBUreg _))
5278         // result: (MOVDreg x)
5279         for {
5280                 x := v_0
5281                 if x.Op != OpRISCV64MOVBUreg {
5282                         break
5283                 }
5284                 v.reset(OpRISCV64MOVDreg)
5285                 v.AddArg(x)
5286                 return true
5287         }
5288         // match: (MOVWreg x:(MOVHreg _))
5289         // result: (MOVDreg x)
5290         for {
5291                 x := v_0
5292                 if x.Op != OpRISCV64MOVHreg {
5293                         break
5294                 }
5295                 v.reset(OpRISCV64MOVDreg)
5296                 v.AddArg(x)
5297                 return true
5298         }
5299         // match: (MOVWreg x:(MOVWreg _))
5300         // result: (MOVDreg x)
5301         for {
5302                 x := v_0
5303                 if x.Op != OpRISCV64MOVWreg {
5304                         break
5305                 }
5306                 v.reset(OpRISCV64MOVDreg)
5307                 v.AddArg(x)
5308                 return true
5309         }
5310         // match: (MOVWreg <t> x:(MOVWUload [off] {sym} ptr mem))
5311         // cond: x.Uses == 1 && clobber(x)
5312         // result: @x.Block (MOVWload <t> [off] {sym} ptr mem)
5313         for {
5314                 t := v.Type
5315                 x := v_0
5316                 if x.Op != OpRISCV64MOVWUload {
5317                         break
5318                 }
5319                 off := auxIntToInt32(x.AuxInt)
5320                 sym := auxToSym(x.Aux)
5321                 mem := x.Args[1]
5322                 ptr := x.Args[0]
5323                 if !(x.Uses == 1 && clobber(x)) {
5324                         break
5325                 }
5326                 b = x.Block
5327                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWload, t)
5328                 v.copyOf(v0)
5329                 v0.AuxInt = int32ToAuxInt(off)
5330                 v0.Aux = symToAux(sym)
5331                 v0.AddArg2(ptr, mem)
5332                 return true
5333         }
5334         return false
5335 }
5336 func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
5337         v_2 := v.Args[2]
5338         v_1 := v.Args[1]
5339         v_0 := v.Args[0]
5340         // match: (MOVWstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
5341         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
5342         // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
5343         for {
5344                 off1 := auxIntToInt32(v.AuxInt)
5345                 sym1 := auxToSym(v.Aux)
5346                 if v_0.Op != OpRISCV64MOVaddr {
5347                         break
5348                 }
5349                 off2 := auxIntToInt32(v_0.AuxInt)
5350                 sym2 := auxToSym(v_0.Aux)
5351                 base := v_0.Args[0]
5352                 val := v_1
5353                 mem := v_2
5354                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
5355                         break
5356                 }
5357                 v.reset(OpRISCV64MOVWstore)
5358                 v.AuxInt = int32ToAuxInt(off1 + off2)
5359                 v.Aux = symToAux(mergeSym(sym1, sym2))
5360                 v.AddArg3(base, val, mem)
5361                 return true
5362         }
5363         // match: (MOVWstore [off1] {sym} (ADDI [off2] base) val mem)
5364         // cond: is32Bit(int64(off1)+off2)
5365         // result: (MOVWstore [off1+int32(off2)] {sym} base val mem)
5366         for {
5367                 off1 := auxIntToInt32(v.AuxInt)
5368                 sym := auxToSym(v.Aux)
5369                 if v_0.Op != OpRISCV64ADDI {
5370                         break
5371                 }
5372                 off2 := auxIntToInt64(v_0.AuxInt)
5373                 base := v_0.Args[0]
5374                 val := v_1
5375                 mem := v_2
5376                 if !(is32Bit(int64(off1) + off2)) {
5377                         break
5378                 }
5379                 v.reset(OpRISCV64MOVWstore)
5380                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5381                 v.Aux = symToAux(sym)
5382                 v.AddArg3(base, val, mem)
5383                 return true
5384         }
5385         // match: (MOVWstore [off] {sym} ptr (MOVDconst [0]) mem)
5386         // result: (MOVWstorezero [off] {sym} ptr mem)
5387         for {
5388                 off := auxIntToInt32(v.AuxInt)
5389                 sym := auxToSym(v.Aux)
5390                 ptr := v_0
5391                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
5392                         break
5393                 }
5394                 mem := v_2
5395                 v.reset(OpRISCV64MOVWstorezero)
5396                 v.AuxInt = int32ToAuxInt(off)
5397                 v.Aux = symToAux(sym)
5398                 v.AddArg2(ptr, mem)
5399                 return true
5400         }
5401         // match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
5402         // result: (MOVWstore [off] {sym} ptr x mem)
5403         for {
5404                 off := auxIntToInt32(v.AuxInt)
5405                 sym := auxToSym(v.Aux)
5406                 ptr := v_0
5407                 if v_1.Op != OpRISCV64MOVWreg {
5408                         break
5409                 }
5410                 x := v_1.Args[0]
5411                 mem := v_2
5412                 v.reset(OpRISCV64MOVWstore)
5413                 v.AuxInt = int32ToAuxInt(off)
5414                 v.Aux = symToAux(sym)
5415                 v.AddArg3(ptr, x, mem)
5416                 return true
5417         }
5418         // match: (MOVWstore [off] {sym} ptr (MOVWUreg x) mem)
5419         // result: (MOVWstore [off] {sym} ptr x mem)
5420         for {
5421                 off := auxIntToInt32(v.AuxInt)
5422                 sym := auxToSym(v.Aux)
5423                 ptr := v_0
5424                 if v_1.Op != OpRISCV64MOVWUreg {
5425                         break
5426                 }
5427                 x := v_1.Args[0]
5428                 mem := v_2
5429                 v.reset(OpRISCV64MOVWstore)
5430                 v.AuxInt = int32ToAuxInt(off)
5431                 v.Aux = symToAux(sym)
5432                 v.AddArg3(ptr, x, mem)
5433                 return true
5434         }
5435         return false
5436 }
5437 func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
5438         v_1 := v.Args[1]
5439         v_0 := v.Args[0]
5440         // match: (MOVWstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
5441         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
5442         // result: (MOVWstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
5443         for {
5444                 off1 := auxIntToInt32(v.AuxInt)
5445                 sym1 := auxToSym(v.Aux)
5446                 if v_0.Op != OpRISCV64MOVaddr {
5447                         break
5448                 }
5449                 off2 := auxIntToInt32(v_0.AuxInt)
5450                 sym2 := auxToSym(v_0.Aux)
5451                 ptr := v_0.Args[0]
5452                 mem := v_1
5453                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
5454                         break
5455                 }
5456                 v.reset(OpRISCV64MOVWstorezero)
5457                 v.AuxInt = int32ToAuxInt(off1 + off2)
5458                 v.Aux = symToAux(mergeSym(sym1, sym2))
5459                 v.AddArg2(ptr, mem)
5460                 return true
5461         }
5462         // match: (MOVWstorezero [off1] {sym} (ADDI [off2] ptr) mem)
5463         // cond: is32Bit(int64(off1)+off2)
5464         // result: (MOVWstorezero [off1+int32(off2)] {sym} ptr mem)
5465         for {
5466                 off1 := auxIntToInt32(v.AuxInt)
5467                 sym := auxToSym(v.Aux)
5468                 if v_0.Op != OpRISCV64ADDI {
5469                         break
5470                 }
5471                 off2 := auxIntToInt64(v_0.AuxInt)
5472                 ptr := v_0.Args[0]
5473                 mem := v_1
5474                 if !(is32Bit(int64(off1) + off2)) {
5475                         break
5476                 }
5477                 v.reset(OpRISCV64MOVWstorezero)
5478                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
5479                 v.Aux = symToAux(sym)
5480                 v.AddArg2(ptr, mem)
5481                 return true
5482         }
5483         return false
5484 }
5485 func rewriteValueRISCV64_OpRISCV64NEG(v *Value) bool {
5486         v_0 := v.Args[0]
5487         b := v.Block
5488         // match: (NEG (SUB x y))
5489         // result: (SUB y x)
5490         for {
5491                 if v_0.Op != OpRISCV64SUB {
5492                         break
5493                 }
5494                 y := v_0.Args[1]
5495                 x := v_0.Args[0]
5496                 v.reset(OpRISCV64SUB)
5497                 v.AddArg2(y, x)
5498                 return true
5499         }
5500         // match: (NEG <t> s:(ADDI [val] (SUB x y)))
5501         // cond: s.Uses == 1 && is32Bit(-val)
5502         // result: (ADDI [-val] (SUB <t> y x))
5503         for {
5504                 t := v.Type
5505                 s := v_0
5506                 if s.Op != OpRISCV64ADDI {
5507                         break
5508                 }
5509                 val := auxIntToInt64(s.AuxInt)
5510                 s_0 := s.Args[0]
5511                 if s_0.Op != OpRISCV64SUB {
5512                         break
5513                 }
5514                 y := s_0.Args[1]
5515                 x := s_0.Args[0]
5516                 if !(s.Uses == 1 && is32Bit(-val)) {
5517                         break
5518                 }
5519                 v.reset(OpRISCV64ADDI)
5520                 v.AuxInt = int64ToAuxInt(-val)
5521                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, t)
5522                 v0.AddArg2(y, x)
5523                 v.AddArg(v0)
5524                 return true
5525         }
5526         // match: (NEG (NEG x))
5527         // result: x
5528         for {
5529                 if v_0.Op != OpRISCV64NEG {
5530                         break
5531                 }
5532                 x := v_0.Args[0]
5533                 v.copyOf(x)
5534                 return true
5535         }
5536         // match: (NEG (MOVDconst [x]))
5537         // result: (MOVDconst [-x])
5538         for {
5539                 if v_0.Op != OpRISCV64MOVDconst {
5540                         break
5541                 }
5542                 x := auxIntToInt64(v_0.AuxInt)
5543                 v.reset(OpRISCV64MOVDconst)
5544                 v.AuxInt = int64ToAuxInt(-x)
5545                 return true
5546         }
5547         return false
5548 }
5549 func rewriteValueRISCV64_OpRISCV64NEGW(v *Value) bool {
5550         v_0 := v.Args[0]
5551         // match: (NEGW (MOVDconst [x]))
5552         // result: (MOVDconst [int64(int32(-x))])
5553         for {
5554                 if v_0.Op != OpRISCV64MOVDconst {
5555                         break
5556                 }
5557                 x := auxIntToInt64(v_0.AuxInt)
5558                 v.reset(OpRISCV64MOVDconst)
5559                 v.AuxInt = int64ToAuxInt(int64(int32(-x)))
5560                 return true
5561         }
5562         return false
5563 }
5564 func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
5565         v_1 := v.Args[1]
5566         v_0 := v.Args[0]
5567         // match: (OR (MOVDconst [val]) x)
5568         // cond: is32Bit(val)
5569         // result: (ORI [val] x)
5570         for {
5571                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
5572                         if v_0.Op != OpRISCV64MOVDconst {
5573                                 continue
5574                         }
5575                         val := auxIntToInt64(v_0.AuxInt)
5576                         x := v_1
5577                         if !(is32Bit(val)) {
5578                                 continue
5579                         }
5580                         v.reset(OpRISCV64ORI)
5581                         v.AuxInt = int64ToAuxInt(val)
5582                         v.AddArg(x)
5583                         return true
5584                 }
5585                 break
5586         }
5587         return false
5588 }
5589 func rewriteValueRISCV64_OpRISCV64ORI(v *Value) bool {
5590         v_0 := v.Args[0]
5591         // match: (ORI [0] x)
5592         // result: x
5593         for {
5594                 if auxIntToInt64(v.AuxInt) != 0 {
5595                         break
5596                 }
5597                 x := v_0
5598                 v.copyOf(x)
5599                 return true
5600         }
5601         // match: (ORI [-1] x)
5602         // result: (MOVDconst [-1])
5603         for {
5604                 if auxIntToInt64(v.AuxInt) != -1 {
5605                         break
5606                 }
5607                 v.reset(OpRISCV64MOVDconst)
5608                 v.AuxInt = int64ToAuxInt(-1)
5609                 return true
5610         }
5611         // match: (ORI [x] (MOVDconst [y]))
5612         // result: (MOVDconst [x | y])
5613         for {
5614                 x := auxIntToInt64(v.AuxInt)
5615                 if v_0.Op != OpRISCV64MOVDconst {
5616                         break
5617                 }
5618                 y := auxIntToInt64(v_0.AuxInt)
5619                 v.reset(OpRISCV64MOVDconst)
5620                 v.AuxInt = int64ToAuxInt(x | y)
5621                 return true
5622         }
5623         // match: (ORI [x] (ORI [y] z))
5624         // result: (ORI [x | y] z)
5625         for {
5626                 x := auxIntToInt64(v.AuxInt)
5627                 if v_0.Op != OpRISCV64ORI {
5628                         break
5629                 }
5630                 y := auxIntToInt64(v_0.AuxInt)
5631                 z := v_0.Args[0]
5632                 v.reset(OpRISCV64ORI)
5633                 v.AuxInt = int64ToAuxInt(x | y)
5634                 v.AddArg(z)
5635                 return true
5636         }
5637         return false
5638 }
5639 func rewriteValueRISCV64_OpRISCV64SEQZ(v *Value) bool {
5640         v_0 := v.Args[0]
5641         // match: (SEQZ (NEG x))
5642         // result: (SEQZ x)
5643         for {
5644                 if v_0.Op != OpRISCV64NEG {
5645                         break
5646                 }
5647                 x := v_0.Args[0]
5648                 v.reset(OpRISCV64SEQZ)
5649                 v.AddArg(x)
5650                 return true
5651         }
5652         // match: (SEQZ (SEQZ x))
5653         // result: (SNEZ x)
5654         for {
5655                 if v_0.Op != OpRISCV64SEQZ {
5656                         break
5657                 }
5658                 x := v_0.Args[0]
5659                 v.reset(OpRISCV64SNEZ)
5660                 v.AddArg(x)
5661                 return true
5662         }
5663         // match: (SEQZ (SNEZ x))
5664         // result: (SEQZ x)
5665         for {
5666                 if v_0.Op != OpRISCV64SNEZ {
5667                         break
5668                 }
5669                 x := v_0.Args[0]
5670                 v.reset(OpRISCV64SEQZ)
5671                 v.AddArg(x)
5672                 return true
5673         }
5674         return false
5675 }
5676 func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
5677         v_1 := v.Args[1]
5678         v_0 := v.Args[0]
5679         // match: (SLL x (MOVDconst [val]))
5680         // result: (SLLI [int64(val&63)] x)
5681         for {
5682                 x := v_0
5683                 if v_1.Op != OpRISCV64MOVDconst {
5684                         break
5685                 }
5686                 val := auxIntToInt64(v_1.AuxInt)
5687                 v.reset(OpRISCV64SLLI)
5688                 v.AuxInt = int64ToAuxInt(int64(val & 63))
5689                 v.AddArg(x)
5690                 return true
5691         }
5692         return false
5693 }
5694 func rewriteValueRISCV64_OpRISCV64SLLI(v *Value) bool {
5695         v_0 := v.Args[0]
5696         // match: (SLLI [x] (MOVDconst [y]))
5697         // cond: is32Bit(y << uint32(x))
5698         // result: (MOVDconst [y << uint32(x)])
5699         for {
5700                 x := auxIntToInt64(v.AuxInt)
5701                 if v_0.Op != OpRISCV64MOVDconst {
5702                         break
5703                 }
5704                 y := auxIntToInt64(v_0.AuxInt)
5705                 if !(is32Bit(y << uint32(x))) {
5706                         break
5707                 }
5708                 v.reset(OpRISCV64MOVDconst)
5709                 v.AuxInt = int64ToAuxInt(y << uint32(x))
5710                 return true
5711         }
5712         return false
5713 }
5714 func rewriteValueRISCV64_OpRISCV64SLT(v *Value) bool {
5715         v_1 := v.Args[1]
5716         v_0 := v.Args[0]
5717         // match: (SLT x (MOVDconst [val]))
5718         // cond: val >= -2048 && val <= 2047
5719         // result: (SLTI [val] x)
5720         for {
5721                 x := v_0
5722                 if v_1.Op != OpRISCV64MOVDconst {
5723                         break
5724                 }
5725                 val := auxIntToInt64(v_1.AuxInt)
5726                 if !(val >= -2048 && val <= 2047) {
5727                         break
5728                 }
5729                 v.reset(OpRISCV64SLTI)
5730                 v.AuxInt = int64ToAuxInt(val)
5731                 v.AddArg(x)
5732                 return true
5733         }
5734         // match: (SLT x x)
5735         // result: (MOVDconst [0])
5736         for {
5737                 x := v_0
5738                 if x != v_1 {
5739                         break
5740                 }
5741                 v.reset(OpRISCV64MOVDconst)
5742                 v.AuxInt = int64ToAuxInt(0)
5743                 return true
5744         }
5745         return false
5746 }
5747 func rewriteValueRISCV64_OpRISCV64SLTI(v *Value) bool {
5748         v_0 := v.Args[0]
5749         // match: (SLTI [x] (MOVDconst [y]))
5750         // result: (MOVDconst [b2i(int64(y) < int64(x))])
5751         for {
5752                 x := auxIntToInt64(v.AuxInt)
5753                 if v_0.Op != OpRISCV64MOVDconst {
5754                         break
5755                 }
5756                 y := auxIntToInt64(v_0.AuxInt)
5757                 v.reset(OpRISCV64MOVDconst)
5758                 v.AuxInt = int64ToAuxInt(b2i(int64(y) < int64(x)))
5759                 return true
5760         }
5761         // match: (SLTI [x] (ANDI [y] _))
5762         // cond: y >= 0 && int64(y) < int64(x)
5763         // result: (MOVDconst [1])
5764         for {
5765                 x := auxIntToInt64(v.AuxInt)
5766                 if v_0.Op != OpRISCV64ANDI {
5767                         break
5768                 }
5769                 y := auxIntToInt64(v_0.AuxInt)
5770                 if !(y >= 0 && int64(y) < int64(x)) {
5771                         break
5772                 }
5773                 v.reset(OpRISCV64MOVDconst)
5774                 v.AuxInt = int64ToAuxInt(1)
5775                 return true
5776         }
5777         // match: (SLTI [x] (ORI [y] _))
5778         // cond: y >= 0 && int64(y) >= int64(x)
5779         // result: (MOVDconst [0])
5780         for {
5781                 x := auxIntToInt64(v.AuxInt)
5782                 if v_0.Op != OpRISCV64ORI {
5783                         break
5784                 }
5785                 y := auxIntToInt64(v_0.AuxInt)
5786                 if !(y >= 0 && int64(y) >= int64(x)) {
5787                         break
5788                 }
5789                 v.reset(OpRISCV64MOVDconst)
5790                 v.AuxInt = int64ToAuxInt(0)
5791                 return true
5792         }
5793         return false
5794 }
5795 func rewriteValueRISCV64_OpRISCV64SLTIU(v *Value) bool {
5796         v_0 := v.Args[0]
5797         // match: (SLTIU [x] (MOVDconst [y]))
5798         // result: (MOVDconst [b2i(uint64(y) < uint64(x))])
5799         for {
5800                 x := auxIntToInt64(v.AuxInt)
5801                 if v_0.Op != OpRISCV64MOVDconst {
5802                         break
5803                 }
5804                 y := auxIntToInt64(v_0.AuxInt)
5805                 v.reset(OpRISCV64MOVDconst)
5806                 v.AuxInt = int64ToAuxInt(b2i(uint64(y) < uint64(x)))
5807                 return true
5808         }
5809         // match: (SLTIU [x] (ANDI [y] _))
5810         // cond: y >= 0 && uint64(y) < uint64(x)
5811         // result: (MOVDconst [1])
5812         for {
5813                 x := auxIntToInt64(v.AuxInt)
5814                 if v_0.Op != OpRISCV64ANDI {
5815                         break
5816                 }
5817                 y := auxIntToInt64(v_0.AuxInt)
5818                 if !(y >= 0 && uint64(y) < uint64(x)) {
5819                         break
5820                 }
5821                 v.reset(OpRISCV64MOVDconst)
5822                 v.AuxInt = int64ToAuxInt(1)
5823                 return true
5824         }
5825         // match: (SLTIU [x] (ORI [y] _))
5826         // cond: y >= 0 && uint64(y) >= uint64(x)
5827         // result: (MOVDconst [0])
5828         for {
5829                 x := auxIntToInt64(v.AuxInt)
5830                 if v_0.Op != OpRISCV64ORI {
5831                         break
5832                 }
5833                 y := auxIntToInt64(v_0.AuxInt)
5834                 if !(y >= 0 && uint64(y) >= uint64(x)) {
5835                         break
5836                 }
5837                 v.reset(OpRISCV64MOVDconst)
5838                 v.AuxInt = int64ToAuxInt(0)
5839                 return true
5840         }
5841         return false
5842 }
5843 func rewriteValueRISCV64_OpRISCV64SLTU(v *Value) bool {
5844         v_1 := v.Args[1]
5845         v_0 := v.Args[0]
5846         // match: (SLTU x (MOVDconst [val]))
5847         // cond: val >= -2048 && val <= 2047
5848         // result: (SLTIU [val] x)
5849         for {
5850                 x := v_0
5851                 if v_1.Op != OpRISCV64MOVDconst {
5852                         break
5853                 }
5854                 val := auxIntToInt64(v_1.AuxInt)
5855                 if !(val >= -2048 && val <= 2047) {
5856                         break
5857                 }
5858                 v.reset(OpRISCV64SLTIU)
5859                 v.AuxInt = int64ToAuxInt(val)
5860                 v.AddArg(x)
5861                 return true
5862         }
5863         // match: (SLTU x x)
5864         // result: (MOVDconst [0])
5865         for {
5866                 x := v_0
5867                 if x != v_1 {
5868                         break
5869                 }
5870                 v.reset(OpRISCV64MOVDconst)
5871                 v.AuxInt = int64ToAuxInt(0)
5872                 return true
5873         }
5874         return false
5875 }
5876 func rewriteValueRISCV64_OpRISCV64SNEZ(v *Value) bool {
5877         v_0 := v.Args[0]
5878         // match: (SNEZ (NEG x))
5879         // result: (SNEZ x)
5880         for {
5881                 if v_0.Op != OpRISCV64NEG {
5882                         break
5883                 }
5884                 x := v_0.Args[0]
5885                 v.reset(OpRISCV64SNEZ)
5886                 v.AddArg(x)
5887                 return true
5888         }
5889         // match: (SNEZ (SEQZ x))
5890         // result: (SEQZ x)
5891         for {
5892                 if v_0.Op != OpRISCV64SEQZ {
5893                         break
5894                 }
5895                 x := v_0.Args[0]
5896                 v.reset(OpRISCV64SEQZ)
5897                 v.AddArg(x)
5898                 return true
5899         }
5900         // match: (SNEZ (SNEZ x))
5901         // result: (SNEZ x)
5902         for {
5903                 if v_0.Op != OpRISCV64SNEZ {
5904                         break
5905                 }
5906                 x := v_0.Args[0]
5907                 v.reset(OpRISCV64SNEZ)
5908                 v.AddArg(x)
5909                 return true
5910         }
5911         return false
5912 }
5913 func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
5914         v_1 := v.Args[1]
5915         v_0 := v.Args[0]
5916         // match: (SRA x (MOVDconst [val]))
5917         // result: (SRAI [int64(val&63)] x)
5918         for {
5919                 x := v_0
5920                 if v_1.Op != OpRISCV64MOVDconst {
5921                         break
5922                 }
5923                 val := auxIntToInt64(v_1.AuxInt)
5924                 v.reset(OpRISCV64SRAI)
5925                 v.AuxInt = int64ToAuxInt(int64(val & 63))
5926                 v.AddArg(x)
5927                 return true
5928         }
5929         return false
5930 }
5931 func rewriteValueRISCV64_OpRISCV64SRAI(v *Value) bool {
5932         v_0 := v.Args[0]
5933         // match: (SRAI [x] (MOVDconst [y]))
5934         // result: (MOVDconst [int64(y) >> uint32(x)])
5935         for {
5936                 x := auxIntToInt64(v.AuxInt)
5937                 if v_0.Op != OpRISCV64MOVDconst {
5938                         break
5939                 }
5940                 y := auxIntToInt64(v_0.AuxInt)
5941                 v.reset(OpRISCV64MOVDconst)
5942                 v.AuxInt = int64ToAuxInt(int64(y) >> uint32(x))
5943                 return true
5944         }
5945         return false
5946 }
5947 func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
5948         v_1 := v.Args[1]
5949         v_0 := v.Args[0]
5950         // match: (SRL x (MOVDconst [val]))
5951         // result: (SRLI [int64(val&63)] x)
5952         for {
5953                 x := v_0
5954                 if v_1.Op != OpRISCV64MOVDconst {
5955                         break
5956                 }
5957                 val := auxIntToInt64(v_1.AuxInt)
5958                 v.reset(OpRISCV64SRLI)
5959                 v.AuxInt = int64ToAuxInt(int64(val & 63))
5960                 v.AddArg(x)
5961                 return true
5962         }
5963         return false
5964 }
5965 func rewriteValueRISCV64_OpRISCV64SRLI(v *Value) bool {
5966         v_0 := v.Args[0]
5967         // match: (SRLI [x] (MOVDconst [y]))
5968         // result: (MOVDconst [int64(uint64(y) >> uint32(x))])
5969         for {
5970                 x := auxIntToInt64(v.AuxInt)
5971                 if v_0.Op != OpRISCV64MOVDconst {
5972                         break
5973                 }
5974                 y := auxIntToInt64(v_0.AuxInt)
5975                 v.reset(OpRISCV64MOVDconst)
5976                 v.AuxInt = int64ToAuxInt(int64(uint64(y) >> uint32(x)))
5977                 return true
5978         }
5979         return false
5980 }
5981 func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
5982         v_1 := v.Args[1]
5983         v_0 := v.Args[0]
5984         b := v.Block
5985         // match: (SUB x (MOVDconst [val]))
5986         // cond: is32Bit(-val)
5987         // result: (ADDI [-val] x)
5988         for {
5989                 x := v_0
5990                 if v_1.Op != OpRISCV64MOVDconst {
5991                         break
5992                 }
5993                 val := auxIntToInt64(v_1.AuxInt)
5994                 if !(is32Bit(-val)) {
5995                         break
5996                 }
5997                 v.reset(OpRISCV64ADDI)
5998                 v.AuxInt = int64ToAuxInt(-val)
5999                 v.AddArg(x)
6000                 return true
6001         }
6002         // match: (SUB <t> (MOVDconst [val]) y)
6003         // cond: is32Bit(-val)
6004         // result: (NEG (ADDI <t> [-val] y))
6005         for {
6006                 t := v.Type
6007                 if v_0.Op != OpRISCV64MOVDconst {
6008                         break
6009                 }
6010                 val := auxIntToInt64(v_0.AuxInt)
6011                 y := v_1
6012                 if !(is32Bit(-val)) {
6013                         break
6014                 }
6015                 v.reset(OpRISCV64NEG)
6016                 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, t)
6017                 v0.AuxInt = int64ToAuxInt(-val)
6018                 v0.AddArg(y)
6019                 v.AddArg(v0)
6020                 return true
6021         }
6022         // match: (SUB x (MOVDconst [0]))
6023         // result: x
6024         for {
6025                 x := v_0
6026                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6027                         break
6028                 }
6029                 v.copyOf(x)
6030                 return true
6031         }
6032         // match: (SUB (MOVDconst [0]) x)
6033         // result: (NEG x)
6034         for {
6035                 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
6036                         break
6037                 }
6038                 x := v_1
6039                 v.reset(OpRISCV64NEG)
6040                 v.AddArg(x)
6041                 return true
6042         }
6043         return false
6044 }
6045 func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
6046         v_1 := v.Args[1]
6047         v_0 := v.Args[0]
6048         // match: (SUBW x (MOVDconst [0]))
6049         // result: (ADDIW [0] x)
6050         for {
6051                 x := v_0
6052                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
6053                         break
6054                 }
6055                 v.reset(OpRISCV64ADDIW)
6056                 v.AuxInt = int64ToAuxInt(0)
6057                 v.AddArg(x)
6058                 return true
6059         }
6060         // match: (SUBW (MOVDconst [0]) x)
6061         // result: (NEGW x)
6062         for {
6063                 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
6064                         break
6065                 }
6066                 x := v_1
6067                 v.reset(OpRISCV64NEGW)
6068                 v.AddArg(x)
6069                 return true
6070         }
6071         return false
6072 }
6073 func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
6074         v_1 := v.Args[1]
6075         v_0 := v.Args[0]
6076         // match: (XOR (MOVDconst [val]) x)
6077         // cond: is32Bit(val)
6078         // result: (XORI [val] x)
6079         for {
6080                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
6081                         if v_0.Op != OpRISCV64MOVDconst {
6082                                 continue
6083                         }
6084                         val := auxIntToInt64(v_0.AuxInt)
6085                         x := v_1
6086                         if !(is32Bit(val)) {
6087                                 continue
6088                         }
6089                         v.reset(OpRISCV64XORI)
6090                         v.AuxInt = int64ToAuxInt(val)
6091                         v.AddArg(x)
6092                         return true
6093                 }
6094                 break
6095         }
6096         return false
6097 }
6098 func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
6099         v_1 := v.Args[1]
6100         v_0 := v.Args[0]
6101         b := v.Block
6102         typ := &b.Func.Config.Types
6103         // match: (RotateLeft16 <t> x (MOVDconst [c]))
6104         // result: (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
6105         for {
6106                 t := v.Type
6107                 x := v_0
6108                 if v_1.Op != OpRISCV64MOVDconst {
6109                         break
6110                 }
6111                 c := auxIntToInt64(v_1.AuxInt)
6112                 v.reset(OpOr16)
6113                 v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
6114                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6115                 v1.AuxInt = int64ToAuxInt(c & 15)
6116                 v0.AddArg2(x, v1)
6117                 v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
6118                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6119                 v3.AuxInt = int64ToAuxInt(-c & 15)
6120                 v2.AddArg2(x, v3)
6121                 v.AddArg2(v0, v2)
6122                 return true
6123         }
6124         return false
6125 }
6126 func rewriteValueRISCV64_OpRotateLeft32(v *Value) bool {
6127         v_1 := v.Args[1]
6128         v_0 := v.Args[0]
6129         b := v.Block
6130         typ := &b.Func.Config.Types
6131         // match: (RotateLeft32 <t> x (MOVDconst [c]))
6132         // result: (Or32 (Lsh32x64 <t> x (MOVDconst [c&31])) (Rsh32Ux64 <t> x (MOVDconst [-c&31])))
6133         for {
6134                 t := v.Type
6135                 x := v_0
6136                 if v_1.Op != OpRISCV64MOVDconst {
6137                         break
6138                 }
6139                 c := auxIntToInt64(v_1.AuxInt)
6140                 v.reset(OpOr32)
6141                 v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
6142                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6143                 v1.AuxInt = int64ToAuxInt(c & 31)
6144                 v0.AddArg2(x, v1)
6145                 v2 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
6146                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6147                 v3.AuxInt = int64ToAuxInt(-c & 31)
6148                 v2.AddArg2(x, v3)
6149                 v.AddArg2(v0, v2)
6150                 return true
6151         }
6152         return false
6153 }
6154 func rewriteValueRISCV64_OpRotateLeft64(v *Value) bool {
6155         v_1 := v.Args[1]
6156         v_0 := v.Args[0]
6157         b := v.Block
6158         typ := &b.Func.Config.Types
6159         // match: (RotateLeft64 <t> x (MOVDconst [c]))
6160         // result: (Or64 (Lsh64x64 <t> x (MOVDconst [c&63])) (Rsh64Ux64 <t> x (MOVDconst [-c&63])))
6161         for {
6162                 t := v.Type
6163                 x := v_0
6164                 if v_1.Op != OpRISCV64MOVDconst {
6165                         break
6166                 }
6167                 c := auxIntToInt64(v_1.AuxInt)
6168                 v.reset(OpOr64)
6169                 v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
6170                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6171                 v1.AuxInt = int64ToAuxInt(c & 63)
6172                 v0.AddArg2(x, v1)
6173                 v2 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
6174                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6175                 v3.AuxInt = int64ToAuxInt(-c & 63)
6176                 v2.AddArg2(x, v3)
6177                 v.AddArg2(v0, v2)
6178                 return true
6179         }
6180         return false
6181 }
6182 func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
6183         v_1 := v.Args[1]
6184         v_0 := v.Args[0]
6185         b := v.Block
6186         typ := &b.Func.Config.Types
6187         // match: (RotateLeft8 <t> x (MOVDconst [c]))
6188         // result: (Or8 (Lsh8x64 <t> x (MOVDconst [c&7])) (Rsh8Ux64 <t> x (MOVDconst [-c&7])))
6189         for {
6190                 t := v.Type
6191                 x := v_0
6192                 if v_1.Op != OpRISCV64MOVDconst {
6193                         break
6194                 }
6195                 c := auxIntToInt64(v_1.AuxInt)
6196                 v.reset(OpOr8)
6197                 v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
6198                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6199                 v1.AuxInt = int64ToAuxInt(c & 7)
6200                 v0.AddArg2(x, v1)
6201                 v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
6202                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6203                 v3.AuxInt = int64ToAuxInt(-c & 7)
6204                 v2.AddArg2(x, v3)
6205                 v.AddArg2(v0, v2)
6206                 return true
6207         }
6208         return false
6209 }
6210 func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
6211         v_1 := v.Args[1]
6212         v_0 := v.Args[0]
6213         b := v.Block
6214         typ := &b.Func.Config.Types
6215         // match: (Rsh16Ux16 <t> x y)
6216         // cond: !shiftIsBounded(v)
6217         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
6218         for {
6219                 t := v.Type
6220                 x := v_0
6221                 y := v_1
6222                 if !(!shiftIsBounded(v)) {
6223                         break
6224                 }
6225                 v.reset(OpRISCV64AND)
6226                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6227                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6228                 v1.AddArg(x)
6229                 v0.AddArg2(v1, y)
6230                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
6231                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6232                 v3.AuxInt = int64ToAuxInt(64)
6233                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6234                 v4.AddArg(y)
6235                 v3.AddArg(v4)
6236                 v2.AddArg(v3)
6237                 v.AddArg2(v0, v2)
6238                 return true
6239         }
6240         // match: (Rsh16Ux16 x y)
6241         // cond: shiftIsBounded(v)
6242         // result: (SRL (ZeroExt16to64 x) y)
6243         for {
6244                 x := v_0
6245                 y := v_1
6246                 if !(shiftIsBounded(v)) {
6247                         break
6248                 }
6249                 v.reset(OpRISCV64SRL)
6250                 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6251                 v0.AddArg(x)
6252                 v.AddArg2(v0, y)
6253                 return true
6254         }
6255         return false
6256 }
6257 func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
6258         v_1 := v.Args[1]
6259         v_0 := v.Args[0]
6260         b := v.Block
6261         typ := &b.Func.Config.Types
6262         // match: (Rsh16Ux32 <t> x y)
6263         // cond: !shiftIsBounded(v)
6264         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
6265         for {
6266                 t := v.Type
6267                 x := v_0
6268                 y := v_1
6269                 if !(!shiftIsBounded(v)) {
6270                         break
6271                 }
6272                 v.reset(OpRISCV64AND)
6273                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6274                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6275                 v1.AddArg(x)
6276                 v0.AddArg2(v1, y)
6277                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
6278                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6279                 v3.AuxInt = int64ToAuxInt(64)
6280                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6281                 v4.AddArg(y)
6282                 v3.AddArg(v4)
6283                 v2.AddArg(v3)
6284                 v.AddArg2(v0, v2)
6285                 return true
6286         }
6287         // match: (Rsh16Ux32 x y)
6288         // cond: shiftIsBounded(v)
6289         // result: (SRL (ZeroExt16to64 x) y)
6290         for {
6291                 x := v_0
6292                 y := v_1
6293                 if !(shiftIsBounded(v)) {
6294                         break
6295                 }
6296                 v.reset(OpRISCV64SRL)
6297                 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6298                 v0.AddArg(x)
6299                 v.AddArg2(v0, y)
6300                 return true
6301         }
6302         return false
6303 }
6304 func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
6305         v_1 := v.Args[1]
6306         v_0 := v.Args[0]
6307         b := v.Block
6308         typ := &b.Func.Config.Types
6309         // match: (Rsh16Ux64 <t> x y)
6310         // cond: !shiftIsBounded(v)
6311         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] y)))
6312         for {
6313                 t := v.Type
6314                 x := v_0
6315                 y := v_1
6316                 if !(!shiftIsBounded(v)) {
6317                         break
6318                 }
6319                 v.reset(OpRISCV64AND)
6320                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6321                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6322                 v1.AddArg(x)
6323                 v0.AddArg2(v1, y)
6324                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
6325                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6326                 v3.AuxInt = int64ToAuxInt(64)
6327                 v3.AddArg(y)
6328                 v2.AddArg(v3)
6329                 v.AddArg2(v0, v2)
6330                 return true
6331         }
6332         // match: (Rsh16Ux64 x y)
6333         // cond: shiftIsBounded(v)
6334         // result: (SRL (ZeroExt16to64 x) y)
6335         for {
6336                 x := v_0
6337                 y := v_1
6338                 if !(shiftIsBounded(v)) {
6339                         break
6340                 }
6341                 v.reset(OpRISCV64SRL)
6342                 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6343                 v0.AddArg(x)
6344                 v.AddArg2(v0, y)
6345                 return true
6346         }
6347         return false
6348 }
6349 func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
6350         v_1 := v.Args[1]
6351         v_0 := v.Args[0]
6352         b := v.Block
6353         typ := &b.Func.Config.Types
6354         // match: (Rsh16Ux8 <t> x y)
6355         // cond: !shiftIsBounded(v)
6356         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
6357         for {
6358                 t := v.Type
6359                 x := v_0
6360                 y := v_1
6361                 if !(!shiftIsBounded(v)) {
6362                         break
6363                 }
6364                 v.reset(OpRISCV64AND)
6365                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6366                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6367                 v1.AddArg(x)
6368                 v0.AddArg2(v1, y)
6369                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
6370                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6371                 v3.AuxInt = int64ToAuxInt(64)
6372                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
6373                 v4.AddArg(y)
6374                 v3.AddArg(v4)
6375                 v2.AddArg(v3)
6376                 v.AddArg2(v0, v2)
6377                 return true
6378         }
6379         // match: (Rsh16Ux8 x y)
6380         // cond: shiftIsBounded(v)
6381         // result: (SRL (ZeroExt16to64 x) y)
6382         for {
6383                 x := v_0
6384                 y := v_1
6385                 if !(shiftIsBounded(v)) {
6386                         break
6387                 }
6388                 v.reset(OpRISCV64SRL)
6389                 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6390                 v0.AddArg(x)
6391                 v.AddArg2(v0, y)
6392                 return true
6393         }
6394         return false
6395 }
6396 func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
6397         v_1 := v.Args[1]
6398         v_0 := v.Args[0]
6399         b := v.Block
6400         typ := &b.Func.Config.Types
6401         // match: (Rsh16x16 <t> x y)
6402         // cond: !shiftIsBounded(v)
6403         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
6404         for {
6405                 t := v.Type
6406                 x := v_0
6407                 y := v_1
6408                 if !(!shiftIsBounded(v)) {
6409                         break
6410                 }
6411                 v.reset(OpRISCV64SRA)
6412                 v.Type = t
6413                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6414                 v0.AddArg(x)
6415                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6416                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6417                 v2.AuxInt = int64ToAuxInt(-1)
6418                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6419                 v3.AuxInt = int64ToAuxInt(64)
6420                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6421                 v4.AddArg(y)
6422                 v3.AddArg(v4)
6423                 v2.AddArg(v3)
6424                 v1.AddArg2(y, v2)
6425                 v.AddArg2(v0, v1)
6426                 return true
6427         }
6428         // match: (Rsh16x16 x y)
6429         // cond: shiftIsBounded(v)
6430         // result: (SRA (SignExt16to64 x) y)
6431         for {
6432                 x := v_0
6433                 y := v_1
6434                 if !(shiftIsBounded(v)) {
6435                         break
6436                 }
6437                 v.reset(OpRISCV64SRA)
6438                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6439                 v0.AddArg(x)
6440                 v.AddArg2(v0, y)
6441                 return true
6442         }
6443         return false
6444 }
6445 func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
6446         v_1 := v.Args[1]
6447         v_0 := v.Args[0]
6448         b := v.Block
6449         typ := &b.Func.Config.Types
6450         // match: (Rsh16x32 <t> x y)
6451         // cond: !shiftIsBounded(v)
6452         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
6453         for {
6454                 t := v.Type
6455                 x := v_0
6456                 y := v_1
6457                 if !(!shiftIsBounded(v)) {
6458                         break
6459                 }
6460                 v.reset(OpRISCV64SRA)
6461                 v.Type = t
6462                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6463                 v0.AddArg(x)
6464                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6465                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6466                 v2.AuxInt = int64ToAuxInt(-1)
6467                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6468                 v3.AuxInt = int64ToAuxInt(64)
6469                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6470                 v4.AddArg(y)
6471                 v3.AddArg(v4)
6472                 v2.AddArg(v3)
6473                 v1.AddArg2(y, v2)
6474                 v.AddArg2(v0, v1)
6475                 return true
6476         }
6477         // match: (Rsh16x32 x y)
6478         // cond: shiftIsBounded(v)
6479         // result: (SRA (SignExt16to64 x) y)
6480         for {
6481                 x := v_0
6482                 y := v_1
6483                 if !(shiftIsBounded(v)) {
6484                         break
6485                 }
6486                 v.reset(OpRISCV64SRA)
6487                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6488                 v0.AddArg(x)
6489                 v.AddArg2(v0, y)
6490                 return true
6491         }
6492         return false
6493 }
6494 func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
6495         v_1 := v.Args[1]
6496         v_0 := v.Args[0]
6497         b := v.Block
6498         typ := &b.Func.Config.Types
6499         // match: (Rsh16x64 <t> x y)
6500         // cond: !shiftIsBounded(v)
6501         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
6502         for {
6503                 t := v.Type
6504                 x := v_0
6505                 y := v_1
6506                 if !(!shiftIsBounded(v)) {
6507                         break
6508                 }
6509                 v.reset(OpRISCV64SRA)
6510                 v.Type = t
6511                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6512                 v0.AddArg(x)
6513                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6514                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6515                 v2.AuxInt = int64ToAuxInt(-1)
6516                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6517                 v3.AuxInt = int64ToAuxInt(64)
6518                 v3.AddArg(y)
6519                 v2.AddArg(v3)
6520                 v1.AddArg2(y, v2)
6521                 v.AddArg2(v0, v1)
6522                 return true
6523         }
6524         // match: (Rsh16x64 x y)
6525         // cond: shiftIsBounded(v)
6526         // result: (SRA (SignExt16to64 x) y)
6527         for {
6528                 x := v_0
6529                 y := v_1
6530                 if !(shiftIsBounded(v)) {
6531                         break
6532                 }
6533                 v.reset(OpRISCV64SRA)
6534                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6535                 v0.AddArg(x)
6536                 v.AddArg2(v0, y)
6537                 return true
6538         }
6539         return false
6540 }
6541 func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
6542         v_1 := v.Args[1]
6543         v_0 := v.Args[0]
6544         b := v.Block
6545         typ := &b.Func.Config.Types
6546         // match: (Rsh16x8 <t> x y)
6547         // cond: !shiftIsBounded(v)
6548         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
6549         for {
6550                 t := v.Type
6551                 x := v_0
6552                 y := v_1
6553                 if !(!shiftIsBounded(v)) {
6554                         break
6555                 }
6556                 v.reset(OpRISCV64SRA)
6557                 v.Type = t
6558                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6559                 v0.AddArg(x)
6560                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6561                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6562                 v2.AuxInt = int64ToAuxInt(-1)
6563                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6564                 v3.AuxInt = int64ToAuxInt(64)
6565                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
6566                 v4.AddArg(y)
6567                 v3.AddArg(v4)
6568                 v2.AddArg(v3)
6569                 v1.AddArg2(y, v2)
6570                 v.AddArg2(v0, v1)
6571                 return true
6572         }
6573         // match: (Rsh16x8 x y)
6574         // cond: shiftIsBounded(v)
6575         // result: (SRA (SignExt16to64 x) y)
6576         for {
6577                 x := v_0
6578                 y := v_1
6579                 if !(shiftIsBounded(v)) {
6580                         break
6581                 }
6582                 v.reset(OpRISCV64SRA)
6583                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
6584                 v0.AddArg(x)
6585                 v.AddArg2(v0, y)
6586                 return true
6587         }
6588         return false
6589 }
6590 func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
6591         v_1 := v.Args[1]
6592         v_0 := v.Args[0]
6593         b := v.Block
6594         typ := &b.Func.Config.Types
6595         // match: (Rsh32Ux16 <t> x y)
6596         // cond: !shiftIsBounded(v)
6597         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
6598         for {
6599                 t := v.Type
6600                 x := v_0
6601                 y := v_1
6602                 if !(!shiftIsBounded(v)) {
6603                         break
6604                 }
6605                 v.reset(OpRISCV64AND)
6606                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6607                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6608                 v1.AddArg(x)
6609                 v0.AddArg2(v1, y)
6610                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
6611                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6612                 v3.AuxInt = int64ToAuxInt(64)
6613                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6614                 v4.AddArg(y)
6615                 v3.AddArg(v4)
6616                 v2.AddArg(v3)
6617                 v.AddArg2(v0, v2)
6618                 return true
6619         }
6620         // match: (Rsh32Ux16 x y)
6621         // cond: shiftIsBounded(v)
6622         // result: (SRL (ZeroExt32to64 x) y)
6623         for {
6624                 x := v_0
6625                 y := v_1
6626                 if !(shiftIsBounded(v)) {
6627                         break
6628                 }
6629                 v.reset(OpRISCV64SRL)
6630                 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6631                 v0.AddArg(x)
6632                 v.AddArg2(v0, y)
6633                 return true
6634         }
6635         return false
6636 }
6637 func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
6638         v_1 := v.Args[1]
6639         v_0 := v.Args[0]
6640         b := v.Block
6641         typ := &b.Func.Config.Types
6642         // match: (Rsh32Ux32 <t> x y)
6643         // cond: !shiftIsBounded(v)
6644         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
6645         for {
6646                 t := v.Type
6647                 x := v_0
6648                 y := v_1
6649                 if !(!shiftIsBounded(v)) {
6650                         break
6651                 }
6652                 v.reset(OpRISCV64AND)
6653                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6654                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6655                 v1.AddArg(x)
6656                 v0.AddArg2(v1, y)
6657                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
6658                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6659                 v3.AuxInt = int64ToAuxInt(64)
6660                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6661                 v4.AddArg(y)
6662                 v3.AddArg(v4)
6663                 v2.AddArg(v3)
6664                 v.AddArg2(v0, v2)
6665                 return true
6666         }
6667         // match: (Rsh32Ux32 x y)
6668         // cond: shiftIsBounded(v)
6669         // result: (SRL (ZeroExt32to64 x) y)
6670         for {
6671                 x := v_0
6672                 y := v_1
6673                 if !(shiftIsBounded(v)) {
6674                         break
6675                 }
6676                 v.reset(OpRISCV64SRL)
6677                 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6678                 v0.AddArg(x)
6679                 v.AddArg2(v0, y)
6680                 return true
6681         }
6682         return false
6683 }
6684 func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
6685         v_1 := v.Args[1]
6686         v_0 := v.Args[0]
6687         b := v.Block
6688         typ := &b.Func.Config.Types
6689         // match: (Rsh32Ux64 <t> x y)
6690         // cond: !shiftIsBounded(v)
6691         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] y)))
6692         for {
6693                 t := v.Type
6694                 x := v_0
6695                 y := v_1
6696                 if !(!shiftIsBounded(v)) {
6697                         break
6698                 }
6699                 v.reset(OpRISCV64AND)
6700                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6701                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6702                 v1.AddArg(x)
6703                 v0.AddArg2(v1, y)
6704                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
6705                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6706                 v3.AuxInt = int64ToAuxInt(64)
6707                 v3.AddArg(y)
6708                 v2.AddArg(v3)
6709                 v.AddArg2(v0, v2)
6710                 return true
6711         }
6712         // match: (Rsh32Ux64 x y)
6713         // cond: shiftIsBounded(v)
6714         // result: (SRL (ZeroExt32to64 x) y)
6715         for {
6716                 x := v_0
6717                 y := v_1
6718                 if !(shiftIsBounded(v)) {
6719                         break
6720                 }
6721                 v.reset(OpRISCV64SRL)
6722                 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6723                 v0.AddArg(x)
6724                 v.AddArg2(v0, y)
6725                 return true
6726         }
6727         return false
6728 }
6729 func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
6730         v_1 := v.Args[1]
6731         v_0 := v.Args[0]
6732         b := v.Block
6733         typ := &b.Func.Config.Types
6734         // match: (Rsh32Ux8 <t> x y)
6735         // cond: !shiftIsBounded(v)
6736         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
6737         for {
6738                 t := v.Type
6739                 x := v_0
6740                 y := v_1
6741                 if !(!shiftIsBounded(v)) {
6742                         break
6743                 }
6744                 v.reset(OpRISCV64AND)
6745                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6746                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6747                 v1.AddArg(x)
6748                 v0.AddArg2(v1, y)
6749                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
6750                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6751                 v3.AuxInt = int64ToAuxInt(64)
6752                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
6753                 v4.AddArg(y)
6754                 v3.AddArg(v4)
6755                 v2.AddArg(v3)
6756                 v.AddArg2(v0, v2)
6757                 return true
6758         }
6759         // match: (Rsh32Ux8 x y)
6760         // cond: shiftIsBounded(v)
6761         // result: (SRL (ZeroExt32to64 x) y)
6762         for {
6763                 x := v_0
6764                 y := v_1
6765                 if !(shiftIsBounded(v)) {
6766                         break
6767                 }
6768                 v.reset(OpRISCV64SRL)
6769                 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6770                 v0.AddArg(x)
6771                 v.AddArg2(v0, y)
6772                 return true
6773         }
6774         return false
6775 }
6776 func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
6777         v_1 := v.Args[1]
6778         v_0 := v.Args[0]
6779         b := v.Block
6780         typ := &b.Func.Config.Types
6781         // match: (Rsh32x16 <t> x y)
6782         // cond: !shiftIsBounded(v)
6783         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
6784         for {
6785                 t := v.Type
6786                 x := v_0
6787                 y := v_1
6788                 if !(!shiftIsBounded(v)) {
6789                         break
6790                 }
6791                 v.reset(OpRISCV64SRA)
6792                 v.Type = t
6793                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6794                 v0.AddArg(x)
6795                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6796                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6797                 v2.AuxInt = int64ToAuxInt(-1)
6798                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6799                 v3.AuxInt = int64ToAuxInt(64)
6800                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6801                 v4.AddArg(y)
6802                 v3.AddArg(v4)
6803                 v2.AddArg(v3)
6804                 v1.AddArg2(y, v2)
6805                 v.AddArg2(v0, v1)
6806                 return true
6807         }
6808         // match: (Rsh32x16 x y)
6809         // cond: shiftIsBounded(v)
6810         // result: (SRA (SignExt32to64 x) y)
6811         for {
6812                 x := v_0
6813                 y := v_1
6814                 if !(shiftIsBounded(v)) {
6815                         break
6816                 }
6817                 v.reset(OpRISCV64SRA)
6818                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6819                 v0.AddArg(x)
6820                 v.AddArg2(v0, y)
6821                 return true
6822         }
6823         return false
6824 }
6825 func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
6826         v_1 := v.Args[1]
6827         v_0 := v.Args[0]
6828         b := v.Block
6829         typ := &b.Func.Config.Types
6830         // match: (Rsh32x32 <t> x y)
6831         // cond: !shiftIsBounded(v)
6832         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
6833         for {
6834                 t := v.Type
6835                 x := v_0
6836                 y := v_1
6837                 if !(!shiftIsBounded(v)) {
6838                         break
6839                 }
6840                 v.reset(OpRISCV64SRA)
6841                 v.Type = t
6842                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6843                 v0.AddArg(x)
6844                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6845                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6846                 v2.AuxInt = int64ToAuxInt(-1)
6847                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6848                 v3.AuxInt = int64ToAuxInt(64)
6849                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
6850                 v4.AddArg(y)
6851                 v3.AddArg(v4)
6852                 v2.AddArg(v3)
6853                 v1.AddArg2(y, v2)
6854                 v.AddArg2(v0, v1)
6855                 return true
6856         }
6857         // match: (Rsh32x32 x y)
6858         // cond: shiftIsBounded(v)
6859         // result: (SRA (SignExt32to64 x) y)
6860         for {
6861                 x := v_0
6862                 y := v_1
6863                 if !(shiftIsBounded(v)) {
6864                         break
6865                 }
6866                 v.reset(OpRISCV64SRA)
6867                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6868                 v0.AddArg(x)
6869                 v.AddArg2(v0, y)
6870                 return true
6871         }
6872         return false
6873 }
6874 func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
6875         v_1 := v.Args[1]
6876         v_0 := v.Args[0]
6877         b := v.Block
6878         typ := &b.Func.Config.Types
6879         // match: (Rsh32x64 <t> x y)
6880         // cond: !shiftIsBounded(v)
6881         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
6882         for {
6883                 t := v.Type
6884                 x := v_0
6885                 y := v_1
6886                 if !(!shiftIsBounded(v)) {
6887                         break
6888                 }
6889                 v.reset(OpRISCV64SRA)
6890                 v.Type = t
6891                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6892                 v0.AddArg(x)
6893                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6894                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6895                 v2.AuxInt = int64ToAuxInt(-1)
6896                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6897                 v3.AuxInt = int64ToAuxInt(64)
6898                 v3.AddArg(y)
6899                 v2.AddArg(v3)
6900                 v1.AddArg2(y, v2)
6901                 v.AddArg2(v0, v1)
6902                 return true
6903         }
6904         // match: (Rsh32x64 x y)
6905         // cond: shiftIsBounded(v)
6906         // result: (SRA (SignExt32to64 x) y)
6907         for {
6908                 x := v_0
6909                 y := v_1
6910                 if !(shiftIsBounded(v)) {
6911                         break
6912                 }
6913                 v.reset(OpRISCV64SRA)
6914                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6915                 v0.AddArg(x)
6916                 v.AddArg2(v0, y)
6917                 return true
6918         }
6919         return false
6920 }
6921 func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
6922         v_1 := v.Args[1]
6923         v_0 := v.Args[0]
6924         b := v.Block
6925         typ := &b.Func.Config.Types
6926         // match: (Rsh32x8 <t> x y)
6927         // cond: !shiftIsBounded(v)
6928         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
6929         for {
6930                 t := v.Type
6931                 x := v_0
6932                 y := v_1
6933                 if !(!shiftIsBounded(v)) {
6934                         break
6935                 }
6936                 v.reset(OpRISCV64SRA)
6937                 v.Type = t
6938                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6939                 v0.AddArg(x)
6940                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
6941                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
6942                 v2.AuxInt = int64ToAuxInt(-1)
6943                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
6944                 v3.AuxInt = int64ToAuxInt(64)
6945                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
6946                 v4.AddArg(y)
6947                 v3.AddArg(v4)
6948                 v2.AddArg(v3)
6949                 v1.AddArg2(y, v2)
6950                 v.AddArg2(v0, v1)
6951                 return true
6952         }
6953         // match: (Rsh32x8 x y)
6954         // cond: shiftIsBounded(v)
6955         // result: (SRA (SignExt32to64 x) y)
6956         for {
6957                 x := v_0
6958                 y := v_1
6959                 if !(shiftIsBounded(v)) {
6960                         break
6961                 }
6962                 v.reset(OpRISCV64SRA)
6963                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
6964                 v0.AddArg(x)
6965                 v.AddArg2(v0, y)
6966                 return true
6967         }
6968         return false
6969 }
6970 func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
6971         v_1 := v.Args[1]
6972         v_0 := v.Args[0]
6973         b := v.Block
6974         typ := &b.Func.Config.Types
6975         // match: (Rsh64Ux16 <t> x y)
6976         // cond: !shiftIsBounded(v)
6977         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
6978         for {
6979                 t := v.Type
6980                 x := v_0
6981                 y := v_1
6982                 if !(!shiftIsBounded(v)) {
6983                         break
6984                 }
6985                 v.reset(OpRISCV64AND)
6986                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
6987                 v0.AddArg2(x, y)
6988                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
6989                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
6990                 v2.AuxInt = int64ToAuxInt(64)
6991                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
6992                 v3.AddArg(y)
6993                 v2.AddArg(v3)
6994                 v1.AddArg(v2)
6995                 v.AddArg2(v0, v1)
6996                 return true
6997         }
6998         // match: (Rsh64Ux16 x y)
6999         // cond: shiftIsBounded(v)
7000         // result: (SRL x y)
7001         for {
7002                 x := v_0
7003                 y := v_1
7004                 if !(shiftIsBounded(v)) {
7005                         break
7006                 }
7007                 v.reset(OpRISCV64SRL)
7008                 v.AddArg2(x, y)
7009                 return true
7010         }
7011         return false
7012 }
7013 func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
7014         v_1 := v.Args[1]
7015         v_0 := v.Args[0]
7016         b := v.Block
7017         typ := &b.Func.Config.Types
7018         // match: (Rsh64Ux32 <t> x y)
7019         // cond: !shiftIsBounded(v)
7020         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
7021         for {
7022                 t := v.Type
7023                 x := v_0
7024                 y := v_1
7025                 if !(!shiftIsBounded(v)) {
7026                         break
7027                 }
7028                 v.reset(OpRISCV64AND)
7029                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7030                 v0.AddArg2(x, y)
7031                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
7032                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7033                 v2.AuxInt = int64ToAuxInt(64)
7034                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7035                 v3.AddArg(y)
7036                 v2.AddArg(v3)
7037                 v1.AddArg(v2)
7038                 v.AddArg2(v0, v1)
7039                 return true
7040         }
7041         // match: (Rsh64Ux32 x y)
7042         // cond: shiftIsBounded(v)
7043         // result: (SRL x y)
7044         for {
7045                 x := v_0
7046                 y := v_1
7047                 if !(shiftIsBounded(v)) {
7048                         break
7049                 }
7050                 v.reset(OpRISCV64SRL)
7051                 v.AddArg2(x, y)
7052                 return true
7053         }
7054         return false
7055 }
7056 func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
7057         v_1 := v.Args[1]
7058         v_0 := v.Args[0]
7059         b := v.Block
7060         // match: (Rsh64Ux64 <t> x y)
7061         // cond: !shiftIsBounded(v)
7062         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] y)))
7063         for {
7064                 t := v.Type
7065                 x := v_0
7066                 y := v_1
7067                 if !(!shiftIsBounded(v)) {
7068                         break
7069                 }
7070                 v.reset(OpRISCV64AND)
7071                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7072                 v0.AddArg2(x, y)
7073                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
7074                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7075                 v2.AuxInt = int64ToAuxInt(64)
7076                 v2.AddArg(y)
7077                 v1.AddArg(v2)
7078                 v.AddArg2(v0, v1)
7079                 return true
7080         }
7081         // match: (Rsh64Ux64 x y)
7082         // cond: shiftIsBounded(v)
7083         // result: (SRL x y)
7084         for {
7085                 x := v_0
7086                 y := v_1
7087                 if !(shiftIsBounded(v)) {
7088                         break
7089                 }
7090                 v.reset(OpRISCV64SRL)
7091                 v.AddArg2(x, y)
7092                 return true
7093         }
7094         return false
7095 }
7096 func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
7097         v_1 := v.Args[1]
7098         v_0 := v.Args[0]
7099         b := v.Block
7100         typ := &b.Func.Config.Types
7101         // match: (Rsh64Ux8 <t> x y)
7102         // cond: !shiftIsBounded(v)
7103         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
7104         for {
7105                 t := v.Type
7106                 x := v_0
7107                 y := v_1
7108                 if !(!shiftIsBounded(v)) {
7109                         break
7110                 }
7111                 v.reset(OpRISCV64AND)
7112                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7113                 v0.AddArg2(x, y)
7114                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
7115                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7116                 v2.AuxInt = int64ToAuxInt(64)
7117                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7118                 v3.AddArg(y)
7119                 v2.AddArg(v3)
7120                 v1.AddArg(v2)
7121                 v.AddArg2(v0, v1)
7122                 return true
7123         }
7124         // match: (Rsh64Ux8 x y)
7125         // cond: shiftIsBounded(v)
7126         // result: (SRL x y)
7127         for {
7128                 x := v_0
7129                 y := v_1
7130                 if !(shiftIsBounded(v)) {
7131                         break
7132                 }
7133                 v.reset(OpRISCV64SRL)
7134                 v.AddArg2(x, y)
7135                 return true
7136         }
7137         return false
7138 }
7139 func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
7140         v_1 := v.Args[1]
7141         v_0 := v.Args[0]
7142         b := v.Block
7143         typ := &b.Func.Config.Types
7144         // match: (Rsh64x16 <t> x y)
7145         // cond: !shiftIsBounded(v)
7146         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
7147         for {
7148                 t := v.Type
7149                 x := v_0
7150                 y := v_1
7151                 if !(!shiftIsBounded(v)) {
7152                         break
7153                 }
7154                 v.reset(OpRISCV64SRA)
7155                 v.Type = t
7156                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7157                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7158                 v1.AuxInt = int64ToAuxInt(-1)
7159                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7160                 v2.AuxInt = int64ToAuxInt(64)
7161                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7162                 v3.AddArg(y)
7163                 v2.AddArg(v3)
7164                 v1.AddArg(v2)
7165                 v0.AddArg2(y, v1)
7166                 v.AddArg2(x, v0)
7167                 return true
7168         }
7169         // match: (Rsh64x16 x y)
7170         // cond: shiftIsBounded(v)
7171         // result: (SRA x y)
7172         for {
7173                 x := v_0
7174                 y := v_1
7175                 if !(shiftIsBounded(v)) {
7176                         break
7177                 }
7178                 v.reset(OpRISCV64SRA)
7179                 v.AddArg2(x, y)
7180                 return true
7181         }
7182         return false
7183 }
7184 func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
7185         v_1 := v.Args[1]
7186         v_0 := v.Args[0]
7187         b := v.Block
7188         typ := &b.Func.Config.Types
7189         // match: (Rsh64x32 <t> x y)
7190         // cond: !shiftIsBounded(v)
7191         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
7192         for {
7193                 t := v.Type
7194                 x := v_0
7195                 y := v_1
7196                 if !(!shiftIsBounded(v)) {
7197                         break
7198                 }
7199                 v.reset(OpRISCV64SRA)
7200                 v.Type = t
7201                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7202                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7203                 v1.AuxInt = int64ToAuxInt(-1)
7204                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7205                 v2.AuxInt = int64ToAuxInt(64)
7206                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7207                 v3.AddArg(y)
7208                 v2.AddArg(v3)
7209                 v1.AddArg(v2)
7210                 v0.AddArg2(y, v1)
7211                 v.AddArg2(x, v0)
7212                 return true
7213         }
7214         // match: (Rsh64x32 x y)
7215         // cond: shiftIsBounded(v)
7216         // result: (SRA x y)
7217         for {
7218                 x := v_0
7219                 y := v_1
7220                 if !(shiftIsBounded(v)) {
7221                         break
7222                 }
7223                 v.reset(OpRISCV64SRA)
7224                 v.AddArg2(x, y)
7225                 return true
7226         }
7227         return false
7228 }
7229 func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
7230         v_1 := v.Args[1]
7231         v_0 := v.Args[0]
7232         b := v.Block
7233         // match: (Rsh64x64 <t> x y)
7234         // cond: !shiftIsBounded(v)
7235         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
7236         for {
7237                 t := v.Type
7238                 x := v_0
7239                 y := v_1
7240                 if !(!shiftIsBounded(v)) {
7241                         break
7242                 }
7243                 v.reset(OpRISCV64SRA)
7244                 v.Type = t
7245                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7246                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7247                 v1.AuxInt = int64ToAuxInt(-1)
7248                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7249                 v2.AuxInt = int64ToAuxInt(64)
7250                 v2.AddArg(y)
7251                 v1.AddArg(v2)
7252                 v0.AddArg2(y, v1)
7253                 v.AddArg2(x, v0)
7254                 return true
7255         }
7256         // match: (Rsh64x64 x y)
7257         // cond: shiftIsBounded(v)
7258         // result: (SRA x y)
7259         for {
7260                 x := v_0
7261                 y := v_1
7262                 if !(shiftIsBounded(v)) {
7263                         break
7264                 }
7265                 v.reset(OpRISCV64SRA)
7266                 v.AddArg2(x, y)
7267                 return true
7268         }
7269         return false
7270 }
7271 func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
7272         v_1 := v.Args[1]
7273         v_0 := v.Args[0]
7274         b := v.Block
7275         typ := &b.Func.Config.Types
7276         // match: (Rsh64x8 <t> x y)
7277         // cond: !shiftIsBounded(v)
7278         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
7279         for {
7280                 t := v.Type
7281                 x := v_0
7282                 y := v_1
7283                 if !(!shiftIsBounded(v)) {
7284                         break
7285                 }
7286                 v.reset(OpRISCV64SRA)
7287                 v.Type = t
7288                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7289                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7290                 v1.AuxInt = int64ToAuxInt(-1)
7291                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7292                 v2.AuxInt = int64ToAuxInt(64)
7293                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7294                 v3.AddArg(y)
7295                 v2.AddArg(v3)
7296                 v1.AddArg(v2)
7297                 v0.AddArg2(y, v1)
7298                 v.AddArg2(x, v0)
7299                 return true
7300         }
7301         // match: (Rsh64x8 x y)
7302         // cond: shiftIsBounded(v)
7303         // result: (SRA x y)
7304         for {
7305                 x := v_0
7306                 y := v_1
7307                 if !(shiftIsBounded(v)) {
7308                         break
7309                 }
7310                 v.reset(OpRISCV64SRA)
7311                 v.AddArg2(x, y)
7312                 return true
7313         }
7314         return false
7315 }
7316 func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
7317         v_1 := v.Args[1]
7318         v_0 := v.Args[0]
7319         b := v.Block
7320         typ := &b.Func.Config.Types
7321         // match: (Rsh8Ux16 <t> x y)
7322         // cond: !shiftIsBounded(v)
7323         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
7324         for {
7325                 t := v.Type
7326                 x := v_0
7327                 y := v_1
7328                 if !(!shiftIsBounded(v)) {
7329                         break
7330                 }
7331                 v.reset(OpRISCV64AND)
7332                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7333                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7334                 v1.AddArg(x)
7335                 v0.AddArg2(v1, y)
7336                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
7337                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7338                 v3.AuxInt = int64ToAuxInt(64)
7339                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7340                 v4.AddArg(y)
7341                 v3.AddArg(v4)
7342                 v2.AddArg(v3)
7343                 v.AddArg2(v0, v2)
7344                 return true
7345         }
7346         // match: (Rsh8Ux16 x y)
7347         // cond: shiftIsBounded(v)
7348         // result: (SRL (ZeroExt8to64 x) y)
7349         for {
7350                 x := v_0
7351                 y := v_1
7352                 if !(shiftIsBounded(v)) {
7353                         break
7354                 }
7355                 v.reset(OpRISCV64SRL)
7356                 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7357                 v0.AddArg(x)
7358                 v.AddArg2(v0, y)
7359                 return true
7360         }
7361         return false
7362 }
7363 func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
7364         v_1 := v.Args[1]
7365         v_0 := v.Args[0]
7366         b := v.Block
7367         typ := &b.Func.Config.Types
7368         // match: (Rsh8Ux32 <t> x y)
7369         // cond: !shiftIsBounded(v)
7370         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
7371         for {
7372                 t := v.Type
7373                 x := v_0
7374                 y := v_1
7375                 if !(!shiftIsBounded(v)) {
7376                         break
7377                 }
7378                 v.reset(OpRISCV64AND)
7379                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7380                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7381                 v1.AddArg(x)
7382                 v0.AddArg2(v1, y)
7383                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
7384                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7385                 v3.AuxInt = int64ToAuxInt(64)
7386                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7387                 v4.AddArg(y)
7388                 v3.AddArg(v4)
7389                 v2.AddArg(v3)
7390                 v.AddArg2(v0, v2)
7391                 return true
7392         }
7393         // match: (Rsh8Ux32 x y)
7394         // cond: shiftIsBounded(v)
7395         // result: (SRL (ZeroExt8to64 x) y)
7396         for {
7397                 x := v_0
7398                 y := v_1
7399                 if !(shiftIsBounded(v)) {
7400                         break
7401                 }
7402                 v.reset(OpRISCV64SRL)
7403                 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7404                 v0.AddArg(x)
7405                 v.AddArg2(v0, y)
7406                 return true
7407         }
7408         return false
7409 }
7410 func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
7411         v_1 := v.Args[1]
7412         v_0 := v.Args[0]
7413         b := v.Block
7414         typ := &b.Func.Config.Types
7415         // match: (Rsh8Ux64 <t> x y)
7416         // cond: !shiftIsBounded(v)
7417         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] y)))
7418         for {
7419                 t := v.Type
7420                 x := v_0
7421                 y := v_1
7422                 if !(!shiftIsBounded(v)) {
7423                         break
7424                 }
7425                 v.reset(OpRISCV64AND)
7426                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7427                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7428                 v1.AddArg(x)
7429                 v0.AddArg2(v1, y)
7430                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
7431                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7432                 v3.AuxInt = int64ToAuxInt(64)
7433                 v3.AddArg(y)
7434                 v2.AddArg(v3)
7435                 v.AddArg2(v0, v2)
7436                 return true
7437         }
7438         // match: (Rsh8Ux64 x y)
7439         // cond: shiftIsBounded(v)
7440         // result: (SRL (ZeroExt8to64 x) y)
7441         for {
7442                 x := v_0
7443                 y := v_1
7444                 if !(shiftIsBounded(v)) {
7445                         break
7446                 }
7447                 v.reset(OpRISCV64SRL)
7448                 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7449                 v0.AddArg(x)
7450                 v.AddArg2(v0, y)
7451                 return true
7452         }
7453         return false
7454 }
7455 func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
7456         v_1 := v.Args[1]
7457         v_0 := v.Args[0]
7458         b := v.Block
7459         typ := &b.Func.Config.Types
7460         // match: (Rsh8Ux8 <t> x y)
7461         // cond: !shiftIsBounded(v)
7462         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
7463         for {
7464                 t := v.Type
7465                 x := v_0
7466                 y := v_1
7467                 if !(!shiftIsBounded(v)) {
7468                         break
7469                 }
7470                 v.reset(OpRISCV64AND)
7471                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
7472                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7473                 v1.AddArg(x)
7474                 v0.AddArg2(v1, y)
7475                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
7476                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
7477                 v3.AuxInt = int64ToAuxInt(64)
7478                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7479                 v4.AddArg(y)
7480                 v3.AddArg(v4)
7481                 v2.AddArg(v3)
7482                 v.AddArg2(v0, v2)
7483                 return true
7484         }
7485         // match: (Rsh8Ux8 x y)
7486         // cond: shiftIsBounded(v)
7487         // result: (SRL (ZeroExt8to64 x) y)
7488         for {
7489                 x := v_0
7490                 y := v_1
7491                 if !(shiftIsBounded(v)) {
7492                         break
7493                 }
7494                 v.reset(OpRISCV64SRL)
7495                 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7496                 v0.AddArg(x)
7497                 v.AddArg2(v0, y)
7498                 return true
7499         }
7500         return false
7501 }
7502 func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
7503         v_1 := v.Args[1]
7504         v_0 := v.Args[0]
7505         b := v.Block
7506         typ := &b.Func.Config.Types
7507         // match: (Rsh8x16 <t> x y)
7508         // cond: !shiftIsBounded(v)
7509         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
7510         for {
7511                 t := v.Type
7512                 x := v_0
7513                 y := v_1
7514                 if !(!shiftIsBounded(v)) {
7515                         break
7516                 }
7517                 v.reset(OpRISCV64SRA)
7518                 v.Type = t
7519                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7520                 v0.AddArg(x)
7521                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7522                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7523                 v2.AuxInt = int64ToAuxInt(-1)
7524                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7525                 v3.AuxInt = int64ToAuxInt(64)
7526                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
7527                 v4.AddArg(y)
7528                 v3.AddArg(v4)
7529                 v2.AddArg(v3)
7530                 v1.AddArg2(y, v2)
7531                 v.AddArg2(v0, v1)
7532                 return true
7533         }
7534         // match: (Rsh8x16 x y)
7535         // cond: shiftIsBounded(v)
7536         // result: (SRA (SignExt8to64 x) y)
7537         for {
7538                 x := v_0
7539                 y := v_1
7540                 if !(shiftIsBounded(v)) {
7541                         break
7542                 }
7543                 v.reset(OpRISCV64SRA)
7544                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7545                 v0.AddArg(x)
7546                 v.AddArg2(v0, y)
7547                 return true
7548         }
7549         return false
7550 }
7551 func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
7552         v_1 := v.Args[1]
7553         v_0 := v.Args[0]
7554         b := v.Block
7555         typ := &b.Func.Config.Types
7556         // match: (Rsh8x32 <t> x y)
7557         // cond: !shiftIsBounded(v)
7558         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
7559         for {
7560                 t := v.Type
7561                 x := v_0
7562                 y := v_1
7563                 if !(!shiftIsBounded(v)) {
7564                         break
7565                 }
7566                 v.reset(OpRISCV64SRA)
7567                 v.Type = t
7568                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7569                 v0.AddArg(x)
7570                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7571                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7572                 v2.AuxInt = int64ToAuxInt(-1)
7573                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7574                 v3.AuxInt = int64ToAuxInt(64)
7575                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
7576                 v4.AddArg(y)
7577                 v3.AddArg(v4)
7578                 v2.AddArg(v3)
7579                 v1.AddArg2(y, v2)
7580                 v.AddArg2(v0, v1)
7581                 return true
7582         }
7583         // match: (Rsh8x32 x y)
7584         // cond: shiftIsBounded(v)
7585         // result: (SRA (SignExt8to64 x) y)
7586         for {
7587                 x := v_0
7588                 y := v_1
7589                 if !(shiftIsBounded(v)) {
7590                         break
7591                 }
7592                 v.reset(OpRISCV64SRA)
7593                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7594                 v0.AddArg(x)
7595                 v.AddArg2(v0, y)
7596                 return true
7597         }
7598         return false
7599 }
7600 func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
7601         v_1 := v.Args[1]
7602         v_0 := v.Args[0]
7603         b := v.Block
7604         typ := &b.Func.Config.Types
7605         // match: (Rsh8x64 <t> x y)
7606         // cond: !shiftIsBounded(v)
7607         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
7608         for {
7609                 t := v.Type
7610                 x := v_0
7611                 y := v_1
7612                 if !(!shiftIsBounded(v)) {
7613                         break
7614                 }
7615                 v.reset(OpRISCV64SRA)
7616                 v.Type = t
7617                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7618                 v0.AddArg(x)
7619                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7620                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7621                 v2.AuxInt = int64ToAuxInt(-1)
7622                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7623                 v3.AuxInt = int64ToAuxInt(64)
7624                 v3.AddArg(y)
7625                 v2.AddArg(v3)
7626                 v1.AddArg2(y, v2)
7627                 v.AddArg2(v0, v1)
7628                 return true
7629         }
7630         // match: (Rsh8x64 x y)
7631         // cond: shiftIsBounded(v)
7632         // result: (SRA (SignExt8to64 x) y)
7633         for {
7634                 x := v_0
7635                 y := v_1
7636                 if !(shiftIsBounded(v)) {
7637                         break
7638                 }
7639                 v.reset(OpRISCV64SRA)
7640                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7641                 v0.AddArg(x)
7642                 v.AddArg2(v0, y)
7643                 return true
7644         }
7645         return false
7646 }
7647 func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
7648         v_1 := v.Args[1]
7649         v_0 := v.Args[0]
7650         b := v.Block
7651         typ := &b.Func.Config.Types
7652         // match: (Rsh8x8 <t> x y)
7653         // cond: !shiftIsBounded(v)
7654         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
7655         for {
7656                 t := v.Type
7657                 x := v_0
7658                 y := v_1
7659                 if !(!shiftIsBounded(v)) {
7660                         break
7661                 }
7662                 v.reset(OpRISCV64SRA)
7663                 v.Type = t
7664                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7665                 v0.AddArg(x)
7666                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
7667                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
7668                 v2.AuxInt = int64ToAuxInt(-1)
7669                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
7670                 v3.AuxInt = int64ToAuxInt(64)
7671                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
7672                 v4.AddArg(y)
7673                 v3.AddArg(v4)
7674                 v2.AddArg(v3)
7675                 v1.AddArg2(y, v2)
7676                 v.AddArg2(v0, v1)
7677                 return true
7678         }
7679         // match: (Rsh8x8 x y)
7680         // cond: shiftIsBounded(v)
7681         // result: (SRA (SignExt8to64 x) y)
7682         for {
7683                 x := v_0
7684                 y := v_1
7685                 if !(shiftIsBounded(v)) {
7686                         break
7687                 }
7688                 v.reset(OpRISCV64SRA)
7689                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
7690                 v0.AddArg(x)
7691                 v.AddArg2(v0, y)
7692                 return true
7693         }
7694         return false
7695 }
7696 func rewriteValueRISCV64_OpSelect0(v *Value) bool {
7697         v_0 := v.Args[0]
7698         b := v.Block
7699         typ := &b.Func.Config.Types
7700         // match: (Select0 (Add64carry x y c))
7701         // result: (ADD (ADD <typ.UInt64> x y) c)
7702         for {
7703                 if v_0.Op != OpAdd64carry {
7704                         break
7705                 }
7706                 c := v_0.Args[2]
7707                 x := v_0.Args[0]
7708                 y := v_0.Args[1]
7709                 v.reset(OpRISCV64ADD)
7710                 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
7711                 v0.AddArg2(x, y)
7712                 v.AddArg2(v0, c)
7713                 return true
7714         }
7715         // match: (Select0 (Sub64borrow x y c))
7716         // result: (SUB (SUB <typ.UInt64> x y) c)
7717         for {
7718                 if v_0.Op != OpSub64borrow {
7719                         break
7720                 }
7721                 c := v_0.Args[2]
7722                 x := v_0.Args[0]
7723                 y := v_0.Args[1]
7724                 v.reset(OpRISCV64SUB)
7725                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
7726                 v0.AddArg2(x, y)
7727                 v.AddArg2(v0, c)
7728                 return true
7729         }
7730         // match: (Select0 m:(LoweredMuluhilo x y))
7731         // cond: m.Uses == 1
7732         // result: (MULHU x y)
7733         for {
7734                 m := v_0
7735                 if m.Op != OpRISCV64LoweredMuluhilo {
7736                         break
7737                 }
7738                 y := m.Args[1]
7739                 x := m.Args[0]
7740                 if !(m.Uses == 1) {
7741                         break
7742                 }
7743                 v.reset(OpRISCV64MULHU)
7744                 v.AddArg2(x, y)
7745                 return true
7746         }
7747         return false
7748 }
7749 func rewriteValueRISCV64_OpSelect1(v *Value) bool {
7750         v_0 := v.Args[0]
7751         b := v.Block
7752         typ := &b.Func.Config.Types
7753         // match: (Select1 (Add64carry x y c))
7754         // result: (OR (SLTU <typ.UInt64> s:(ADD <typ.UInt64> x y) x) (SLTU <typ.UInt64> (ADD <typ.UInt64> s c) s))
7755         for {
7756                 if v_0.Op != OpAdd64carry {
7757                         break
7758                 }
7759                 c := v_0.Args[2]
7760                 x := v_0.Args[0]
7761                 y := v_0.Args[1]
7762                 v.reset(OpRISCV64OR)
7763                 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
7764                 s := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
7765                 s.AddArg2(x, y)
7766                 v0.AddArg2(s, x)
7767                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
7768                 v3 := b.NewValue0(v.Pos, OpRISCV64ADD, typ.UInt64)
7769                 v3.AddArg2(s, c)
7770                 v2.AddArg2(v3, s)
7771                 v.AddArg2(v0, v2)
7772                 return true
7773         }
7774         // match: (Select1 (Sub64borrow x y c))
7775         // result: (OR (SLTU <typ.UInt64> x s:(SUB <typ.UInt64> x y)) (SLTU <typ.UInt64> s (SUB <typ.UInt64> s c)))
7776         for {
7777                 if v_0.Op != OpSub64borrow {
7778                         break
7779                 }
7780                 c := v_0.Args[2]
7781                 x := v_0.Args[0]
7782                 y := v_0.Args[1]
7783                 v.reset(OpRISCV64OR)
7784                 v0 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
7785                 s := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
7786                 s.AddArg2(x, y)
7787                 v0.AddArg2(x, s)
7788                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTU, typ.UInt64)
7789                 v3 := b.NewValue0(v.Pos, OpRISCV64SUB, typ.UInt64)
7790                 v3.AddArg2(s, c)
7791                 v2.AddArg2(s, v3)
7792                 v.AddArg2(v0, v2)
7793                 return true
7794         }
7795         // match: (Select1 m:(LoweredMuluhilo x y))
7796         // cond: m.Uses == 1
7797         // result: (MUL x y)
7798         for {
7799                 m := v_0
7800                 if m.Op != OpRISCV64LoweredMuluhilo {
7801                         break
7802                 }
7803                 y := m.Args[1]
7804                 x := m.Args[0]
7805                 if !(m.Uses == 1) {
7806                         break
7807                 }
7808                 v.reset(OpRISCV64MUL)
7809                 v.AddArg2(x, y)
7810                 return true
7811         }
7812         return false
7813 }
7814 func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
7815         v_0 := v.Args[0]
7816         b := v.Block
7817         // match: (Slicemask <t> x)
7818         // result: (SRAI [63] (NEG <t> x))
7819         for {
7820                 t := v.Type
7821                 x := v_0
7822                 v.reset(OpRISCV64SRAI)
7823                 v.AuxInt = int64ToAuxInt(63)
7824                 v0 := b.NewValue0(v.Pos, OpRISCV64NEG, t)
7825                 v0.AddArg(x)
7826                 v.AddArg(v0)
7827                 return true
7828         }
7829 }
7830 func rewriteValueRISCV64_OpStore(v *Value) bool {
7831         v_2 := v.Args[2]
7832         v_1 := v.Args[1]
7833         v_0 := v.Args[0]
7834         // match: (Store {t} ptr val mem)
7835         // cond: t.Size() == 1
7836         // result: (MOVBstore ptr val mem)
7837         for {
7838                 t := auxToType(v.Aux)
7839                 ptr := v_0
7840                 val := v_1
7841                 mem := v_2
7842                 if !(t.Size() == 1) {
7843                         break
7844                 }
7845                 v.reset(OpRISCV64MOVBstore)
7846                 v.AddArg3(ptr, val, mem)
7847                 return true
7848         }
7849         // match: (Store {t} ptr val mem)
7850         // cond: t.Size() == 2
7851         // result: (MOVHstore ptr val mem)
7852         for {
7853                 t := auxToType(v.Aux)
7854                 ptr := v_0
7855                 val := v_1
7856                 mem := v_2
7857                 if !(t.Size() == 2) {
7858                         break
7859                 }
7860                 v.reset(OpRISCV64MOVHstore)
7861                 v.AddArg3(ptr, val, mem)
7862                 return true
7863         }
7864         // match: (Store {t} ptr val mem)
7865         // cond: t.Size() == 4 && !t.IsFloat()
7866         // result: (MOVWstore ptr val mem)
7867         for {
7868                 t := auxToType(v.Aux)
7869                 ptr := v_0
7870                 val := v_1
7871                 mem := v_2
7872                 if !(t.Size() == 4 && !t.IsFloat()) {
7873                         break
7874                 }
7875                 v.reset(OpRISCV64MOVWstore)
7876                 v.AddArg3(ptr, val, mem)
7877                 return true
7878         }
7879         // match: (Store {t} ptr val mem)
7880         // cond: t.Size() == 8 && !t.IsFloat()
7881         // result: (MOVDstore ptr val mem)
7882         for {
7883                 t := auxToType(v.Aux)
7884                 ptr := v_0
7885                 val := v_1
7886                 mem := v_2
7887                 if !(t.Size() == 8 && !t.IsFloat()) {
7888                         break
7889                 }
7890                 v.reset(OpRISCV64MOVDstore)
7891                 v.AddArg3(ptr, val, mem)
7892                 return true
7893         }
7894         // match: (Store {t} ptr val mem)
7895         // cond: t.Size() == 4 && t.IsFloat()
7896         // result: (FMOVWstore ptr val mem)
7897         for {
7898                 t := auxToType(v.Aux)
7899                 ptr := v_0
7900                 val := v_1
7901                 mem := v_2
7902                 if !(t.Size() == 4 && t.IsFloat()) {
7903                         break
7904                 }
7905                 v.reset(OpRISCV64FMOVWstore)
7906                 v.AddArg3(ptr, val, mem)
7907                 return true
7908         }
7909         // match: (Store {t} ptr val mem)
7910         // cond: t.Size() == 8 && t.IsFloat()
7911         // result: (FMOVDstore ptr val mem)
7912         for {
7913                 t := auxToType(v.Aux)
7914                 ptr := v_0
7915                 val := v_1
7916                 mem := v_2
7917                 if !(t.Size() == 8 && t.IsFloat()) {
7918                         break
7919                 }
7920                 v.reset(OpRISCV64FMOVDstore)
7921                 v.AddArg3(ptr, val, mem)
7922                 return true
7923         }
7924         return false
7925 }
7926 func rewriteValueRISCV64_OpZero(v *Value) bool {
7927         v_1 := v.Args[1]
7928         v_0 := v.Args[0]
7929         b := v.Block
7930         config := b.Func.Config
7931         typ := &b.Func.Config.Types
7932         // match: (Zero [0] _ mem)
7933         // result: mem
7934         for {
7935                 if auxIntToInt64(v.AuxInt) != 0 {
7936                         break
7937                 }
7938                 mem := v_1
7939                 v.copyOf(mem)
7940                 return true
7941         }
7942         // match: (Zero [1] ptr mem)
7943         // result: (MOVBstore ptr (MOVDconst [0]) mem)
7944         for {
7945                 if auxIntToInt64(v.AuxInt) != 1 {
7946                         break
7947                 }
7948                 ptr := v_0
7949                 mem := v_1
7950                 v.reset(OpRISCV64MOVBstore)
7951                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7952                 v0.AuxInt = int64ToAuxInt(0)
7953                 v.AddArg3(ptr, v0, mem)
7954                 return true
7955         }
7956         // match: (Zero [2] {t} ptr mem)
7957         // cond: t.Alignment()%2 == 0
7958         // result: (MOVHstore ptr (MOVDconst [0]) mem)
7959         for {
7960                 if auxIntToInt64(v.AuxInt) != 2 {
7961                         break
7962                 }
7963                 t := auxToType(v.Aux)
7964                 ptr := v_0
7965                 mem := v_1
7966                 if !(t.Alignment()%2 == 0) {
7967                         break
7968                 }
7969                 v.reset(OpRISCV64MOVHstore)
7970                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7971                 v0.AuxInt = int64ToAuxInt(0)
7972                 v.AddArg3(ptr, v0, mem)
7973                 return true
7974         }
7975         // match: (Zero [2] ptr mem)
7976         // result: (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))
7977         for {
7978                 if auxIntToInt64(v.AuxInt) != 2 {
7979                         break
7980                 }
7981                 ptr := v_0
7982                 mem := v_1
7983                 v.reset(OpRISCV64MOVBstore)
7984                 v.AuxInt = int32ToAuxInt(1)
7985                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
7986                 v0.AuxInt = int64ToAuxInt(0)
7987                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
7988                 v1.AddArg3(ptr, v0, mem)
7989                 v.AddArg3(ptr, v0, v1)
7990                 return true
7991         }
7992         // match: (Zero [4] {t} ptr mem)
7993         // cond: t.Alignment()%4 == 0
7994         // result: (MOVWstore ptr (MOVDconst [0]) mem)
7995         for {
7996                 if auxIntToInt64(v.AuxInt) != 4 {
7997                         break
7998                 }
7999                 t := auxToType(v.Aux)
8000                 ptr := v_0
8001                 mem := v_1
8002                 if !(t.Alignment()%4 == 0) {
8003                         break
8004                 }
8005                 v.reset(OpRISCV64MOVWstore)
8006                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8007                 v0.AuxInt = int64ToAuxInt(0)
8008                 v.AddArg3(ptr, v0, mem)
8009                 return true
8010         }
8011         // match: (Zero [4] {t} ptr mem)
8012         // cond: t.Alignment()%2 == 0
8013         // result: (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))
8014         for {
8015                 if auxIntToInt64(v.AuxInt) != 4 {
8016                         break
8017                 }
8018                 t := auxToType(v.Aux)
8019                 ptr := v_0
8020                 mem := v_1
8021                 if !(t.Alignment()%2 == 0) {
8022                         break
8023                 }
8024                 v.reset(OpRISCV64MOVHstore)
8025                 v.AuxInt = int32ToAuxInt(2)
8026                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8027                 v0.AuxInt = int64ToAuxInt(0)
8028                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
8029                 v1.AddArg3(ptr, v0, mem)
8030                 v.AddArg3(ptr, v0, v1)
8031                 return true
8032         }
8033         // match: (Zero [4] ptr mem)
8034         // result: (MOVBstore [3] ptr (MOVDconst [0]) (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))))
8035         for {
8036                 if auxIntToInt64(v.AuxInt) != 4 {
8037                         break
8038                 }
8039                 ptr := v_0
8040                 mem := v_1
8041                 v.reset(OpRISCV64MOVBstore)
8042                 v.AuxInt = int32ToAuxInt(3)
8043                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8044                 v0.AuxInt = int64ToAuxInt(0)
8045                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
8046                 v1.AuxInt = int32ToAuxInt(2)
8047                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
8048                 v2.AuxInt = int32ToAuxInt(1)
8049                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
8050                 v3.AddArg3(ptr, v0, mem)
8051                 v2.AddArg3(ptr, v0, v3)
8052                 v1.AddArg3(ptr, v0, v2)
8053                 v.AddArg3(ptr, v0, v1)
8054                 return true
8055         }
8056         // match: (Zero [8] {t} ptr mem)
8057         // cond: t.Alignment()%8 == 0
8058         // result: (MOVDstore ptr (MOVDconst [0]) mem)
8059         for {
8060                 if auxIntToInt64(v.AuxInt) != 8 {
8061                         break
8062                 }
8063                 t := auxToType(v.Aux)
8064                 ptr := v_0
8065                 mem := v_1
8066                 if !(t.Alignment()%8 == 0) {
8067                         break
8068                 }
8069                 v.reset(OpRISCV64MOVDstore)
8070                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8071                 v0.AuxInt = int64ToAuxInt(0)
8072                 v.AddArg3(ptr, v0, mem)
8073                 return true
8074         }
8075         // match: (Zero [8] {t} ptr mem)
8076         // cond: t.Alignment()%4 == 0
8077         // result: (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem))
8078         for {
8079                 if auxIntToInt64(v.AuxInt) != 8 {
8080                         break
8081                 }
8082                 t := auxToType(v.Aux)
8083                 ptr := v_0
8084                 mem := v_1
8085                 if !(t.Alignment()%4 == 0) {
8086                         break
8087                 }
8088                 v.reset(OpRISCV64MOVWstore)
8089                 v.AuxInt = int32ToAuxInt(4)
8090                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8091                 v0.AuxInt = int64ToAuxInt(0)
8092                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
8093                 v1.AddArg3(ptr, v0, mem)
8094                 v.AddArg3(ptr, v0, v1)
8095                 return true
8096         }
8097         // match: (Zero [8] {t} ptr mem)
8098         // cond: t.Alignment()%2 == 0
8099         // result: (MOVHstore [6] ptr (MOVDconst [0]) (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))))
8100         for {
8101                 if auxIntToInt64(v.AuxInt) != 8 {
8102                         break
8103                 }
8104                 t := auxToType(v.Aux)
8105                 ptr := v_0
8106                 mem := v_1
8107                 if !(t.Alignment()%2 == 0) {
8108                         break
8109                 }
8110                 v.reset(OpRISCV64MOVHstore)
8111                 v.AuxInt = int32ToAuxInt(6)
8112                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8113                 v0.AuxInt = int64ToAuxInt(0)
8114                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
8115                 v1.AuxInt = int32ToAuxInt(4)
8116                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
8117                 v2.AuxInt = int32ToAuxInt(2)
8118                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
8119                 v3.AddArg3(ptr, v0, mem)
8120                 v2.AddArg3(ptr, v0, v3)
8121                 v1.AddArg3(ptr, v0, v2)
8122                 v.AddArg3(ptr, v0, v1)
8123                 return true
8124         }
8125         // match: (Zero [3] ptr mem)
8126         // result: (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem)))
8127         for {
8128                 if auxIntToInt64(v.AuxInt) != 3 {
8129                         break
8130                 }
8131                 ptr := v_0
8132                 mem := v_1
8133                 v.reset(OpRISCV64MOVBstore)
8134                 v.AuxInt = int32ToAuxInt(2)
8135                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8136                 v0.AuxInt = int64ToAuxInt(0)
8137                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
8138                 v1.AuxInt = int32ToAuxInt(1)
8139                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
8140                 v2.AddArg3(ptr, v0, mem)
8141                 v1.AddArg3(ptr, v0, v2)
8142                 v.AddArg3(ptr, v0, v1)
8143                 return true
8144         }
8145         // match: (Zero [6] {t} ptr mem)
8146         // cond: t.Alignment()%2 == 0
8147         // result: (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem)))
8148         for {
8149                 if auxIntToInt64(v.AuxInt) != 6 {
8150                         break
8151                 }
8152                 t := auxToType(v.Aux)
8153                 ptr := v_0
8154                 mem := v_1
8155                 if !(t.Alignment()%2 == 0) {
8156                         break
8157                 }
8158                 v.reset(OpRISCV64MOVHstore)
8159                 v.AuxInt = int32ToAuxInt(4)
8160                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8161                 v0.AuxInt = int64ToAuxInt(0)
8162                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
8163                 v1.AuxInt = int32ToAuxInt(2)
8164                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
8165                 v2.AddArg3(ptr, v0, mem)
8166                 v1.AddArg3(ptr, v0, v2)
8167                 v.AddArg3(ptr, v0, v1)
8168                 return true
8169         }
8170         // match: (Zero [12] {t} ptr mem)
8171         // cond: t.Alignment()%4 == 0
8172         // result: (MOVWstore [8] ptr (MOVDconst [0]) (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem)))
8173         for {
8174                 if auxIntToInt64(v.AuxInt) != 12 {
8175                         break
8176                 }
8177                 t := auxToType(v.Aux)
8178                 ptr := v_0
8179                 mem := v_1
8180                 if !(t.Alignment()%4 == 0) {
8181                         break
8182                 }
8183                 v.reset(OpRISCV64MOVWstore)
8184                 v.AuxInt = int32ToAuxInt(8)
8185                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8186                 v0.AuxInt = int64ToAuxInt(0)
8187                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
8188                 v1.AuxInt = int32ToAuxInt(4)
8189                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
8190                 v2.AddArg3(ptr, v0, mem)
8191                 v1.AddArg3(ptr, v0, v2)
8192                 v.AddArg3(ptr, v0, v1)
8193                 return true
8194         }
8195         // match: (Zero [16] {t} ptr mem)
8196         // cond: t.Alignment()%8 == 0
8197         // result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
8198         for {
8199                 if auxIntToInt64(v.AuxInt) != 16 {
8200                         break
8201                 }
8202                 t := auxToType(v.Aux)
8203                 ptr := v_0
8204                 mem := v_1
8205                 if !(t.Alignment()%8 == 0) {
8206                         break
8207                 }
8208                 v.reset(OpRISCV64MOVDstore)
8209                 v.AuxInt = int32ToAuxInt(8)
8210                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8211                 v0.AuxInt = int64ToAuxInt(0)
8212                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
8213                 v1.AddArg3(ptr, v0, mem)
8214                 v.AddArg3(ptr, v0, v1)
8215                 return true
8216         }
8217         // match: (Zero [24] {t} ptr mem)
8218         // cond: t.Alignment()%8 == 0
8219         // result: (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem)))
8220         for {
8221                 if auxIntToInt64(v.AuxInt) != 24 {
8222                         break
8223                 }
8224                 t := auxToType(v.Aux)
8225                 ptr := v_0
8226                 mem := v_1
8227                 if !(t.Alignment()%8 == 0) {
8228                         break
8229                 }
8230                 v.reset(OpRISCV64MOVDstore)
8231                 v.AuxInt = int32ToAuxInt(16)
8232                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8233                 v0.AuxInt = int64ToAuxInt(0)
8234                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
8235                 v1.AuxInt = int32ToAuxInt(8)
8236                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
8237                 v2.AddArg3(ptr, v0, mem)
8238                 v1.AddArg3(ptr, v0, v2)
8239                 v.AddArg3(ptr, v0, v1)
8240                 return true
8241         }
8242         // match: (Zero [32] {t} ptr mem)
8243         // cond: t.Alignment()%8 == 0
8244         // result: (MOVDstore [24] ptr (MOVDconst [0]) (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))))
8245         for {
8246                 if auxIntToInt64(v.AuxInt) != 32 {
8247                         break
8248                 }
8249                 t := auxToType(v.Aux)
8250                 ptr := v_0
8251                 mem := v_1
8252                 if !(t.Alignment()%8 == 0) {
8253                         break
8254                 }
8255                 v.reset(OpRISCV64MOVDstore)
8256                 v.AuxInt = int32ToAuxInt(24)
8257                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8258                 v0.AuxInt = int64ToAuxInt(0)
8259                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
8260                 v1.AuxInt = int32ToAuxInt(16)
8261                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
8262                 v2.AuxInt = int32ToAuxInt(8)
8263                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
8264                 v3.AddArg3(ptr, v0, mem)
8265                 v2.AddArg3(ptr, v0, v3)
8266                 v1.AddArg3(ptr, v0, v2)
8267                 v.AddArg3(ptr, v0, v1)
8268                 return true
8269         }
8270         // match: (Zero [s] {t} ptr mem)
8271         // cond: s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice
8272         // result: (DUFFZERO [8 * (128 - s/8)] ptr mem)
8273         for {
8274                 s := auxIntToInt64(v.AuxInt)
8275                 t := auxToType(v.Aux)
8276                 ptr := v_0
8277                 mem := v_1
8278                 if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice) {
8279                         break
8280                 }
8281                 v.reset(OpRISCV64DUFFZERO)
8282                 v.AuxInt = int64ToAuxInt(8 * (128 - s/8))
8283                 v.AddArg2(ptr, mem)
8284                 return true
8285         }
8286         // match: (Zero [s] {t} ptr mem)
8287         // result: (LoweredZero [t.Alignment()] ptr (ADD <ptr.Type> ptr (MOVDconst [s-moveSize(t.Alignment(), config)])) mem)
8288         for {
8289                 s := auxIntToInt64(v.AuxInt)
8290                 t := auxToType(v.Aux)
8291                 ptr := v_0
8292                 mem := v_1
8293                 v.reset(OpRISCV64LoweredZero)
8294                 v.AuxInt = int64ToAuxInt(t.Alignment())
8295                 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, ptr.Type)
8296                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
8297                 v1.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
8298                 v0.AddArg2(ptr, v1)
8299                 v.AddArg3(ptr, v0, mem)
8300                 return true
8301         }
8302 }
8303 func rewriteBlockRISCV64(b *Block) bool {
8304         typ := &b.Func.Config.Types
8305         switch b.Kind {
8306         case BlockRISCV64BEQ:
8307                 // match: (BEQ (MOVDconst [0]) cond yes no)
8308                 // result: (BEQZ cond yes no)
8309                 for b.Controls[0].Op == OpRISCV64MOVDconst {
8310                         v_0 := b.Controls[0]
8311                         if auxIntToInt64(v_0.AuxInt) != 0 {
8312                                 break
8313                         }
8314                         cond := b.Controls[1]
8315                         b.resetWithControl(BlockRISCV64BEQZ, cond)
8316                         return true
8317                 }
8318                 // match: (BEQ cond (MOVDconst [0]) yes no)
8319                 // result: (BEQZ cond yes no)
8320                 for b.Controls[1].Op == OpRISCV64MOVDconst {
8321                         cond := b.Controls[0]
8322                         v_1 := b.Controls[1]
8323                         if auxIntToInt64(v_1.AuxInt) != 0 {
8324                                 break
8325                         }
8326                         b.resetWithControl(BlockRISCV64BEQZ, cond)
8327                         return true
8328                 }
8329         case BlockRISCV64BEQZ:
8330                 // match: (BEQZ (SEQZ x) yes no)
8331                 // result: (BNEZ x yes no)
8332                 for b.Controls[0].Op == OpRISCV64SEQZ {
8333                         v_0 := b.Controls[0]
8334                         x := v_0.Args[0]
8335                         b.resetWithControl(BlockRISCV64BNEZ, x)
8336                         return true
8337                 }
8338                 // match: (BEQZ (SNEZ x) yes no)
8339                 // result: (BEQZ x yes no)
8340                 for b.Controls[0].Op == OpRISCV64SNEZ {
8341                         v_0 := b.Controls[0]
8342                         x := v_0.Args[0]
8343                         b.resetWithControl(BlockRISCV64BEQZ, x)
8344                         return true
8345                 }
8346                 // match: (BEQZ (NEG x) yes no)
8347                 // result: (BEQZ x yes no)
8348                 for b.Controls[0].Op == OpRISCV64NEG {
8349                         v_0 := b.Controls[0]
8350                         x := v_0.Args[0]
8351                         b.resetWithControl(BlockRISCV64BEQZ, x)
8352                         return true
8353                 }
8354                 // match: (BEQZ (FNES <t> x y) yes no)
8355                 // result: (BNEZ (FEQS <t> x y) yes no)
8356                 for b.Controls[0].Op == OpRISCV64FNES {
8357                         v_0 := b.Controls[0]
8358                         t := v_0.Type
8359                         _ = v_0.Args[1]
8360                         v_0_0 := v_0.Args[0]
8361                         v_0_1 := v_0.Args[1]
8362                         for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
8363                                 x := v_0_0
8364                                 y := v_0_1
8365                                 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
8366                                 v0.AddArg2(x, y)
8367                                 b.resetWithControl(BlockRISCV64BNEZ, v0)
8368                                 return true
8369                         }
8370                 }
8371                 // match: (BEQZ (FNED <t> x y) yes no)
8372                 // result: (BNEZ (FEQD <t> x y) yes no)
8373                 for b.Controls[0].Op == OpRISCV64FNED {
8374                         v_0 := b.Controls[0]
8375                         t := v_0.Type
8376                         _ = v_0.Args[1]
8377                         v_0_0 := v_0.Args[0]
8378                         v_0_1 := v_0.Args[1]
8379                         for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
8380                                 x := v_0_0
8381                                 y := v_0_1
8382                                 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
8383                                 v0.AddArg2(x, y)
8384                                 b.resetWithControl(BlockRISCV64BNEZ, v0)
8385                                 return true
8386                         }
8387                 }
8388                 // match: (BEQZ (SUB x y) yes no)
8389                 // result: (BEQ x y yes no)
8390                 for b.Controls[0].Op == OpRISCV64SUB {
8391                         v_0 := b.Controls[0]
8392                         y := v_0.Args[1]
8393                         x := v_0.Args[0]
8394                         b.resetWithControl2(BlockRISCV64BEQ, x, y)
8395                         return true
8396                 }
8397                 // match: (BEQZ (SLT x y) yes no)
8398                 // result: (BGE x y yes no)
8399                 for b.Controls[0].Op == OpRISCV64SLT {
8400                         v_0 := b.Controls[0]
8401                         y := v_0.Args[1]
8402                         x := v_0.Args[0]
8403                         b.resetWithControl2(BlockRISCV64BGE, x, y)
8404                         return true
8405                 }
8406                 // match: (BEQZ (SLTU x y) yes no)
8407                 // result: (BGEU x y yes no)
8408                 for b.Controls[0].Op == OpRISCV64SLTU {
8409                         v_0 := b.Controls[0]
8410                         y := v_0.Args[1]
8411                         x := v_0.Args[0]
8412                         b.resetWithControl2(BlockRISCV64BGEU, x, y)
8413                         return true
8414                 }
8415                 // match: (BEQZ (SLTI [x] y) yes no)
8416                 // result: (BGE y (MOVDconst [x]) yes no)
8417                 for b.Controls[0].Op == OpRISCV64SLTI {
8418                         v_0 := b.Controls[0]
8419                         x := auxIntToInt64(v_0.AuxInt)
8420                         y := v_0.Args[0]
8421                         v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
8422                         v0.AuxInt = int64ToAuxInt(x)
8423                         b.resetWithControl2(BlockRISCV64BGE, y, v0)
8424                         return true
8425                 }
8426                 // match: (BEQZ (SLTIU [x] y) yes no)
8427                 // result: (BGEU y (MOVDconst [x]) yes no)
8428                 for b.Controls[0].Op == OpRISCV64SLTIU {
8429                         v_0 := b.Controls[0]
8430                         x := auxIntToInt64(v_0.AuxInt)
8431                         y := v_0.Args[0]
8432                         v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
8433                         v0.AuxInt = int64ToAuxInt(x)
8434                         b.resetWithControl2(BlockRISCV64BGEU, y, v0)
8435                         return true
8436                 }
8437         case BlockRISCV64BGE:
8438                 // match: (BGE (MOVDconst [0]) cond yes no)
8439                 // result: (BLEZ cond yes no)
8440                 for b.Controls[0].Op == OpRISCV64MOVDconst {
8441                         v_0 := b.Controls[0]
8442                         if auxIntToInt64(v_0.AuxInt) != 0 {
8443                                 break
8444                         }
8445                         cond := b.Controls[1]
8446                         b.resetWithControl(BlockRISCV64BLEZ, cond)
8447                         return true
8448                 }
8449                 // match: (BGE cond (MOVDconst [0]) yes no)
8450                 // result: (BGEZ cond yes no)
8451                 for b.Controls[1].Op == OpRISCV64MOVDconst {
8452                         cond := b.Controls[0]
8453                         v_1 := b.Controls[1]
8454                         if auxIntToInt64(v_1.AuxInt) != 0 {
8455                                 break
8456                         }
8457                         b.resetWithControl(BlockRISCV64BGEZ, cond)
8458                         return true
8459                 }
8460         case BlockRISCV64BLT:
8461                 // match: (BLT (MOVDconst [0]) cond yes no)
8462                 // result: (BGTZ cond yes no)
8463                 for b.Controls[0].Op == OpRISCV64MOVDconst {
8464                         v_0 := b.Controls[0]
8465                         if auxIntToInt64(v_0.AuxInt) != 0 {
8466                                 break
8467                         }
8468                         cond := b.Controls[1]
8469                         b.resetWithControl(BlockRISCV64BGTZ, cond)
8470                         return true
8471                 }
8472                 // match: (BLT cond (MOVDconst [0]) yes no)
8473                 // result: (BLTZ cond yes no)
8474                 for b.Controls[1].Op == OpRISCV64MOVDconst {
8475                         cond := b.Controls[0]
8476                         v_1 := b.Controls[1]
8477                         if auxIntToInt64(v_1.AuxInt) != 0 {
8478                                 break
8479                         }
8480                         b.resetWithControl(BlockRISCV64BLTZ, cond)
8481                         return true
8482                 }
8483         case BlockRISCV64BNE:
8484                 // match: (BNE (MOVDconst [0]) cond yes no)
8485                 // result: (BNEZ cond yes no)
8486                 for b.Controls[0].Op == OpRISCV64MOVDconst {
8487                         v_0 := b.Controls[0]
8488                         if auxIntToInt64(v_0.AuxInt) != 0 {
8489                                 break
8490                         }
8491                         cond := b.Controls[1]
8492                         b.resetWithControl(BlockRISCV64BNEZ, cond)
8493                         return true
8494                 }
8495                 // match: (BNE cond (MOVDconst [0]) yes no)
8496                 // result: (BNEZ cond yes no)
8497                 for b.Controls[1].Op == OpRISCV64MOVDconst {
8498                         cond := b.Controls[0]
8499                         v_1 := b.Controls[1]
8500                         if auxIntToInt64(v_1.AuxInt) != 0 {
8501                                 break
8502                         }
8503                         b.resetWithControl(BlockRISCV64BNEZ, cond)
8504                         return true
8505                 }
8506         case BlockRISCV64BNEZ:
8507                 // match: (BNEZ (SEQZ x) yes no)
8508                 // result: (BEQZ x yes no)
8509                 for b.Controls[0].Op == OpRISCV64SEQZ {
8510                         v_0 := b.Controls[0]
8511                         x := v_0.Args[0]
8512                         b.resetWithControl(BlockRISCV64BEQZ, x)
8513                         return true
8514                 }
8515                 // match: (BNEZ (SNEZ x) yes no)
8516                 // result: (BNEZ x yes no)
8517                 for b.Controls[0].Op == OpRISCV64SNEZ {
8518                         v_0 := b.Controls[0]
8519                         x := v_0.Args[0]
8520                         b.resetWithControl(BlockRISCV64BNEZ, x)
8521                         return true
8522                 }
8523                 // match: (BNEZ (NEG x) yes no)
8524                 // result: (BNEZ x yes no)
8525                 for b.Controls[0].Op == OpRISCV64NEG {
8526                         v_0 := b.Controls[0]
8527                         x := v_0.Args[0]
8528                         b.resetWithControl(BlockRISCV64BNEZ, x)
8529                         return true
8530                 }
8531                 // match: (BNEZ (FNES <t> x y) yes no)
8532                 // result: (BEQZ (FEQS <t> x y) yes no)
8533                 for b.Controls[0].Op == OpRISCV64FNES {
8534                         v_0 := b.Controls[0]
8535                         t := v_0.Type
8536                         _ = v_0.Args[1]
8537                         v_0_0 := v_0.Args[0]
8538                         v_0_1 := v_0.Args[1]
8539                         for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
8540                                 x := v_0_0
8541                                 y := v_0_1
8542                                 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQS, t)
8543                                 v0.AddArg2(x, y)
8544                                 b.resetWithControl(BlockRISCV64BEQZ, v0)
8545                                 return true
8546                         }
8547                 }
8548                 // match: (BNEZ (FNED <t> x y) yes no)
8549                 // result: (BEQZ (FEQD <t> x y) yes no)
8550                 for b.Controls[0].Op == OpRISCV64FNED {
8551                         v_0 := b.Controls[0]
8552                         t := v_0.Type
8553                         _ = v_0.Args[1]
8554                         v_0_0 := v_0.Args[0]
8555                         v_0_1 := v_0.Args[1]
8556                         for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
8557                                 x := v_0_0
8558                                 y := v_0_1
8559                                 v0 := b.NewValue0(v_0.Pos, OpRISCV64FEQD, t)
8560                                 v0.AddArg2(x, y)
8561                                 b.resetWithControl(BlockRISCV64BEQZ, v0)
8562                                 return true
8563                         }
8564                 }
8565                 // match: (BNEZ (SUB x y) yes no)
8566                 // result: (BNE x y yes no)
8567                 for b.Controls[0].Op == OpRISCV64SUB {
8568                         v_0 := b.Controls[0]
8569                         y := v_0.Args[1]
8570                         x := v_0.Args[0]
8571                         b.resetWithControl2(BlockRISCV64BNE, x, y)
8572                         return true
8573                 }
8574                 // match: (BNEZ (SLT x y) yes no)
8575                 // result: (BLT x y yes no)
8576                 for b.Controls[0].Op == OpRISCV64SLT {
8577                         v_0 := b.Controls[0]
8578                         y := v_0.Args[1]
8579                         x := v_0.Args[0]
8580                         b.resetWithControl2(BlockRISCV64BLT, x, y)
8581                         return true
8582                 }
8583                 // match: (BNEZ (SLTU x y) yes no)
8584                 // result: (BLTU x y yes no)
8585                 for b.Controls[0].Op == OpRISCV64SLTU {
8586                         v_0 := b.Controls[0]
8587                         y := v_0.Args[1]
8588                         x := v_0.Args[0]
8589                         b.resetWithControl2(BlockRISCV64BLTU, x, y)
8590                         return true
8591                 }
8592                 // match: (BNEZ (SLTI [x] y) yes no)
8593                 // result: (BLT y (MOVDconst [x]) yes no)
8594                 for b.Controls[0].Op == OpRISCV64SLTI {
8595                         v_0 := b.Controls[0]
8596                         x := auxIntToInt64(v_0.AuxInt)
8597                         y := v_0.Args[0]
8598                         v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
8599                         v0.AuxInt = int64ToAuxInt(x)
8600                         b.resetWithControl2(BlockRISCV64BLT, y, v0)
8601                         return true
8602                 }
8603                 // match: (BNEZ (SLTIU [x] y) yes no)
8604                 // result: (BLTU y (MOVDconst [x]) yes no)
8605                 for b.Controls[0].Op == OpRISCV64SLTIU {
8606                         v_0 := b.Controls[0]
8607                         x := auxIntToInt64(v_0.AuxInt)
8608                         y := v_0.Args[0]
8609                         v0 := b.NewValue0(b.Pos, OpRISCV64MOVDconst, typ.UInt64)
8610                         v0.AuxInt = int64ToAuxInt(x)
8611                         b.resetWithControl2(BlockRISCV64BLTU, y, v0)
8612                         return true
8613                 }
8614         case BlockIf:
8615                 // match: (If cond yes no)
8616                 // result: (BNEZ (MOVBUreg <typ.UInt64> cond) yes no)
8617                 for {
8618                         cond := b.Controls[0]
8619                         v0 := b.NewValue0(cond.Pos, OpRISCV64MOVBUreg, typ.UInt64)
8620                         v0.AddArg(cond)
8621                         b.resetWithControl(BlockRISCV64BNEZ, v0)
8622                         return true
8623                 }
8624         }
8625         return false
8626 }