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