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

   1 // Code generated from gen/RISCV64.rules; DO NOT EDIT.
   2 // generated with: cd gen; go run *.go
   3
   4 package ssa
   5
   6 import "math"
   7 import "cmd/compile/internal/types"
   8
   9 func rewriteValueRISCV64(v *Value) bool {
  10         switch v.Op {
  11         case OpAdd16:
  12                 v.Op = OpRISCV64ADD
  13                 return true
  14         case OpAdd32:
  15                 v.Op = OpRISCV64ADD
  16                 return true
  17         case OpAdd32F:
  18                 v.Op = OpRISCV64FADDS
  19                 return true
  20         case OpAdd64:
  21                 v.Op = OpRISCV64ADD
  22                 return true
  23         case OpAdd64F:
  24                 v.Op = OpRISCV64FADDD
  25                 return true
  26         case OpAdd8:
  27                 v.Op = OpRISCV64ADD
  28                 return true
  29         case OpAddPtr:
  30                 v.Op = OpRISCV64ADD
  31                 return true
  32         case OpAddr:
  33                 return rewriteValueRISCV64_OpAddr(v)
  34         case OpAnd16:
  35                 v.Op = OpRISCV64AND
  36                 return true
  37         case OpAnd32:
  38                 v.Op = OpRISCV64AND
  39                 return true
  40         case OpAnd64:
  41                 v.Op = OpRISCV64AND
  42                 return true
  43         case OpAnd8:
  44                 v.Op = OpRISCV64AND
  45                 return true
  46         case OpAndB:
  47                 v.Op = OpRISCV64AND
  48                 return true
  49         case OpAtomicAdd32:
  50                 v.Op = OpRISCV64LoweredAtomicAdd32
  51                 return true
  52         case OpAtomicAdd64:
  53                 v.Op = OpRISCV64LoweredAtomicAdd64
  54                 return true
  55         case OpAtomicAnd32:
  56                 v.Op = OpRISCV64LoweredAtomicAnd32
  57                 return true
  58         case OpAtomicAnd8:
  59                 return rewriteValueRISCV64_OpAtomicAnd8(v)
  60         case OpAtomicCompareAndSwap32:
  61                 v.Op = OpRISCV64LoweredAtomicCas32
  62                 return true
  63         case OpAtomicCompareAndSwap64:
  64                 v.Op = OpRISCV64LoweredAtomicCas64
  65                 return true
  66         case OpAtomicExchange32:
  67                 v.Op = OpRISCV64LoweredAtomicExchange32
  68                 return true
  69         case OpAtomicExchange64:
  70                 v.Op = OpRISCV64LoweredAtomicExchange64
  71                 return true
  72         case OpAtomicLoad32:
  73                 v.Op = OpRISCV64LoweredAtomicLoad32
  74                 return true
  75         case OpAtomicLoad64:
  76                 v.Op = OpRISCV64LoweredAtomicLoad64
  77                 return true
  78         case OpAtomicLoad8:
  79                 v.Op = OpRISCV64LoweredAtomicLoad8
  80                 return true
  81         case OpAtomicLoadPtr:
  82                 v.Op = OpRISCV64LoweredAtomicLoad64
  83                 return true
  84         case OpAtomicOr32:
  85                 v.Op = OpRISCV64LoweredAtomicOr32
  86                 return true
  87         case OpAtomicOr8:
  88                 return rewriteValueRISCV64_OpAtomicOr8(v)
  89         case OpAtomicStore32:
  90                 v.Op = OpRISCV64LoweredAtomicStore32
  91                 return true
  92         case OpAtomicStore64:
  93                 v.Op = OpRISCV64LoweredAtomicStore64
  94                 return true
  95         case OpAtomicStore8:
  96                 v.Op = OpRISCV64LoweredAtomicStore8
  97                 return true
  98         case OpAtomicStorePtrNoWB:
  99                 v.Op = OpRISCV64LoweredAtomicStore64
 100                 return true
 101         case OpAvg64u:
 102                 return rewriteValueRISCV64_OpAvg64u(v)
 103         case OpClosureCall:
 104                 v.Op = OpRISCV64CALLclosure
 105                 return true
 106         case OpCom16:
 107                 v.Op = OpRISCV64NOT
 108                 return true
 109         case OpCom32:
 110                 v.Op = OpRISCV64NOT
 111                 return true
 112         case OpCom64:
 113                 v.Op = OpRISCV64NOT
 114                 return true
 115         case OpCom8:
 116                 v.Op = OpRISCV64NOT
 117                 return true
 118         case OpConst16:
 119                 return rewriteValueRISCV64_OpConst16(v)
 120         case OpConst32:
 121                 return rewriteValueRISCV64_OpConst32(v)
 122         case OpConst32F:
 123                 return rewriteValueRISCV64_OpConst32F(v)
 124         case OpConst64:
 125                 return rewriteValueRISCV64_OpConst64(v)
 126         case OpConst64F:
 127                 return rewriteValueRISCV64_OpConst64F(v)
 128         case OpConst8:
 129                 return rewriteValueRISCV64_OpConst8(v)
 130         case OpConstBool:
 131                 return rewriteValueRISCV64_OpConstBool(v)
 132         case OpConstNil:
 133                 return rewriteValueRISCV64_OpConstNil(v)
 134         case OpConvert:
 135                 v.Op = OpRISCV64MOVconvert
 136                 return true
 137         case OpCvt32Fto32:
 138                 v.Op = OpRISCV64FCVTWS
 139                 return true
 140         case OpCvt32Fto64:
 141                 v.Op = OpRISCV64FCVTLS
 142                 return true
 143         case OpCvt32Fto64F:
 144                 v.Op = OpRISCV64FCVTDS
 145                 return true
 146         case OpCvt32to32F:
 147                 v.Op = OpRISCV64FCVTSW
 148                 return true
 149         case OpCvt32to64F:
 150                 v.Op = OpRISCV64FCVTDW
 151                 return true
 152         case OpCvt64Fto32:
 153                 v.Op = OpRISCV64FCVTWD
 154                 return true
 155         case OpCvt64Fto32F:
 156                 v.Op = OpRISCV64FCVTSD
 157                 return true
 158         case OpCvt64Fto64:
 159                 v.Op = OpRISCV64FCVTLD
 160                 return true
 161         case OpCvt64to32F:
 162                 v.Op = OpRISCV64FCVTSL
 163                 return true
 164         case OpCvt64to64F:
 165                 v.Op = OpRISCV64FCVTDL
 166                 return true
 167         case OpCvtBoolToUint8:
 168                 v.Op = OpCopy
 169                 return true
 170         case OpDiv16:
 171                 return rewriteValueRISCV64_OpDiv16(v)
 172         case OpDiv16u:
 173                 return rewriteValueRISCV64_OpDiv16u(v)
 174         case OpDiv32:
 175                 return rewriteValueRISCV64_OpDiv32(v)
 176         case OpDiv32F:
 177                 v.Op = OpRISCV64FDIVS
 178                 return true
 179         case OpDiv32u:
 180                 v.Op = OpRISCV64DIVUW
 181                 return true
 182         case OpDiv64:
 183                 return rewriteValueRISCV64_OpDiv64(v)
 184         case OpDiv64F:
 185                 v.Op = OpRISCV64FDIVD
 186                 return true
 187         case OpDiv64u:
 188                 v.Op = OpRISCV64DIVU
 189                 return true
 190         case OpDiv8:
 191                 return rewriteValueRISCV64_OpDiv8(v)
 192         case OpDiv8u:
 193                 return rewriteValueRISCV64_OpDiv8u(v)
 194         case OpEq16:
 195                 return rewriteValueRISCV64_OpEq16(v)
 196         case OpEq32:
 197                 return rewriteValueRISCV64_OpEq32(v)
 198         case OpEq32F:
 199                 v.Op = OpRISCV64FEQS
 200                 return true
 201         case OpEq64:
 202                 return rewriteValueRISCV64_OpEq64(v)
 203         case OpEq64F:
 204                 v.Op = OpRISCV64FEQD
 205                 return true
 206         case OpEq8:
 207                 return rewriteValueRISCV64_OpEq8(v)
 208         case OpEqB:
 209                 return rewriteValueRISCV64_OpEqB(v)
 210         case OpEqPtr:
 211                 return rewriteValueRISCV64_OpEqPtr(v)
 212         case OpGetCallerPC:
 213                 v.Op = OpRISCV64LoweredGetCallerPC
 214                 return true
 215         case OpGetCallerSP:
 216                 v.Op = OpRISCV64LoweredGetCallerSP
 217                 return true
 218         case OpGetClosurePtr:
 219                 v.Op = OpRISCV64LoweredGetClosurePtr
 220                 return true
 221         case OpHmul32:
 222                 return rewriteValueRISCV64_OpHmul32(v)
 223         case OpHmul32u:
 224                 return rewriteValueRISCV64_OpHmul32u(v)
 225         case OpHmul64:
 226                 v.Op = OpRISCV64MULH
 227                 return true
 228         case OpHmul64u:
 229                 v.Op = OpRISCV64MULHU
 230                 return true
 231         case OpInterCall:
 232                 v.Op = OpRISCV64CALLinter
 233                 return true
 234         case OpIsInBounds:
 235                 v.Op = OpLess64U
 236                 return true
 237         case OpIsNonNil:
 238                 v.Op = OpRISCV64SNEZ
 239                 return true
 240         case OpIsSliceInBounds:
 241                 v.Op = OpLeq64U
 242                 return true
 243         case OpLeq16:
 244                 return rewriteValueRISCV64_OpLeq16(v)
 245         case OpLeq16U:
 246                 return rewriteValueRISCV64_OpLeq16U(v)
 247         case OpLeq32:
 248                 return rewriteValueRISCV64_OpLeq32(v)
 249         case OpLeq32F:
 250                 v.Op = OpRISCV64FLES
 251                 return true
 252         case OpLeq32U:
 253                 return rewriteValueRISCV64_OpLeq32U(v)
 254         case OpLeq64:
 255                 return rewriteValueRISCV64_OpLeq64(v)
 256         case OpLeq64F:
 257                 v.Op = OpRISCV64FLED
 258                 return true
 259         case OpLeq64U:
 260                 return rewriteValueRISCV64_OpLeq64U(v)
 261         case OpLeq8:
 262                 return rewriteValueRISCV64_OpLeq8(v)
 263         case OpLeq8U:
 264                 return rewriteValueRISCV64_OpLeq8U(v)
 265         case OpLess16:
 266                 return rewriteValueRISCV64_OpLess16(v)
 267         case OpLess16U:
 268                 return rewriteValueRISCV64_OpLess16U(v)
 269         case OpLess32:
 270                 return rewriteValueRISCV64_OpLess32(v)
 271         case OpLess32F:
 272                 v.Op = OpRISCV64FLTS
 273                 return true
 274         case OpLess32U:
 275                 return rewriteValueRISCV64_OpLess32U(v)
 276         case OpLess64:
 277                 v.Op = OpRISCV64SLT
 278                 return true
 279         case OpLess64F:
 280                 v.Op = OpRISCV64FLTD
 281                 return true
 282         case OpLess64U:
 283                 v.Op = OpRISCV64SLTU
 284                 return true
 285         case OpLess8:
 286                 return rewriteValueRISCV64_OpLess8(v)
 287         case OpLess8U:
 288                 return rewriteValueRISCV64_OpLess8U(v)
 289         case OpLoad:
 290                 return rewriteValueRISCV64_OpLoad(v)
 291         case OpLocalAddr:
 292                 return rewriteValueRISCV64_OpLocalAddr(v)
 293         case OpLsh16x16:
 294                 return rewriteValueRISCV64_OpLsh16x16(v)
 295         case OpLsh16x32:
 296                 return rewriteValueRISCV64_OpLsh16x32(v)
 297         case OpLsh16x64:
 298                 return rewriteValueRISCV64_OpLsh16x64(v)
 299         case OpLsh16x8:
 300                 return rewriteValueRISCV64_OpLsh16x8(v)
 301         case OpLsh32x16:
 302                 return rewriteValueRISCV64_OpLsh32x16(v)
 303         case OpLsh32x32:
 304                 return rewriteValueRISCV64_OpLsh32x32(v)
 305         case OpLsh32x64:
 306                 return rewriteValueRISCV64_OpLsh32x64(v)
 307         case OpLsh32x8:
 308                 return rewriteValueRISCV64_OpLsh32x8(v)
 309         case OpLsh64x16:
 310                 return rewriteValueRISCV64_OpLsh64x16(v)
 311         case OpLsh64x32:
 312                 return rewriteValueRISCV64_OpLsh64x32(v)
 313         case OpLsh64x64:
 314                 return rewriteValueRISCV64_OpLsh64x64(v)
 315         case OpLsh64x8:
 316                 return rewriteValueRISCV64_OpLsh64x8(v)
 317         case OpLsh8x16:
 318                 return rewriteValueRISCV64_OpLsh8x16(v)
 319         case OpLsh8x32:
 320                 return rewriteValueRISCV64_OpLsh8x32(v)
 321         case OpLsh8x64:
 322                 return rewriteValueRISCV64_OpLsh8x64(v)
 323         case OpLsh8x8:
 324                 return rewriteValueRISCV64_OpLsh8x8(v)
 325         case OpMod16:
 326                 return rewriteValueRISCV64_OpMod16(v)
 327         case OpMod16u:
 328                 return rewriteValueRISCV64_OpMod16u(v)
 329         case OpMod32:
 330                 return rewriteValueRISCV64_OpMod32(v)
 331         case OpMod32u:
 332                 v.Op = OpRISCV64REMUW
 333                 return true
 334         case OpMod64:
 335                 return rewriteValueRISCV64_OpMod64(v)
 336         case OpMod64u:
 337                 v.Op = OpRISCV64REMU
 338                 return true
 339         case OpMod8:
 340                 return rewriteValueRISCV64_OpMod8(v)
 341         case OpMod8u:
 342                 return rewriteValueRISCV64_OpMod8u(v)
 343         case OpMove:
 344                 return rewriteValueRISCV64_OpMove(v)
 345         case OpMul16:
 346                 return rewriteValueRISCV64_OpMul16(v)
 347         case OpMul32:
 348                 v.Op = OpRISCV64MULW
 349                 return true
 350         case OpMul32F:
 351                 v.Op = OpRISCV64FMULS
 352                 return true
 353         case OpMul64:
 354                 v.Op = OpRISCV64MUL
 355                 return true
 356         case OpMul64F:
 357                 v.Op = OpRISCV64FMULD
 358                 return true
 359         case OpMul8:
 360                 return rewriteValueRISCV64_OpMul8(v)
 361         case OpNeg16:
 362                 v.Op = OpRISCV64NEG
 363                 return true
 364         case OpNeg32:
 365                 v.Op = OpRISCV64NEG
 366                 return true
 367         case OpNeg32F:
 368                 v.Op = OpRISCV64FNEGS
 369                 return true
 370         case OpNeg64:
 371                 v.Op = OpRISCV64NEG
 372                 return true
 373         case OpNeg64F:
 374                 v.Op = OpRISCV64FNEGD
 375                 return true
 376         case OpNeg8:
 377                 v.Op = OpRISCV64NEG
 378                 return true
 379         case OpNeq16:
 380                 return rewriteValueRISCV64_OpNeq16(v)
 381         case OpNeq32:
 382                 return rewriteValueRISCV64_OpNeq32(v)
 383         case OpNeq32F:
 384                 v.Op = OpRISCV64FNES
 385                 return true
 386         case OpNeq64:
 387                 return rewriteValueRISCV64_OpNeq64(v)
 388         case OpNeq64F:
 389                 v.Op = OpRISCV64FNED
 390                 return true
 391         case OpNeq8:
 392                 return rewriteValueRISCV64_OpNeq8(v)
 393         case OpNeqB:
 394                 v.Op = OpRISCV64XOR
 395                 return true
 396         case OpNeqPtr:
 397                 return rewriteValueRISCV64_OpNeqPtr(v)
 398         case OpNilCheck:
 399                 v.Op = OpRISCV64LoweredNilCheck
 400                 return true
 401         case OpNot:
 402                 v.Op = OpRISCV64SEQZ
 403                 return true
 404         case OpOffPtr:
 405                 return rewriteValueRISCV64_OpOffPtr(v)
 406         case OpOr16:
 407                 v.Op = OpRISCV64OR
 408                 return true
 409         case OpOr32:
 410                 v.Op = OpRISCV64OR
 411                 return true
 412         case OpOr64:
 413                 v.Op = OpRISCV64OR
 414                 return true
 415         case OpOr8:
 416                 v.Op = OpRISCV64OR
 417                 return true
 418         case OpOrB:
 419                 v.Op = OpRISCV64OR
 420                 return true
 421         case OpPanicBounds:
 422                 return rewriteValueRISCV64_OpPanicBounds(v)
 423         case OpRISCV64ADD:
 424                 return rewriteValueRISCV64_OpRISCV64ADD(v)
 425         case OpRISCV64ADDI:
 426                 return rewriteValueRISCV64_OpRISCV64ADDI(v)
 427         case OpRISCV64AND:
 428                 return rewriteValueRISCV64_OpRISCV64AND(v)
 429         case OpRISCV64MOVBUload:
 430                 return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
 431         case OpRISCV64MOVBUreg:
 432                 return rewriteValueRISCV64_OpRISCV64MOVBUreg(v)
 433         case OpRISCV64MOVBload:
 434                 return rewriteValueRISCV64_OpRISCV64MOVBload(v)
 435         case OpRISCV64MOVBreg:
 436                 return rewriteValueRISCV64_OpRISCV64MOVBreg(v)
 437         case OpRISCV64MOVBstore:
 438                 return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
 439         case OpRISCV64MOVBstorezero:
 440                 return rewriteValueRISCV64_OpRISCV64MOVBstorezero(v)
 441         case OpRISCV64MOVDload:
 442                 return rewriteValueRISCV64_OpRISCV64MOVDload(v)
 443         case OpRISCV64MOVDnop:
 444                 return rewriteValueRISCV64_OpRISCV64MOVDnop(v)
 445         case OpRISCV64MOVDreg:
 446                 return rewriteValueRISCV64_OpRISCV64MOVDreg(v)
 447         case OpRISCV64MOVDstore:
 448                 return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
 449         case OpRISCV64MOVDstorezero:
 450                 return rewriteValueRISCV64_OpRISCV64MOVDstorezero(v)
 451         case OpRISCV64MOVHUload:
 452                 return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
 453         case OpRISCV64MOVHUreg:
 454                 return rewriteValueRISCV64_OpRISCV64MOVHUreg(v)
 455         case OpRISCV64MOVHload:
 456                 return rewriteValueRISCV64_OpRISCV64MOVHload(v)
 457         case OpRISCV64MOVHreg:
 458                 return rewriteValueRISCV64_OpRISCV64MOVHreg(v)
 459         case OpRISCV64MOVHstore:
 460                 return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
 461         case OpRISCV64MOVHstorezero:
 462                 return rewriteValueRISCV64_OpRISCV64MOVHstorezero(v)
 463         case OpRISCV64MOVWUload:
 464                 return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
 465         case OpRISCV64MOVWUreg:
 466                 return rewriteValueRISCV64_OpRISCV64MOVWUreg(v)
 467         case OpRISCV64MOVWload:
 468                 return rewriteValueRISCV64_OpRISCV64MOVWload(v)
 469         case OpRISCV64MOVWreg:
 470                 return rewriteValueRISCV64_OpRISCV64MOVWreg(v)
 471         case OpRISCV64MOVWstore:
 472                 return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
 473         case OpRISCV64MOVWstorezero:
 474                 return rewriteValueRISCV64_OpRISCV64MOVWstorezero(v)
 475         case OpRISCV64OR:
 476                 return rewriteValueRISCV64_OpRISCV64OR(v)
 477         case OpRISCV64SLL:
 478                 return rewriteValueRISCV64_OpRISCV64SLL(v)
 479         case OpRISCV64SRA:
 480                 return rewriteValueRISCV64_OpRISCV64SRA(v)
 481         case OpRISCV64SRL:
 482                 return rewriteValueRISCV64_OpRISCV64SRL(v)
 483         case OpRISCV64SUB:
 484                 return rewriteValueRISCV64_OpRISCV64SUB(v)
 485         case OpRISCV64SUBW:
 486                 return rewriteValueRISCV64_OpRISCV64SUBW(v)
 487         case OpRISCV64XOR:
 488                 return rewriteValueRISCV64_OpRISCV64XOR(v)
 489         case OpRotateLeft16:
 490                 return rewriteValueRISCV64_OpRotateLeft16(v)
 491         case OpRotateLeft32:
 492                 return rewriteValueRISCV64_OpRotateLeft32(v)
 493         case OpRotateLeft64:
 494                 return rewriteValueRISCV64_OpRotateLeft64(v)
 495         case OpRotateLeft8:
 496                 return rewriteValueRISCV64_OpRotateLeft8(v)
 497         case OpRound32F:
 498                 v.Op = OpCopy
 499                 return true
 500         case OpRound64F:
 501                 v.Op = OpCopy
 502                 return true
 503         case OpRsh16Ux16:
 504                 return rewriteValueRISCV64_OpRsh16Ux16(v)
 505         case OpRsh16Ux32:
 506                 return rewriteValueRISCV64_OpRsh16Ux32(v)
 507         case OpRsh16Ux64:
 508                 return rewriteValueRISCV64_OpRsh16Ux64(v)
 509         case OpRsh16Ux8:
 510                 return rewriteValueRISCV64_OpRsh16Ux8(v)
 511         case OpRsh16x16:
 512                 return rewriteValueRISCV64_OpRsh16x16(v)
 513         case OpRsh16x32:
 514                 return rewriteValueRISCV64_OpRsh16x32(v)
 515         case OpRsh16x64:
 516                 return rewriteValueRISCV64_OpRsh16x64(v)
 517         case OpRsh16x8:
 518                 return rewriteValueRISCV64_OpRsh16x8(v)
 519         case OpRsh32Ux16:
 520                 return rewriteValueRISCV64_OpRsh32Ux16(v)
 521         case OpRsh32Ux32:
 522                 return rewriteValueRISCV64_OpRsh32Ux32(v)
 523         case OpRsh32Ux64:
 524                 return rewriteValueRISCV64_OpRsh32Ux64(v)
 525         case OpRsh32Ux8:
 526                 return rewriteValueRISCV64_OpRsh32Ux8(v)
 527         case OpRsh32x16:
 528                 return rewriteValueRISCV64_OpRsh32x16(v)
 529         case OpRsh32x32:
 530                 return rewriteValueRISCV64_OpRsh32x32(v)
 531         case OpRsh32x64:
 532                 return rewriteValueRISCV64_OpRsh32x64(v)
 533         case OpRsh32x8:
 534                 return rewriteValueRISCV64_OpRsh32x8(v)
 535         case OpRsh64Ux16:
 536                 return rewriteValueRISCV64_OpRsh64Ux16(v)
 537         case OpRsh64Ux32:
 538                 return rewriteValueRISCV64_OpRsh64Ux32(v)
 539         case OpRsh64Ux64:
 540                 return rewriteValueRISCV64_OpRsh64Ux64(v)
 541         case OpRsh64Ux8:
 542                 return rewriteValueRISCV64_OpRsh64Ux8(v)
 543         case OpRsh64x16:
 544                 return rewriteValueRISCV64_OpRsh64x16(v)
 545         case OpRsh64x32:
 546                 return rewriteValueRISCV64_OpRsh64x32(v)
 547         case OpRsh64x64:
 548                 return rewriteValueRISCV64_OpRsh64x64(v)
 549         case OpRsh64x8:
 550                 return rewriteValueRISCV64_OpRsh64x8(v)
 551         case OpRsh8Ux16:
 552                 return rewriteValueRISCV64_OpRsh8Ux16(v)
 553         case OpRsh8Ux32:
 554                 return rewriteValueRISCV64_OpRsh8Ux32(v)
 555         case OpRsh8Ux64:
 556                 return rewriteValueRISCV64_OpRsh8Ux64(v)
 557         case OpRsh8Ux8:
 558                 return rewriteValueRISCV64_OpRsh8Ux8(v)
 559         case OpRsh8x16:
 560                 return rewriteValueRISCV64_OpRsh8x16(v)
 561         case OpRsh8x32:
 562                 return rewriteValueRISCV64_OpRsh8x32(v)
 563         case OpRsh8x64:
 564                 return rewriteValueRISCV64_OpRsh8x64(v)
 565         case OpRsh8x8:
 566                 return rewriteValueRISCV64_OpRsh8x8(v)
 567         case OpSignExt16to32:
 568                 v.Op = OpRISCV64MOVHreg
 569                 return true
 570         case OpSignExt16to64:
 571                 v.Op = OpRISCV64MOVHreg
 572                 return true
 573         case OpSignExt32to64:
 574                 v.Op = OpRISCV64MOVWreg
 575                 return true
 576         case OpSignExt8to16:
 577                 v.Op = OpRISCV64MOVBreg
 578                 return true
 579         case OpSignExt8to32:
 580                 v.Op = OpRISCV64MOVBreg
 581                 return true
 582         case OpSignExt8to64:
 583                 v.Op = OpRISCV64MOVBreg
 584                 return true
 585         case OpSlicemask:
 586                 return rewriteValueRISCV64_OpSlicemask(v)
 587         case OpSqrt:
 588                 v.Op = OpRISCV64FSQRTD
 589                 return true
 590         case OpSqrt32:
 591                 v.Op = OpRISCV64FSQRTS
 592                 return true
 593         case OpStaticCall:
 594                 v.Op = OpRISCV64CALLstatic
 595                 return true
 596         case OpStore:
 597                 return rewriteValueRISCV64_OpStore(v)
 598         case OpSub16:
 599                 v.Op = OpRISCV64SUB
 600                 return true
 601         case OpSub32:
 602                 v.Op = OpRISCV64SUB
 603                 return true
 604         case OpSub32F:
 605                 v.Op = OpRISCV64FSUBS
 606                 return true
 607         case OpSub64:
 608                 v.Op = OpRISCV64SUB
 609                 return true
 610         case OpSub64F:
 611                 v.Op = OpRISCV64FSUBD
 612                 return true
 613         case OpSub8:
 614                 v.Op = OpRISCV64SUB
 615                 return true
 616         case OpSubPtr:
 617                 v.Op = OpRISCV64SUB
 618                 return true
 619         case OpTrunc16to8:
 620                 v.Op = OpCopy
 621                 return true
 622         case OpTrunc32to16:
 623                 v.Op = OpCopy
 624                 return true
 625         case OpTrunc32to8:
 626                 v.Op = OpCopy
 627                 return true
 628         case OpTrunc64to16:
 629                 v.Op = OpCopy
 630                 return true
 631         case OpTrunc64to32:
 632                 v.Op = OpCopy
 633                 return true
 634         case OpTrunc64to8:
 635                 v.Op = OpCopy
 636                 return true
 637         case OpWB:
 638                 v.Op = OpRISCV64LoweredWB
 639                 return true
 640         case OpXor16:
 641                 v.Op = OpRISCV64XOR
 642                 return true
 643         case OpXor32:
 644                 v.Op = OpRISCV64XOR
 645                 return true
 646         case OpXor64:
 647                 v.Op = OpRISCV64XOR
 648                 return true
 649         case OpXor8:
 650                 v.Op = OpRISCV64XOR
 651                 return true
 652         case OpZero:
 653                 return rewriteValueRISCV64_OpZero(v)
 654         case OpZeroExt16to32:
 655                 v.Op = OpRISCV64MOVHUreg
 656                 return true
 657         case OpZeroExt16to64:
 658                 v.Op = OpRISCV64MOVHUreg
 659                 return true
 660         case OpZeroExt32to64:
 661                 v.Op = OpRISCV64MOVWUreg
 662                 return true
 663         case OpZeroExt8to16:
 664                 v.Op = OpRISCV64MOVBUreg
 665                 return true
 666         case OpZeroExt8to32:
 667                 v.Op = OpRISCV64MOVBUreg
 668                 return true
 669         case OpZeroExt8to64:
 670                 v.Op = OpRISCV64MOVBUreg
 671                 return true
 672         }
 673         return false
 674 }
 675 func rewriteValueRISCV64_OpAddr(v *Value) bool {
 676         v_0 := v.Args[0]
 677         // match: (Addr {sym} base)
 678         // result: (MOVaddr {sym} [0] base)
 679         for {
 680                 sym := auxToSym(v.Aux)
 681                 base := v_0
 682                 v.reset(OpRISCV64MOVaddr)
 683                 v.AuxInt = int32ToAuxInt(0)
 684                 v.Aux = symToAux(sym)
 685                 v.AddArg(base)
 686                 return true
 687         }
 688 }
 689 func rewriteValueRISCV64_OpAtomicAnd8(v *Value) bool {
 690         v_2 := v.Args[2]
 691         v_1 := v.Args[1]
 692         v_0 := v.Args[0]
 693         b := v.Block
 694         typ := &b.Func.Config.Types
 695         // match: (AtomicAnd8 ptr val mem)
 696         // 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)
 697         for {
 698                 ptr := v_0
 699                 val := v_1
 700                 mem := v_2
 701                 v.reset(OpRISCV64LoweredAtomicAnd32)
 702                 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
 703                 v0.AuxInt = int64ToAuxInt(^3)
 704                 v0.AddArg(ptr)
 705                 v1 := b.NewValue0(v.Pos, OpRISCV64NOT, typ.UInt32)
 706                 v2 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
 707                 v3 := b.NewValue0(v.Pos, OpRISCV64XORI, typ.UInt32)
 708                 v3.AuxInt = int64ToAuxInt(0xff)
 709                 v4 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 710                 v4.AddArg(val)
 711                 v3.AddArg(v4)
 712                 v5 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
 713                 v5.AuxInt = int64ToAuxInt(3)
 714                 v6 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
 715                 v6.AuxInt = int64ToAuxInt(3)
 716                 v6.AddArg(ptr)
 717                 v5.AddArg(v6)
 718                 v2.AddArg2(v3, v5)
 719                 v1.AddArg(v2)
 720                 v.AddArg3(v0, v1, mem)
 721                 return true
 722         }
 723 }
 724 func rewriteValueRISCV64_OpAtomicOr8(v *Value) bool {
 725         v_2 := v.Args[2]
 726         v_1 := v.Args[1]
 727         v_0 := v.Args[0]
 728         b := v.Block
 729         typ := &b.Func.Config.Types
 730         // match: (AtomicOr8 ptr val mem)
 731         // result: (LoweredAtomicOr32 (ANDI <typ.Uintptr> [^3] ptr) (SLL <typ.UInt32> (ZeroExt8to32 val) (SLLI <typ.UInt64> [3] (ANDI <typ.UInt64> [3] ptr))) mem)
 732         for {
 733                 ptr := v_0
 734                 val := v_1
 735                 mem := v_2
 736                 v.reset(OpRISCV64LoweredAtomicOr32)
 737                 v0 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.Uintptr)
 738                 v0.AuxInt = int64ToAuxInt(^3)
 739                 v0.AddArg(ptr)
 740                 v1 := b.NewValue0(v.Pos, OpRISCV64SLL, typ.UInt32)
 741                 v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 742                 v2.AddArg(val)
 743                 v3 := b.NewValue0(v.Pos, OpRISCV64SLLI, typ.UInt64)
 744                 v3.AuxInt = int64ToAuxInt(3)
 745                 v4 := b.NewValue0(v.Pos, OpRISCV64ANDI, typ.UInt64)
 746                 v4.AuxInt = int64ToAuxInt(3)
 747                 v4.AddArg(ptr)
 748                 v3.AddArg(v4)
 749                 v1.AddArg2(v2, v3)
 750                 v.AddArg3(v0, v1, mem)
 751                 return true
 752         }
 753 }
 754 func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
 755         v_1 := v.Args[1]
 756         v_0 := v.Args[0]
 757         b := v.Block
 758         // match: (Avg64u <t> x y)
 759         // result: (ADD (ADD <t> (SRLI <t> [1] x) (SRLI <t> [1] y)) (ANDI <t> [1] (AND <t> x y)))
 760         for {
 761                 t := v.Type
 762                 x := v_0
 763                 y := v_1
 764                 v.reset(OpRISCV64ADD)
 765                 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, t)
 766                 v1 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
 767                 v1.AuxInt = int64ToAuxInt(1)
 768                 v1.AddArg(x)
 769                 v2 := b.NewValue0(v.Pos, OpRISCV64SRLI, t)
 770                 v2.AuxInt = int64ToAuxInt(1)
 771                 v2.AddArg(y)
 772                 v0.AddArg2(v1, v2)
 773                 v3 := b.NewValue0(v.Pos, OpRISCV64ANDI, t)
 774                 v3.AuxInt = int64ToAuxInt(1)
 775                 v4 := b.NewValue0(v.Pos, OpRISCV64AND, t)
 776                 v4.AddArg2(x, y)
 777                 v3.AddArg(v4)
 778                 v.AddArg2(v0, v3)
 779                 return true
 780         }
 781 }
 782 func rewriteValueRISCV64_OpConst16(v *Value) bool {
 783         // match: (Const16 [val])
 784         // result: (MOVDconst [int64(val)])
 785         for {
 786                 val := auxIntToInt16(v.AuxInt)
 787                 v.reset(OpRISCV64MOVDconst)
 788                 v.AuxInt = int64ToAuxInt(int64(val))
 789                 return true
 790         }
 791 }
 792 func rewriteValueRISCV64_OpConst32(v *Value) bool {
 793         // match: (Const32 [val])
 794         // result: (MOVDconst [int64(val)])
 795         for {
 796                 val := auxIntToInt32(v.AuxInt)
 797                 v.reset(OpRISCV64MOVDconst)
 798                 v.AuxInt = int64ToAuxInt(int64(val))
 799                 return true
 800         }
 801 }
 802 func rewriteValueRISCV64_OpConst32F(v *Value) bool {
 803         b := v.Block
 804         typ := &b.Func.Config.Types
 805         // match: (Const32F [val])
 806         // result: (FMVSX (MOVDconst [int64(math.Float32bits(val))]))
 807         for {
 808                 val := auxIntToFloat32(v.AuxInt)
 809                 v.reset(OpRISCV64FMVSX)
 810                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
 811                 v0.AuxInt = int64ToAuxInt(int64(math.Float32bits(val)))
 812                 v.AddArg(v0)
 813                 return true
 814         }
 815 }
 816 func rewriteValueRISCV64_OpConst64(v *Value) bool {
 817         // match: (Const64 [val])
 818         // result: (MOVDconst [int64(val)])
 819         for {
 820                 val := auxIntToInt64(v.AuxInt)
 821                 v.reset(OpRISCV64MOVDconst)
 822                 v.AuxInt = int64ToAuxInt(int64(val))
 823                 return true
 824         }
 825 }
 826 func rewriteValueRISCV64_OpConst64F(v *Value) bool {
 827         b := v.Block
 828         typ := &b.Func.Config.Types
 829         // match: (Const64F [val])
 830         // result: (FMVDX (MOVDconst [int64(math.Float64bits(val))]))
 831         for {
 832                 val := auxIntToFloat64(v.AuxInt)
 833                 v.reset(OpRISCV64FMVDX)
 834                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
 835                 v0.AuxInt = int64ToAuxInt(int64(math.Float64bits(val)))
 836                 v.AddArg(v0)
 837                 return true
 838         }
 839 }
 840 func rewriteValueRISCV64_OpConst8(v *Value) bool {
 841         // match: (Const8 [val])
 842         // result: (MOVDconst [int64(val)])
 843         for {
 844                 val := auxIntToInt8(v.AuxInt)
 845                 v.reset(OpRISCV64MOVDconst)
 846                 v.AuxInt = int64ToAuxInt(int64(val))
 847                 return true
 848         }
 849 }
 850 func rewriteValueRISCV64_OpConstBool(v *Value) bool {
 851         // match: (ConstBool [val])
 852         // result: (MOVDconst [int64(b2i(val))])
 853         for {
 854                 val := auxIntToBool(v.AuxInt)
 855                 v.reset(OpRISCV64MOVDconst)
 856                 v.AuxInt = int64ToAuxInt(int64(b2i(val)))
 857                 return true
 858         }
 859 }
 860 func rewriteValueRISCV64_OpConstNil(v *Value) bool {
 861         // match: (ConstNil)
 862         // result: (MOVDconst [0])
 863         for {
 864                 v.reset(OpRISCV64MOVDconst)
 865                 v.AuxInt = int64ToAuxInt(0)
 866                 return true
 867         }
 868 }
 869 func rewriteValueRISCV64_OpDiv16(v *Value) bool {
 870         v_1 := v.Args[1]
 871         v_0 := v.Args[0]
 872         b := v.Block
 873         typ := &b.Func.Config.Types
 874         // match: (Div16 x y [false])
 875         // result: (DIVW (SignExt16to32 x) (SignExt16to32 y))
 876         for {
 877                 if auxIntToBool(v.AuxInt) != false {
 878                         break
 879                 }
 880                 x := v_0
 881                 y := v_1
 882                 v.reset(OpRISCV64DIVW)
 883                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 884                 v0.AddArg(x)
 885                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 886                 v1.AddArg(y)
 887                 v.AddArg2(v0, v1)
 888                 return true
 889         }
 890         return false
 891 }
 892 func rewriteValueRISCV64_OpDiv16u(v *Value) bool {
 893         v_1 := v.Args[1]
 894         v_0 := v.Args[0]
 895         b := v.Block
 896         typ := &b.Func.Config.Types
 897         // match: (Div16u x y)
 898         // result: (DIVUW (ZeroExt16to32 x) (ZeroExt16to32 y))
 899         for {
 900                 x := v_0
 901                 y := v_1
 902                 v.reset(OpRISCV64DIVUW)
 903                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 904                 v0.AddArg(x)
 905                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 906                 v1.AddArg(y)
 907                 v.AddArg2(v0, v1)
 908                 return true
 909         }
 910 }
 911 func rewriteValueRISCV64_OpDiv32(v *Value) bool {
 912         v_1 := v.Args[1]
 913         v_0 := v.Args[0]
 914         // match: (Div32 x y [false])
 915         // result: (DIVW x y)
 916         for {
 917                 if auxIntToBool(v.AuxInt) != false {
 918                         break
 919                 }
 920                 x := v_0
 921                 y := v_1
 922                 v.reset(OpRISCV64DIVW)
 923                 v.AddArg2(x, y)
 924                 return true
 925         }
 926         return false
 927 }
 928 func rewriteValueRISCV64_OpDiv64(v *Value) bool {
 929         v_1 := v.Args[1]
 930         v_0 := v.Args[0]
 931         // match: (Div64 x y [false])
 932         // result: (DIV x y)
 933         for {
 934                 if auxIntToBool(v.AuxInt) != false {
 935                         break
 936                 }
 937                 x := v_0
 938                 y := v_1
 939                 v.reset(OpRISCV64DIV)
 940                 v.AddArg2(x, y)
 941                 return true
 942         }
 943         return false
 944 }
 945 func rewriteValueRISCV64_OpDiv8(v *Value) bool {
 946         v_1 := v.Args[1]
 947         v_0 := v.Args[0]
 948         b := v.Block
 949         typ := &b.Func.Config.Types
 950         // match: (Div8 x y)
 951         // result: (DIVW (SignExt8to32 x) (SignExt8to32 y))
 952         for {
 953                 x := v_0
 954                 y := v_1
 955                 v.reset(OpRISCV64DIVW)
 956                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 957                 v0.AddArg(x)
 958                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 959                 v1.AddArg(y)
 960                 v.AddArg2(v0, v1)
 961                 return true
 962         }
 963 }
 964 func rewriteValueRISCV64_OpDiv8u(v *Value) bool {
 965         v_1 := v.Args[1]
 966         v_0 := v.Args[0]
 967         b := v.Block
 968         typ := &b.Func.Config.Types
 969         // match: (Div8u x y)
 970         // result: (DIVUW (ZeroExt8to32 x) (ZeroExt8to32 y))
 971         for {
 972                 x := v_0
 973                 y := v_1
 974                 v.reset(OpRISCV64DIVUW)
 975                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 976                 v0.AddArg(x)
 977                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 978                 v1.AddArg(y)
 979                 v.AddArg2(v0, v1)
 980                 return true
 981         }
 982 }
 983 func rewriteValueRISCV64_OpEq16(v *Value) bool {
 984         v_1 := v.Args[1]
 985         v_0 := v.Args[0]
 986         b := v.Block
 987         typ := &b.Func.Config.Types
 988         // match: (Eq16 x y)
 989         // result: (SEQZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
 990         for {
 991                 x := v_0
 992                 y := v_1
 993                 v.reset(OpRISCV64SEQZ)
 994                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
 995                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
 996                 v1.AddArg(x)
 997                 v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
 998                 v2.AddArg(y)
 999                 v0.AddArg2(v1, v2)
1000                 v.AddArg(v0)
1001                 return true
1002         }
1003 }
1004 func rewriteValueRISCV64_OpEq32(v *Value) bool {
1005         v_1 := v.Args[1]
1006         v_0 := v.Args[0]
1007         b := v.Block
1008         typ := &b.Func.Config.Types
1009         // match: (Eq32 x y)
1010         // result: (SEQZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
1011         for {
1012                 x := v_0
1013                 y := v_1
1014                 v.reset(OpRISCV64SEQZ)
1015                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1016                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1017                 v1.AddArg(x)
1018                 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1019                 v2.AddArg(y)
1020                 v0.AddArg2(v1, v2)
1021                 v.AddArg(v0)
1022                 return true
1023         }
1024 }
1025 func rewriteValueRISCV64_OpEq64(v *Value) bool {
1026         v_1 := v.Args[1]
1027         v_0 := v.Args[0]
1028         b := v.Block
1029         // match: (Eq64 x y)
1030         // result: (SEQZ (SUB <x.Type> x y))
1031         for {
1032                 x := v_0
1033                 y := v_1
1034                 v.reset(OpRISCV64SEQZ)
1035                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1036                 v0.AddArg2(x, y)
1037                 v.AddArg(v0)
1038                 return true
1039         }
1040 }
1041 func rewriteValueRISCV64_OpEq8(v *Value) bool {
1042         v_1 := v.Args[1]
1043         v_0 := v.Args[0]
1044         b := v.Block
1045         typ := &b.Func.Config.Types
1046         // match: (Eq8 x y)
1047         // result: (SEQZ (SUB <x.Type> (ZeroExt8to64 x) (ZeroExt8to64 y)))
1048         for {
1049                 x := v_0
1050                 y := v_1
1051                 v.reset(OpRISCV64SEQZ)
1052                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1053                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1054                 v1.AddArg(x)
1055                 v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1056                 v2.AddArg(y)
1057                 v0.AddArg2(v1, v2)
1058                 v.AddArg(v0)
1059                 return true
1060         }
1061 }
1062 func rewriteValueRISCV64_OpEqB(v *Value) bool {
1063         v_1 := v.Args[1]
1064         v_0 := v.Args[0]
1065         b := v.Block
1066         typ := &b.Func.Config.Types
1067         // match: (EqB x y)
1068         // result: (SEQZ (XOR <typ.Bool> x y))
1069         for {
1070                 x := v_0
1071                 y := v_1
1072                 v.reset(OpRISCV64SEQZ)
1073                 v0 := b.NewValue0(v.Pos, OpRISCV64XOR, typ.Bool)
1074                 v0.AddArg2(x, y)
1075                 v.AddArg(v0)
1076                 return true
1077         }
1078 }
1079 func rewriteValueRISCV64_OpEqPtr(v *Value) bool {
1080         v_1 := v.Args[1]
1081         v_0 := v.Args[0]
1082         b := v.Block
1083         // match: (EqPtr x y)
1084         // result: (SEQZ (SUB <x.Type> x y))
1085         for {
1086                 x := v_0
1087                 y := v_1
1088                 v.reset(OpRISCV64SEQZ)
1089                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
1090                 v0.AddArg2(x, y)
1091                 v.AddArg(v0)
1092                 return true
1093         }
1094 }
1095 func rewriteValueRISCV64_OpHmul32(v *Value) bool {
1096         v_1 := v.Args[1]
1097         v_0 := v.Args[0]
1098         b := v.Block
1099         typ := &b.Func.Config.Types
1100         // match: (Hmul32 x y)
1101         // result: (SRAI [32] (MUL (SignExt32to64 x) (SignExt32to64 y)))
1102         for {
1103                 x := v_0
1104                 y := v_1
1105                 v.reset(OpRISCV64SRAI)
1106                 v.AuxInt = int64ToAuxInt(32)
1107                 v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
1108                 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1109                 v1.AddArg(x)
1110                 v2 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1111                 v2.AddArg(y)
1112                 v0.AddArg2(v1, v2)
1113                 v.AddArg(v0)
1114                 return true
1115         }
1116 }
1117 func rewriteValueRISCV64_OpHmul32u(v *Value) bool {
1118         v_1 := v.Args[1]
1119         v_0 := v.Args[0]
1120         b := v.Block
1121         typ := &b.Func.Config.Types
1122         // match: (Hmul32u x y)
1123         // result: (SRLI [32] (MUL (ZeroExt32to64 x) (ZeroExt32to64 y)))
1124         for {
1125                 x := v_0
1126                 y := v_1
1127                 v.reset(OpRISCV64SRLI)
1128                 v.AuxInt = int64ToAuxInt(32)
1129                 v0 := b.NewValue0(v.Pos, OpRISCV64MUL, typ.Int64)
1130                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1131                 v1.AddArg(x)
1132                 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1133                 v2.AddArg(y)
1134                 v0.AddArg2(v1, v2)
1135                 v.AddArg(v0)
1136                 return true
1137         }
1138 }
1139 func rewriteValueRISCV64_OpLeq16(v *Value) bool {
1140         v_1 := v.Args[1]
1141         v_0 := v.Args[0]
1142         b := v.Block
1143         typ := &b.Func.Config.Types
1144         // match: (Leq16 x y)
1145         // result: (Not (Less16 y x))
1146         for {
1147                 x := v_0
1148                 y := v_1
1149                 v.reset(OpNot)
1150                 v0 := b.NewValue0(v.Pos, OpLess16, typ.Bool)
1151                 v0.AddArg2(y, x)
1152                 v.AddArg(v0)
1153                 return true
1154         }
1155 }
1156 func rewriteValueRISCV64_OpLeq16U(v *Value) bool {
1157         v_1 := v.Args[1]
1158         v_0 := v.Args[0]
1159         b := v.Block
1160         typ := &b.Func.Config.Types
1161         // match: (Leq16U x y)
1162         // result: (Not (Less16U y x))
1163         for {
1164                 x := v_0
1165                 y := v_1
1166                 v.reset(OpNot)
1167                 v0 := b.NewValue0(v.Pos, OpLess16U, typ.Bool)
1168                 v0.AddArg2(y, x)
1169                 v.AddArg(v0)
1170                 return true
1171         }
1172 }
1173 func rewriteValueRISCV64_OpLeq32(v *Value) bool {
1174         v_1 := v.Args[1]
1175         v_0 := v.Args[0]
1176         b := v.Block
1177         typ := &b.Func.Config.Types
1178         // match: (Leq32 x y)
1179         // result: (Not (Less32 y x))
1180         for {
1181                 x := v_0
1182                 y := v_1
1183                 v.reset(OpNot)
1184                 v0 := b.NewValue0(v.Pos, OpLess32, typ.Bool)
1185                 v0.AddArg2(y, x)
1186                 v.AddArg(v0)
1187                 return true
1188         }
1189 }
1190 func rewriteValueRISCV64_OpLeq32U(v *Value) bool {
1191         v_1 := v.Args[1]
1192         v_0 := v.Args[0]
1193         b := v.Block
1194         typ := &b.Func.Config.Types
1195         // match: (Leq32U x y)
1196         // result: (Not (Less32U y x))
1197         for {
1198                 x := v_0
1199                 y := v_1
1200                 v.reset(OpNot)
1201                 v0 := b.NewValue0(v.Pos, OpLess32U, typ.Bool)
1202                 v0.AddArg2(y, x)
1203                 v.AddArg(v0)
1204                 return true
1205         }
1206 }
1207 func rewriteValueRISCV64_OpLeq64(v *Value) bool {
1208         v_1 := v.Args[1]
1209         v_0 := v.Args[0]
1210         b := v.Block
1211         typ := &b.Func.Config.Types
1212         // match: (Leq64 x y)
1213         // result: (Not (Less64 y x))
1214         for {
1215                 x := v_0
1216                 y := v_1
1217                 v.reset(OpNot)
1218                 v0 := b.NewValue0(v.Pos, OpLess64, typ.Bool)
1219                 v0.AddArg2(y, x)
1220                 v.AddArg(v0)
1221                 return true
1222         }
1223 }
1224 func rewriteValueRISCV64_OpLeq64U(v *Value) bool {
1225         v_1 := v.Args[1]
1226         v_0 := v.Args[0]
1227         b := v.Block
1228         typ := &b.Func.Config.Types
1229         // match: (Leq64U x y)
1230         // result: (Not (Less64U y x))
1231         for {
1232                 x := v_0
1233                 y := v_1
1234                 v.reset(OpNot)
1235                 v0 := b.NewValue0(v.Pos, OpLess64U, typ.Bool)
1236                 v0.AddArg2(y, x)
1237                 v.AddArg(v0)
1238                 return true
1239         }
1240 }
1241 func rewriteValueRISCV64_OpLeq8(v *Value) bool {
1242         v_1 := v.Args[1]
1243         v_0 := v.Args[0]
1244         b := v.Block
1245         typ := &b.Func.Config.Types
1246         // match: (Leq8 x y)
1247         // result: (Not (Less8 y x))
1248         for {
1249                 x := v_0
1250                 y := v_1
1251                 v.reset(OpNot)
1252                 v0 := b.NewValue0(v.Pos, OpLess8, typ.Bool)
1253                 v0.AddArg2(y, x)
1254                 v.AddArg(v0)
1255                 return true
1256         }
1257 }
1258 func rewriteValueRISCV64_OpLeq8U(v *Value) bool {
1259         v_1 := v.Args[1]
1260         v_0 := v.Args[0]
1261         b := v.Block
1262         typ := &b.Func.Config.Types
1263         // match: (Leq8U x y)
1264         // result: (Not (Less8U y x))
1265         for {
1266                 x := v_0
1267                 y := v_1
1268                 v.reset(OpNot)
1269                 v0 := b.NewValue0(v.Pos, OpLess8U, typ.Bool)
1270                 v0.AddArg2(y, x)
1271                 v.AddArg(v0)
1272                 return true
1273         }
1274 }
1275 func rewriteValueRISCV64_OpLess16(v *Value) bool {
1276         v_1 := v.Args[1]
1277         v_0 := v.Args[0]
1278         b := v.Block
1279         typ := &b.Func.Config.Types
1280         // match: (Less16 x y)
1281         // result: (SLT (SignExt16to64 x) (SignExt16to64 y))
1282         for {
1283                 x := v_0
1284                 y := v_1
1285                 v.reset(OpRISCV64SLT)
1286                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1287                 v0.AddArg(x)
1288                 v1 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
1289                 v1.AddArg(y)
1290                 v.AddArg2(v0, v1)
1291                 return true
1292         }
1293 }
1294 func rewriteValueRISCV64_OpLess16U(v *Value) bool {
1295         v_1 := v.Args[1]
1296         v_0 := v.Args[0]
1297         b := v.Block
1298         typ := &b.Func.Config.Types
1299         // match: (Less16U x y)
1300         // result: (SLTU (ZeroExt16to64 x) (ZeroExt16to64 y))
1301         for {
1302                 x := v_0
1303                 y := v_1
1304                 v.reset(OpRISCV64SLTU)
1305                 v0 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1306                 v0.AddArg(x)
1307                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1308                 v1.AddArg(y)
1309                 v.AddArg2(v0, v1)
1310                 return true
1311         }
1312 }
1313 func rewriteValueRISCV64_OpLess32(v *Value) bool {
1314         v_1 := v.Args[1]
1315         v_0 := v.Args[0]
1316         b := v.Block
1317         typ := &b.Func.Config.Types
1318         // match: (Less32 x y)
1319         // result: (SLT (SignExt32to64 x) (SignExt32to64 y))
1320         for {
1321                 x := v_0
1322                 y := v_1
1323                 v.reset(OpRISCV64SLT)
1324                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1325                 v0.AddArg(x)
1326                 v1 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
1327                 v1.AddArg(y)
1328                 v.AddArg2(v0, v1)
1329                 return true
1330         }
1331 }
1332 func rewriteValueRISCV64_OpLess32U(v *Value) bool {
1333         v_1 := v.Args[1]
1334         v_0 := v.Args[0]
1335         b := v.Block
1336         typ := &b.Func.Config.Types
1337         // match: (Less32U x y)
1338         // result: (SLTU (ZeroExt32to64 x) (ZeroExt32to64 y))
1339         for {
1340                 x := v_0
1341                 y := v_1
1342                 v.reset(OpRISCV64SLTU)
1343                 v0 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1344                 v0.AddArg(x)
1345                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1346                 v1.AddArg(y)
1347                 v.AddArg2(v0, v1)
1348                 return true
1349         }
1350 }
1351 func rewriteValueRISCV64_OpLess8(v *Value) bool {
1352         v_1 := v.Args[1]
1353         v_0 := v.Args[0]
1354         b := v.Block
1355         typ := &b.Func.Config.Types
1356         // match: (Less8 x y)
1357         // result: (SLT (SignExt8to64 x) (SignExt8to64 y))
1358         for {
1359                 x := v_0
1360                 y := v_1
1361                 v.reset(OpRISCV64SLT)
1362                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1363                 v0.AddArg(x)
1364                 v1 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
1365                 v1.AddArg(y)
1366                 v.AddArg2(v0, v1)
1367                 return true
1368         }
1369 }
1370 func rewriteValueRISCV64_OpLess8U(v *Value) bool {
1371         v_1 := v.Args[1]
1372         v_0 := v.Args[0]
1373         b := v.Block
1374         typ := &b.Func.Config.Types
1375         // match: (Less8U x y)
1376         // result: (SLTU (ZeroExt8to64 x) (ZeroExt8to64 y))
1377         for {
1378                 x := v_0
1379                 y := v_1
1380                 v.reset(OpRISCV64SLTU)
1381                 v0 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1382                 v0.AddArg(x)
1383                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1384                 v1.AddArg(y)
1385                 v.AddArg2(v0, v1)
1386                 return true
1387         }
1388 }
1389 func rewriteValueRISCV64_OpLoad(v *Value) bool {
1390         v_1 := v.Args[1]
1391         v_0 := v.Args[0]
1392         // match: (Load <t> ptr mem)
1393         // cond: t.IsBoolean()
1394         // result: (MOVBUload ptr mem)
1395         for {
1396                 t := v.Type
1397                 ptr := v_0
1398                 mem := v_1
1399                 if !(t.IsBoolean()) {
1400                         break
1401                 }
1402                 v.reset(OpRISCV64MOVBUload)
1403                 v.AddArg2(ptr, mem)
1404                 return true
1405         }
1406         // match: (Load <t> ptr mem)
1407         // cond: ( is8BitInt(t) && isSigned(t))
1408         // result: (MOVBload ptr mem)
1409         for {
1410                 t := v.Type
1411                 ptr := v_0
1412                 mem := v_1
1413                 if !(is8BitInt(t) && isSigned(t)) {
1414                         break
1415                 }
1416                 v.reset(OpRISCV64MOVBload)
1417                 v.AddArg2(ptr, mem)
1418                 return true
1419         }
1420         // match: (Load <t> ptr mem)
1421         // cond: ( is8BitInt(t) && !isSigned(t))
1422         // result: (MOVBUload ptr mem)
1423         for {
1424                 t := v.Type
1425                 ptr := v_0
1426                 mem := v_1
1427                 if !(is8BitInt(t) && !isSigned(t)) {
1428                         break
1429                 }
1430                 v.reset(OpRISCV64MOVBUload)
1431                 v.AddArg2(ptr, mem)
1432                 return true
1433         }
1434         // match: (Load <t> ptr mem)
1435         // cond: (is16BitInt(t) && isSigned(t))
1436         // result: (MOVHload ptr mem)
1437         for {
1438                 t := v.Type
1439                 ptr := v_0
1440                 mem := v_1
1441                 if !(is16BitInt(t) && isSigned(t)) {
1442                         break
1443                 }
1444                 v.reset(OpRISCV64MOVHload)
1445                 v.AddArg2(ptr, mem)
1446                 return true
1447         }
1448         // match: (Load <t> ptr mem)
1449         // cond: (is16BitInt(t) && !isSigned(t))
1450         // result: (MOVHUload ptr mem)
1451         for {
1452                 t := v.Type
1453                 ptr := v_0
1454                 mem := v_1
1455                 if !(is16BitInt(t) && !isSigned(t)) {
1456                         break
1457                 }
1458                 v.reset(OpRISCV64MOVHUload)
1459                 v.AddArg2(ptr, mem)
1460                 return true
1461         }
1462         // match: (Load <t> ptr mem)
1463         // cond: (is32BitInt(t) && isSigned(t))
1464         // result: (MOVWload ptr mem)
1465         for {
1466                 t := v.Type
1467                 ptr := v_0
1468                 mem := v_1
1469                 if !(is32BitInt(t) && isSigned(t)) {
1470                         break
1471                 }
1472                 v.reset(OpRISCV64MOVWload)
1473                 v.AddArg2(ptr, mem)
1474                 return true
1475         }
1476         // match: (Load <t> ptr mem)
1477         // cond: (is32BitInt(t) && !isSigned(t))
1478         // result: (MOVWUload ptr mem)
1479         for {
1480                 t := v.Type
1481                 ptr := v_0
1482                 mem := v_1
1483                 if !(is32BitInt(t) && !isSigned(t)) {
1484                         break
1485                 }
1486                 v.reset(OpRISCV64MOVWUload)
1487                 v.AddArg2(ptr, mem)
1488                 return true
1489         }
1490         // match: (Load <t> ptr mem)
1491         // cond: (is64BitInt(t) || isPtr(t))
1492         // result: (MOVDload ptr mem)
1493         for {
1494                 t := v.Type
1495                 ptr := v_0
1496                 mem := v_1
1497                 if !(is64BitInt(t) || isPtr(t)) {
1498                         break
1499                 }
1500                 v.reset(OpRISCV64MOVDload)
1501                 v.AddArg2(ptr, mem)
1502                 return true
1503         }
1504         // match: (Load <t> ptr mem)
1505         // cond: is32BitFloat(t)
1506         // result: (FMOVWload ptr mem)
1507         for {
1508                 t := v.Type
1509                 ptr := v_0
1510                 mem := v_1
1511                 if !(is32BitFloat(t)) {
1512                         break
1513                 }
1514                 v.reset(OpRISCV64FMOVWload)
1515                 v.AddArg2(ptr, mem)
1516                 return true
1517         }
1518         // match: (Load <t> ptr mem)
1519         // cond: is64BitFloat(t)
1520         // result: (FMOVDload ptr mem)
1521         for {
1522                 t := v.Type
1523                 ptr := v_0
1524                 mem := v_1
1525                 if !(is64BitFloat(t)) {
1526                         break
1527                 }
1528                 v.reset(OpRISCV64FMOVDload)
1529                 v.AddArg2(ptr, mem)
1530                 return true
1531         }
1532         return false
1533 }
1534 func rewriteValueRISCV64_OpLocalAddr(v *Value) bool {
1535         v_0 := v.Args[0]
1536         // match: (LocalAddr {sym} base _)
1537         // result: (MOVaddr {sym} base)
1538         for {
1539                 sym := auxToSym(v.Aux)
1540                 base := v_0
1541                 v.reset(OpRISCV64MOVaddr)
1542                 v.Aux = symToAux(sym)
1543                 v.AddArg(base)
1544                 return true
1545         }
1546 }
1547 func rewriteValueRISCV64_OpLsh16x16(v *Value) bool {
1548         v_1 := v.Args[1]
1549         v_0 := v.Args[0]
1550         b := v.Block
1551         typ := &b.Func.Config.Types
1552         // match: (Lsh16x16 <t> x y)
1553         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1554         for {
1555                 t := v.Type
1556                 x := v_0
1557                 y := v_1
1558                 v.reset(OpRISCV64AND)
1559                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1560                 v0.AddArg2(x, y)
1561                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1562                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1563                 v2.AuxInt = int64ToAuxInt(64)
1564                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1565                 v3.AddArg(y)
1566                 v2.AddArg(v3)
1567                 v1.AddArg(v2)
1568                 v.AddArg2(v0, v1)
1569                 return true
1570         }
1571 }
1572 func rewriteValueRISCV64_OpLsh16x32(v *Value) bool {
1573         v_1 := v.Args[1]
1574         v_0 := v.Args[0]
1575         b := v.Block
1576         typ := &b.Func.Config.Types
1577         // match: (Lsh16x32 <t> x y)
1578         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
1579         for {
1580                 t := v.Type
1581                 x := v_0
1582                 y := v_1
1583                 v.reset(OpRISCV64AND)
1584                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1585                 v0.AddArg2(x, y)
1586                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1587                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1588                 v2.AuxInt = int64ToAuxInt(64)
1589                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1590                 v3.AddArg(y)
1591                 v2.AddArg(v3)
1592                 v1.AddArg(v2)
1593                 v.AddArg2(v0, v1)
1594                 return true
1595         }
1596 }
1597 func rewriteValueRISCV64_OpLsh16x64(v *Value) bool {
1598         v_1 := v.Args[1]
1599         v_0 := v.Args[0]
1600         b := v.Block
1601         // match: (Lsh16x64 <t> x y)
1602         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] y)))
1603         for {
1604                 t := v.Type
1605                 x := v_0
1606                 y := v_1
1607                 v.reset(OpRISCV64AND)
1608                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1609                 v0.AddArg2(x, y)
1610                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1611                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1612                 v2.AuxInt = int64ToAuxInt(64)
1613                 v2.AddArg(y)
1614                 v1.AddArg(v2)
1615                 v.AddArg2(v0, v1)
1616                 return true
1617         }
1618 }
1619 func rewriteValueRISCV64_OpLsh16x8(v *Value) bool {
1620         v_1 := v.Args[1]
1621         v_0 := v.Args[0]
1622         b := v.Block
1623         typ := &b.Func.Config.Types
1624         // match: (Lsh16x8 <t> x y)
1625         // result: (AND (SLL <t> x y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
1626         for {
1627                 t := v.Type
1628                 x := v_0
1629                 y := v_1
1630                 v.reset(OpRISCV64AND)
1631                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1632                 v0.AddArg2(x, y)
1633                 v1 := b.NewValue0(v.Pos, OpNeg16, t)
1634                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1635                 v2.AuxInt = int64ToAuxInt(64)
1636                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1637                 v3.AddArg(y)
1638                 v2.AddArg(v3)
1639                 v1.AddArg(v2)
1640                 v.AddArg2(v0, v1)
1641                 return true
1642         }
1643 }
1644 func rewriteValueRISCV64_OpLsh32x16(v *Value) bool {
1645         v_1 := v.Args[1]
1646         v_0 := v.Args[0]
1647         b := v.Block
1648         typ := &b.Func.Config.Types
1649         // match: (Lsh32x16 <t> x y)
1650         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1651         for {
1652                 t := v.Type
1653                 x := v_0
1654                 y := v_1
1655                 v.reset(OpRISCV64AND)
1656                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1657                 v0.AddArg2(x, y)
1658                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1659                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1660                 v2.AuxInt = int64ToAuxInt(64)
1661                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1662                 v3.AddArg(y)
1663                 v2.AddArg(v3)
1664                 v1.AddArg(v2)
1665                 v.AddArg2(v0, v1)
1666                 return true
1667         }
1668 }
1669 func rewriteValueRISCV64_OpLsh32x32(v *Value) bool {
1670         v_1 := v.Args[1]
1671         v_0 := v.Args[0]
1672         b := v.Block
1673         typ := &b.Func.Config.Types
1674         // match: (Lsh32x32 <t> x y)
1675         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
1676         for {
1677                 t := v.Type
1678                 x := v_0
1679                 y := v_1
1680                 v.reset(OpRISCV64AND)
1681                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1682                 v0.AddArg2(x, y)
1683                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1684                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1685                 v2.AuxInt = int64ToAuxInt(64)
1686                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1687                 v3.AddArg(y)
1688                 v2.AddArg(v3)
1689                 v1.AddArg(v2)
1690                 v.AddArg2(v0, v1)
1691                 return true
1692         }
1693 }
1694 func rewriteValueRISCV64_OpLsh32x64(v *Value) bool {
1695         v_1 := v.Args[1]
1696         v_0 := v.Args[0]
1697         b := v.Block
1698         // match: (Lsh32x64 <t> x y)
1699         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] y)))
1700         for {
1701                 t := v.Type
1702                 x := v_0
1703                 y := v_1
1704                 v.reset(OpRISCV64AND)
1705                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1706                 v0.AddArg2(x, y)
1707                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1708                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1709                 v2.AuxInt = int64ToAuxInt(64)
1710                 v2.AddArg(y)
1711                 v1.AddArg(v2)
1712                 v.AddArg2(v0, v1)
1713                 return true
1714         }
1715 }
1716 func rewriteValueRISCV64_OpLsh32x8(v *Value) bool {
1717         v_1 := v.Args[1]
1718         v_0 := v.Args[0]
1719         b := v.Block
1720         typ := &b.Func.Config.Types
1721         // match: (Lsh32x8 <t> x y)
1722         // result: (AND (SLL <t> x y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
1723         for {
1724                 t := v.Type
1725                 x := v_0
1726                 y := v_1
1727                 v.reset(OpRISCV64AND)
1728                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1729                 v0.AddArg2(x, y)
1730                 v1 := b.NewValue0(v.Pos, OpNeg32, t)
1731                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1732                 v2.AuxInt = int64ToAuxInt(64)
1733                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1734                 v3.AddArg(y)
1735                 v2.AddArg(v3)
1736                 v1.AddArg(v2)
1737                 v.AddArg2(v0, v1)
1738                 return true
1739         }
1740 }
1741 func rewriteValueRISCV64_OpLsh64x16(v *Value) bool {
1742         v_1 := v.Args[1]
1743         v_0 := v.Args[0]
1744         b := v.Block
1745         typ := &b.Func.Config.Types
1746         // match: (Lsh64x16 <t> x y)
1747         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1748         for {
1749                 t := v.Type
1750                 x := v_0
1751                 y := v_1
1752                 v.reset(OpRISCV64AND)
1753                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1754                 v0.AddArg2(x, y)
1755                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
1756                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1757                 v2.AuxInt = int64ToAuxInt(64)
1758                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1759                 v3.AddArg(y)
1760                 v2.AddArg(v3)
1761                 v1.AddArg(v2)
1762                 v.AddArg2(v0, v1)
1763                 return true
1764         }
1765 }
1766 func rewriteValueRISCV64_OpLsh64x32(v *Value) bool {
1767         v_1 := v.Args[1]
1768         v_0 := v.Args[0]
1769         b := v.Block
1770         typ := &b.Func.Config.Types
1771         // match: (Lsh64x32 <t> x y)
1772         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
1773         for {
1774                 t := v.Type
1775                 x := v_0
1776                 y := v_1
1777                 v.reset(OpRISCV64AND)
1778                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1779                 v0.AddArg2(x, y)
1780                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
1781                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1782                 v2.AuxInt = int64ToAuxInt(64)
1783                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1784                 v3.AddArg(y)
1785                 v2.AddArg(v3)
1786                 v1.AddArg(v2)
1787                 v.AddArg2(v0, v1)
1788                 return true
1789         }
1790 }
1791 func rewriteValueRISCV64_OpLsh64x64(v *Value) bool {
1792         v_1 := v.Args[1]
1793         v_0 := v.Args[0]
1794         b := v.Block
1795         // match: (Lsh64x64 <t> x y)
1796         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] y)))
1797         for {
1798                 t := v.Type
1799                 x := v_0
1800                 y := v_1
1801                 v.reset(OpRISCV64AND)
1802                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1803                 v0.AddArg2(x, y)
1804                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
1805                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1806                 v2.AuxInt = int64ToAuxInt(64)
1807                 v2.AddArg(y)
1808                 v1.AddArg(v2)
1809                 v.AddArg2(v0, v1)
1810                 return true
1811         }
1812 }
1813 func rewriteValueRISCV64_OpLsh64x8(v *Value) bool {
1814         v_1 := v.Args[1]
1815         v_0 := v.Args[0]
1816         b := v.Block
1817         typ := &b.Func.Config.Types
1818         // match: (Lsh64x8 <t> x y)
1819         // result: (AND (SLL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
1820         for {
1821                 t := v.Type
1822                 x := v_0
1823                 y := v_1
1824                 v.reset(OpRISCV64AND)
1825                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1826                 v0.AddArg2(x, y)
1827                 v1 := b.NewValue0(v.Pos, OpNeg64, 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 }
1838 func rewriteValueRISCV64_OpLsh8x16(v *Value) bool {
1839         v_1 := v.Args[1]
1840         v_0 := v.Args[0]
1841         b := v.Block
1842         typ := &b.Func.Config.Types
1843         // match: (Lsh8x16 <t> x y)
1844         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
1845         for {
1846                 t := v.Type
1847                 x := v_0
1848                 y := v_1
1849                 v.reset(OpRISCV64AND)
1850                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1851                 v0.AddArg2(x, y)
1852                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
1853                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1854                 v2.AuxInt = int64ToAuxInt(64)
1855                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
1856                 v3.AddArg(y)
1857                 v2.AddArg(v3)
1858                 v1.AddArg(v2)
1859                 v.AddArg2(v0, v1)
1860                 return true
1861         }
1862 }
1863 func rewriteValueRISCV64_OpLsh8x32(v *Value) bool {
1864         v_1 := v.Args[1]
1865         v_0 := v.Args[0]
1866         b := v.Block
1867         typ := &b.Func.Config.Types
1868         // match: (Lsh8x32 <t> x y)
1869         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
1870         for {
1871                 t := v.Type
1872                 x := v_0
1873                 y := v_1
1874                 v.reset(OpRISCV64AND)
1875                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1876                 v0.AddArg2(x, y)
1877                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
1878                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1879                 v2.AuxInt = int64ToAuxInt(64)
1880                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
1881                 v3.AddArg(y)
1882                 v2.AddArg(v3)
1883                 v1.AddArg(v2)
1884                 v.AddArg2(v0, v1)
1885                 return true
1886         }
1887 }
1888 func rewriteValueRISCV64_OpLsh8x64(v *Value) bool {
1889         v_1 := v.Args[1]
1890         v_0 := v.Args[0]
1891         b := v.Block
1892         // match: (Lsh8x64 <t> x y)
1893         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] y)))
1894         for {
1895                 t := v.Type
1896                 x := v_0
1897                 y := v_1
1898                 v.reset(OpRISCV64AND)
1899                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1900                 v0.AddArg2(x, y)
1901                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
1902                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1903                 v2.AuxInt = int64ToAuxInt(64)
1904                 v2.AddArg(y)
1905                 v1.AddArg(v2)
1906                 v.AddArg2(v0, v1)
1907                 return true
1908         }
1909 }
1910 func rewriteValueRISCV64_OpLsh8x8(v *Value) bool {
1911         v_1 := v.Args[1]
1912         v_0 := v.Args[0]
1913         b := v.Block
1914         typ := &b.Func.Config.Types
1915         // match: (Lsh8x8 <t> x y)
1916         // result: (AND (SLL <t> x y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
1917         for {
1918                 t := v.Type
1919                 x := v_0
1920                 y := v_1
1921                 v.reset(OpRISCV64AND)
1922                 v0 := b.NewValue0(v.Pos, OpRISCV64SLL, t)
1923                 v0.AddArg2(x, y)
1924                 v1 := b.NewValue0(v.Pos, OpNeg8, t)
1925                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
1926                 v2.AuxInt = int64ToAuxInt(64)
1927                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
1928                 v3.AddArg(y)
1929                 v2.AddArg(v3)
1930                 v1.AddArg(v2)
1931                 v.AddArg2(v0, v1)
1932                 return true
1933         }
1934 }
1935 func rewriteValueRISCV64_OpMod16(v *Value) bool {
1936         v_1 := v.Args[1]
1937         v_0 := v.Args[0]
1938         b := v.Block
1939         typ := &b.Func.Config.Types
1940         // match: (Mod16 x y [false])
1941         // result: (REMW (SignExt16to32 x) (SignExt16to32 y))
1942         for {
1943                 if auxIntToBool(v.AuxInt) != false {
1944                         break
1945                 }
1946                 x := v_0
1947                 y := v_1
1948                 v.reset(OpRISCV64REMW)
1949                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
1950                 v0.AddArg(x)
1951                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
1952                 v1.AddArg(y)
1953                 v.AddArg2(v0, v1)
1954                 return true
1955         }
1956         return false
1957 }
1958 func rewriteValueRISCV64_OpMod16u(v *Value) bool {
1959         v_1 := v.Args[1]
1960         v_0 := v.Args[0]
1961         b := v.Block
1962         typ := &b.Func.Config.Types
1963         // match: (Mod16u x y)
1964         // result: (REMUW (ZeroExt16to32 x) (ZeroExt16to32 y))
1965         for {
1966                 x := v_0
1967                 y := v_1
1968                 v.reset(OpRISCV64REMUW)
1969                 v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
1970                 v0.AddArg(x)
1971                 v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
1972                 v1.AddArg(y)
1973                 v.AddArg2(v0, v1)
1974                 return true
1975         }
1976 }
1977 func rewriteValueRISCV64_OpMod32(v *Value) bool {
1978         v_1 := v.Args[1]
1979         v_0 := v.Args[0]
1980         // match: (Mod32 x y [false])
1981         // result: (REMW x y)
1982         for {
1983                 if auxIntToBool(v.AuxInt) != false {
1984                         break
1985                 }
1986                 x := v_0
1987                 y := v_1
1988                 v.reset(OpRISCV64REMW)
1989                 v.AddArg2(x, y)
1990                 return true
1991         }
1992         return false
1993 }
1994 func rewriteValueRISCV64_OpMod64(v *Value) bool {
1995         v_1 := v.Args[1]
1996         v_0 := v.Args[0]
1997         // match: (Mod64 x y [false])
1998         // result: (REM x y)
1999         for {
2000                 if auxIntToBool(v.AuxInt) != false {
2001                         break
2002                 }
2003                 x := v_0
2004                 y := v_1
2005                 v.reset(OpRISCV64REM)
2006                 v.AddArg2(x, y)
2007                 return true
2008         }
2009         return false
2010 }
2011 func rewriteValueRISCV64_OpMod8(v *Value) bool {
2012         v_1 := v.Args[1]
2013         v_0 := v.Args[0]
2014         b := v.Block
2015         typ := &b.Func.Config.Types
2016         // match: (Mod8 x y)
2017         // result: (REMW (SignExt8to32 x) (SignExt8to32 y))
2018         for {
2019                 x := v_0
2020                 y := v_1
2021                 v.reset(OpRISCV64REMW)
2022                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2023                 v0.AddArg(x)
2024                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2025                 v1.AddArg(y)
2026                 v.AddArg2(v0, v1)
2027                 return true
2028         }
2029 }
2030 func rewriteValueRISCV64_OpMod8u(v *Value) bool {
2031         v_1 := v.Args[1]
2032         v_0 := v.Args[0]
2033         b := v.Block
2034         typ := &b.Func.Config.Types
2035         // match: (Mod8u x y)
2036         // result: (REMUW (ZeroExt8to32 x) (ZeroExt8to32 y))
2037         for {
2038                 x := v_0
2039                 y := v_1
2040                 v.reset(OpRISCV64REMUW)
2041                 v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
2042                 v0.AddArg(x)
2043                 v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
2044                 v1.AddArg(y)
2045                 v.AddArg2(v0, v1)
2046                 return true
2047         }
2048 }
2049 func rewriteValueRISCV64_OpMove(v *Value) bool {
2050         v_2 := v.Args[2]
2051         v_1 := v.Args[1]
2052         v_0 := v.Args[0]
2053         b := v.Block
2054         config := b.Func.Config
2055         typ := &b.Func.Config.Types
2056         // match: (Move [0] _ _ mem)
2057         // result: mem
2058         for {
2059                 if auxIntToInt64(v.AuxInt) != 0 {
2060                         break
2061                 }
2062                 mem := v_2
2063                 v.copyOf(mem)
2064                 return true
2065         }
2066         // match: (Move [1] dst src mem)
2067         // result: (MOVBstore dst (MOVBload src mem) mem)
2068         for {
2069                 if auxIntToInt64(v.AuxInt) != 1 {
2070                         break
2071                 }
2072                 dst := v_0
2073                 src := v_1
2074                 mem := v_2
2075                 v.reset(OpRISCV64MOVBstore)
2076                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2077                 v0.AddArg2(src, mem)
2078                 v.AddArg3(dst, v0, mem)
2079                 return true
2080         }
2081         // match: (Move [2] {t} dst src mem)
2082         // cond: t.Alignment()%2 == 0
2083         // result: (MOVHstore dst (MOVHload src mem) mem)
2084         for {
2085                 if auxIntToInt64(v.AuxInt) != 2 {
2086                         break
2087                 }
2088                 t := auxToType(v.Aux)
2089                 dst := v_0
2090                 src := v_1
2091                 mem := v_2
2092                 if !(t.Alignment()%2 == 0) {
2093                         break
2094                 }
2095                 v.reset(OpRISCV64MOVHstore)
2096                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2097                 v0.AddArg2(src, mem)
2098                 v.AddArg3(dst, v0, mem)
2099                 return true
2100         }
2101         // match: (Move [2] dst src mem)
2102         // result: (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))
2103         for {
2104                 if auxIntToInt64(v.AuxInt) != 2 {
2105                         break
2106                 }
2107                 dst := v_0
2108                 src := v_1
2109                 mem := v_2
2110                 v.reset(OpRISCV64MOVBstore)
2111                 v.AuxInt = int32ToAuxInt(1)
2112                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2113                 v0.AuxInt = int32ToAuxInt(1)
2114                 v0.AddArg2(src, mem)
2115                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2116                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2117                 v2.AddArg2(src, mem)
2118                 v1.AddArg3(dst, v2, mem)
2119                 v.AddArg3(dst, v0, v1)
2120                 return true
2121         }
2122         // match: (Move [4] {t} dst src mem)
2123         // cond: t.Alignment()%4 == 0
2124         // result: (MOVWstore dst (MOVWload src mem) mem)
2125         for {
2126                 if auxIntToInt64(v.AuxInt) != 4 {
2127                         break
2128                 }
2129                 t := auxToType(v.Aux)
2130                 dst := v_0
2131                 src := v_1
2132                 mem := v_2
2133                 if !(t.Alignment()%4 == 0) {
2134                         break
2135                 }
2136                 v.reset(OpRISCV64MOVWstore)
2137                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2138                 v0.AddArg2(src, mem)
2139                 v.AddArg3(dst, v0, mem)
2140                 return true
2141         }
2142         // match: (Move [4] {t} dst src mem)
2143         // cond: t.Alignment()%2 == 0
2144         // result: (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))
2145         for {
2146                 if auxIntToInt64(v.AuxInt) != 4 {
2147                         break
2148                 }
2149                 t := auxToType(v.Aux)
2150                 dst := v_0
2151                 src := v_1
2152                 mem := v_2
2153                 if !(t.Alignment()%2 == 0) {
2154                         break
2155                 }
2156                 v.reset(OpRISCV64MOVHstore)
2157                 v.AuxInt = int32ToAuxInt(2)
2158                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2159                 v0.AuxInt = int32ToAuxInt(2)
2160                 v0.AddArg2(src, mem)
2161                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2162                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2163                 v2.AddArg2(src, mem)
2164                 v1.AddArg3(dst, v2, mem)
2165                 v.AddArg3(dst, v0, v1)
2166                 return true
2167         }
2168         // match: (Move [4] dst src mem)
2169         // 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))))
2170         for {
2171                 if auxIntToInt64(v.AuxInt) != 4 {
2172                         break
2173                 }
2174                 dst := v_0
2175                 src := v_1
2176                 mem := v_2
2177                 v.reset(OpRISCV64MOVBstore)
2178                 v.AuxInt = int32ToAuxInt(3)
2179                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2180                 v0.AuxInt = int32ToAuxInt(3)
2181                 v0.AddArg2(src, mem)
2182                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2183                 v1.AuxInt = int32ToAuxInt(2)
2184                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2185                 v2.AuxInt = int32ToAuxInt(2)
2186                 v2.AddArg2(src, mem)
2187                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2188                 v3.AuxInt = int32ToAuxInt(1)
2189                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2190                 v4.AuxInt = int32ToAuxInt(1)
2191                 v4.AddArg2(src, mem)
2192                 v5 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2193                 v6 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2194                 v6.AddArg2(src, mem)
2195                 v5.AddArg3(dst, v6, mem)
2196                 v3.AddArg3(dst, v4, v5)
2197                 v1.AddArg3(dst, v2, v3)
2198                 v.AddArg3(dst, v0, v1)
2199                 return true
2200         }
2201         // match: (Move [8] {t} dst src mem)
2202         // cond: t.Alignment()%8 == 0
2203         // result: (MOVDstore dst (MOVDload src mem) mem)
2204         for {
2205                 if auxIntToInt64(v.AuxInt) != 8 {
2206                         break
2207                 }
2208                 t := auxToType(v.Aux)
2209                 dst := v_0
2210                 src := v_1
2211                 mem := v_2
2212                 if !(t.Alignment()%8 == 0) {
2213                         break
2214                 }
2215                 v.reset(OpRISCV64MOVDstore)
2216                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2217                 v0.AddArg2(src, mem)
2218                 v.AddArg3(dst, v0, mem)
2219                 return true
2220         }
2221         // match: (Move [8] {t} dst src mem)
2222         // cond: t.Alignment()%4 == 0
2223         // result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem))
2224         for {
2225                 if auxIntToInt64(v.AuxInt) != 8 {
2226                         break
2227                 }
2228                 t := auxToType(v.Aux)
2229                 dst := v_0
2230                 src := v_1
2231                 mem := v_2
2232                 if !(t.Alignment()%4 == 0) {
2233                         break
2234                 }
2235                 v.reset(OpRISCV64MOVWstore)
2236                 v.AuxInt = int32ToAuxInt(4)
2237                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2238                 v0.AuxInt = int32ToAuxInt(4)
2239                 v0.AddArg2(src, mem)
2240                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
2241                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2242                 v2.AddArg2(src, mem)
2243                 v1.AddArg3(dst, v2, mem)
2244                 v.AddArg3(dst, v0, v1)
2245                 return true
2246         }
2247         // match: (Move [8] {t} dst src mem)
2248         // cond: t.Alignment()%2 == 0
2249         // 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))))
2250         for {
2251                 if auxIntToInt64(v.AuxInt) != 8 {
2252                         break
2253                 }
2254                 t := auxToType(v.Aux)
2255                 dst := v_0
2256                 src := v_1
2257                 mem := v_2
2258                 if !(t.Alignment()%2 == 0) {
2259                         break
2260                 }
2261                 v.reset(OpRISCV64MOVHstore)
2262                 v.AuxInt = int32ToAuxInt(6)
2263                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2264                 v0.AuxInt = int32ToAuxInt(6)
2265                 v0.AddArg2(src, mem)
2266                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2267                 v1.AuxInt = int32ToAuxInt(4)
2268                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2269                 v2.AuxInt = int32ToAuxInt(4)
2270                 v2.AddArg2(src, mem)
2271                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2272                 v3.AuxInt = int32ToAuxInt(2)
2273                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2274                 v4.AuxInt = int32ToAuxInt(2)
2275                 v4.AddArg2(src, mem)
2276                 v5 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2277                 v6 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2278                 v6.AddArg2(src, mem)
2279                 v5.AddArg3(dst, v6, mem)
2280                 v3.AddArg3(dst, v4, v5)
2281                 v1.AddArg3(dst, v2, v3)
2282                 v.AddArg3(dst, v0, v1)
2283                 return true
2284         }
2285         // match: (Move [3] dst src mem)
2286         // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
2287         for {
2288                 if auxIntToInt64(v.AuxInt) != 3 {
2289                         break
2290                 }
2291                 dst := v_0
2292                 src := v_1
2293                 mem := v_2
2294                 v.reset(OpRISCV64MOVBstore)
2295                 v.AuxInt = int32ToAuxInt(2)
2296                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2297                 v0.AuxInt = int32ToAuxInt(2)
2298                 v0.AddArg2(src, mem)
2299                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2300                 v1.AuxInt = int32ToAuxInt(1)
2301                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2302                 v2.AuxInt = int32ToAuxInt(1)
2303                 v2.AddArg2(src, mem)
2304                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
2305                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVBload, typ.Int8)
2306                 v4.AddArg2(src, mem)
2307                 v3.AddArg3(dst, v4, mem)
2308                 v1.AddArg3(dst, v2, v3)
2309                 v.AddArg3(dst, v0, v1)
2310                 return true
2311         }
2312         // match: (Move [6] {t} dst src mem)
2313         // cond: t.Alignment()%2 == 0
2314         // result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
2315         for {
2316                 if auxIntToInt64(v.AuxInt) != 6 {
2317                         break
2318                 }
2319                 t := auxToType(v.Aux)
2320                 dst := v_0
2321                 src := v_1
2322                 mem := v_2
2323                 if !(t.Alignment()%2 == 0) {
2324                         break
2325                 }
2326                 v.reset(OpRISCV64MOVHstore)
2327                 v.AuxInt = int32ToAuxInt(4)
2328                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2329                 v0.AuxInt = int32ToAuxInt(4)
2330                 v0.AddArg2(src, mem)
2331                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2332                 v1.AuxInt = int32ToAuxInt(2)
2333                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2334                 v2.AuxInt = int32ToAuxInt(2)
2335                 v2.AddArg2(src, mem)
2336                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
2337                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVHload, typ.Int16)
2338                 v4.AddArg2(src, mem)
2339                 v3.AddArg3(dst, v4, mem)
2340                 v1.AddArg3(dst, v2, v3)
2341                 v.AddArg3(dst, v0, v1)
2342                 return true
2343         }
2344         // match: (Move [12] {t} dst src mem)
2345         // cond: t.Alignment()%4 == 0
2346         // result: (MOVWstore [8] dst (MOVWload [8] src mem) (MOVWstore [4] dst (MOVWload [4] src mem) (MOVWstore dst (MOVWload src mem) mem)))
2347         for {
2348                 if auxIntToInt64(v.AuxInt) != 12 {
2349                         break
2350                 }
2351                 t := auxToType(v.Aux)
2352                 dst := v_0
2353                 src := v_1
2354                 mem := v_2
2355                 if !(t.Alignment()%4 == 0) {
2356                         break
2357                 }
2358                 v.reset(OpRISCV64MOVWstore)
2359                 v.AuxInt = int32ToAuxInt(8)
2360                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2361                 v0.AuxInt = int32ToAuxInt(8)
2362                 v0.AddArg2(src, mem)
2363                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
2364                 v1.AuxInt = int32ToAuxInt(4)
2365                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2366                 v2.AuxInt = int32ToAuxInt(4)
2367                 v2.AddArg2(src, mem)
2368                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
2369                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVWload, typ.Int32)
2370                 v4.AddArg2(src, mem)
2371                 v3.AddArg3(dst, v4, mem)
2372                 v1.AddArg3(dst, v2, v3)
2373                 v.AddArg3(dst, v0, v1)
2374                 return true
2375         }
2376         // match: (Move [16] {t} dst src mem)
2377         // cond: t.Alignment()%8 == 0
2378         // result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
2379         for {
2380                 if auxIntToInt64(v.AuxInt) != 16 {
2381                         break
2382                 }
2383                 t := auxToType(v.Aux)
2384                 dst := v_0
2385                 src := v_1
2386                 mem := v_2
2387                 if !(t.Alignment()%8 == 0) {
2388                         break
2389                 }
2390                 v.reset(OpRISCV64MOVDstore)
2391                 v.AuxInt = int32ToAuxInt(8)
2392                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2393                 v0.AuxInt = int32ToAuxInt(8)
2394                 v0.AddArg2(src, mem)
2395                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2396                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2397                 v2.AddArg2(src, mem)
2398                 v1.AddArg3(dst, v2, mem)
2399                 v.AddArg3(dst, v0, v1)
2400                 return true
2401         }
2402         // match: (Move [24] {t} dst src mem)
2403         // cond: t.Alignment()%8 == 0
2404         // result: (MOVDstore [16] dst (MOVDload [16] src mem) (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)))
2405         for {
2406                 if auxIntToInt64(v.AuxInt) != 24 {
2407                         break
2408                 }
2409                 t := auxToType(v.Aux)
2410                 dst := v_0
2411                 src := v_1
2412                 mem := v_2
2413                 if !(t.Alignment()%8 == 0) {
2414                         break
2415                 }
2416                 v.reset(OpRISCV64MOVDstore)
2417                 v.AuxInt = int32ToAuxInt(16)
2418                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2419                 v0.AuxInt = int32ToAuxInt(16)
2420                 v0.AddArg2(src, mem)
2421                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2422                 v1.AuxInt = int32ToAuxInt(8)
2423                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2424                 v2.AuxInt = int32ToAuxInt(8)
2425                 v2.AddArg2(src, mem)
2426                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2427                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2428                 v4.AddArg2(src, mem)
2429                 v3.AddArg3(dst, v4, mem)
2430                 v1.AddArg3(dst, v2, v3)
2431                 v.AddArg3(dst, v0, v1)
2432                 return true
2433         }
2434         // match: (Move [32] {t} dst src mem)
2435         // cond: t.Alignment()%8 == 0
2436         // 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))))
2437         for {
2438                 if auxIntToInt64(v.AuxInt) != 32 {
2439                         break
2440                 }
2441                 t := auxToType(v.Aux)
2442                 dst := v_0
2443                 src := v_1
2444                 mem := v_2
2445                 if !(t.Alignment()%8 == 0) {
2446                         break
2447                 }
2448                 v.reset(OpRISCV64MOVDstore)
2449                 v.AuxInt = int32ToAuxInt(24)
2450                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2451                 v0.AuxInt = int32ToAuxInt(24)
2452                 v0.AddArg2(src, mem)
2453                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2454                 v1.AuxInt = int32ToAuxInt(16)
2455                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2456                 v2.AuxInt = int32ToAuxInt(16)
2457                 v2.AddArg2(src, mem)
2458                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2459                 v3.AuxInt = int32ToAuxInt(8)
2460                 v4 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2461                 v4.AuxInt = int32ToAuxInt(8)
2462                 v4.AddArg2(src, mem)
2463                 v5 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
2464                 v6 := b.NewValue0(v.Pos, OpRISCV64MOVDload, typ.Int64)
2465                 v6.AddArg2(src, mem)
2466                 v5.AddArg3(dst, v6, mem)
2467                 v3.AddArg3(dst, v4, v5)
2468                 v1.AddArg3(dst, v2, v3)
2469                 v.AddArg3(dst, v0, v1)
2470                 return true
2471         }
2472         // match: (Move [s] {t} dst src mem)
2473         // cond: s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice && logLargeCopy(v, s)
2474         // result: (DUFFCOPY [16 * (128 - s/8)] dst src mem)
2475         for {
2476                 s := auxIntToInt64(v.AuxInt)
2477                 t := auxToType(v.Aux)
2478                 dst := v_0
2479                 src := v_1
2480                 mem := v_2
2481                 if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice && logLargeCopy(v, s)) {
2482                         break
2483                 }
2484                 v.reset(OpRISCV64DUFFCOPY)
2485                 v.AuxInt = int64ToAuxInt(16 * (128 - s/8))
2486                 v.AddArg3(dst, src, mem)
2487                 return true
2488         }
2489         // match: (Move [s] {t} dst src mem)
2490         // cond: (s <= 16 || logLargeCopy(v, s))
2491         // result: (LoweredMove [t.Alignment()] dst src (ADDI <src.Type> [s-moveSize(t.Alignment(), config)] src) mem)
2492         for {
2493                 s := auxIntToInt64(v.AuxInt)
2494                 t := auxToType(v.Aux)
2495                 dst := v_0
2496                 src := v_1
2497                 mem := v_2
2498                 if !(s <= 16 || logLargeCopy(v, s)) {
2499                         break
2500                 }
2501                 v.reset(OpRISCV64LoweredMove)
2502                 v.AuxInt = int64ToAuxInt(t.Alignment())
2503                 v0 := b.NewValue0(v.Pos, OpRISCV64ADDI, src.Type)
2504                 v0.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
2505                 v0.AddArg(src)
2506                 v.AddArg4(dst, src, v0, mem)
2507                 return true
2508         }
2509         return false
2510 }
2511 func rewriteValueRISCV64_OpMul16(v *Value) bool {
2512         v_1 := v.Args[1]
2513         v_0 := v.Args[0]
2514         b := v.Block
2515         typ := &b.Func.Config.Types
2516         // match: (Mul16 x y)
2517         // result: (MULW (SignExt16to32 x) (SignExt16to32 y))
2518         for {
2519                 x := v_0
2520                 y := v_1
2521                 v.reset(OpRISCV64MULW)
2522                 v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2523                 v0.AddArg(x)
2524                 v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
2525                 v1.AddArg(y)
2526                 v.AddArg2(v0, v1)
2527                 return true
2528         }
2529 }
2530 func rewriteValueRISCV64_OpMul8(v *Value) bool {
2531         v_1 := v.Args[1]
2532         v_0 := v.Args[0]
2533         b := v.Block
2534         typ := &b.Func.Config.Types
2535         // match: (Mul8 x y)
2536         // result: (MULW (SignExt8to32 x) (SignExt8to32 y))
2537         for {
2538                 x := v_0
2539                 y := v_1
2540                 v.reset(OpRISCV64MULW)
2541                 v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2542                 v0.AddArg(x)
2543                 v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
2544                 v1.AddArg(y)
2545                 v.AddArg2(v0, v1)
2546                 return true
2547         }
2548 }
2549 func rewriteValueRISCV64_OpNeq16(v *Value) bool {
2550         v_1 := v.Args[1]
2551         v_0 := v.Args[0]
2552         b := v.Block
2553         typ := &b.Func.Config.Types
2554         // match: (Neq16 x y)
2555         // result: (SNEZ (SUB <x.Type> (ZeroExt16to64 x) (ZeroExt16to64 y)))
2556         for {
2557                 x := v_0
2558                 y := v_1
2559                 v.reset(OpRISCV64SNEZ)
2560                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2561                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2562                 v1.AddArg(x)
2563                 v2 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
2564                 v2.AddArg(y)
2565                 v0.AddArg2(v1, v2)
2566                 v.AddArg(v0)
2567                 return true
2568         }
2569 }
2570 func rewriteValueRISCV64_OpNeq32(v *Value) bool {
2571         v_1 := v.Args[1]
2572         v_0 := v.Args[0]
2573         b := v.Block
2574         typ := &b.Func.Config.Types
2575         // match: (Neq32 x y)
2576         // result: (SNEZ (SUB <x.Type> (ZeroExt32to64 x) (ZeroExt32to64 y)))
2577         for {
2578                 x := v_0
2579                 y := v_1
2580                 v.reset(OpRISCV64SNEZ)
2581                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2582                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2583                 v1.AddArg(x)
2584                 v2 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
2585                 v2.AddArg(y)
2586                 v0.AddArg2(v1, v2)
2587                 v.AddArg(v0)
2588                 return true
2589         }
2590 }
2591 func rewriteValueRISCV64_OpNeq64(v *Value) bool {
2592         v_1 := v.Args[1]
2593         v_0 := v.Args[0]
2594         b := v.Block
2595         // match: (Neq64 x y)
2596         // result: (SNEZ (SUB <x.Type> x y))
2597         for {
2598                 x := v_0
2599                 y := v_1
2600                 v.reset(OpRISCV64SNEZ)
2601                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2602                 v0.AddArg2(x, y)
2603                 v.AddArg(v0)
2604                 return true
2605         }
2606 }
2607 func rewriteValueRISCV64_OpNeq8(v *Value) bool {
2608         v_1 := v.Args[1]
2609         v_0 := v.Args[0]
2610         b := v.Block
2611         typ := &b.Func.Config.Types
2612         // match: (Neq8 x y)
2613         // result: (SNEZ (SUB <x.Type> (ZeroExt8to64 x) (ZeroExt8to64 y)))
2614         for {
2615                 x := v_0
2616                 y := v_1
2617                 v.reset(OpRISCV64SNEZ)
2618                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2619                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2620                 v1.AddArg(x)
2621                 v2 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
2622                 v2.AddArg(y)
2623                 v0.AddArg2(v1, v2)
2624                 v.AddArg(v0)
2625                 return true
2626         }
2627 }
2628 func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
2629         v_1 := v.Args[1]
2630         v_0 := v.Args[0]
2631         b := v.Block
2632         // match: (NeqPtr x y)
2633         // result: (SNEZ (SUB <x.Type> x y))
2634         for {
2635                 x := v_0
2636                 y := v_1
2637                 v.reset(OpRISCV64SNEZ)
2638                 v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type)
2639                 v0.AddArg2(x, y)
2640                 v.AddArg(v0)
2641                 return true
2642         }
2643 }
2644 func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
2645         v_0 := v.Args[0]
2646         b := v.Block
2647         typ := &b.Func.Config.Types
2648         // match: (OffPtr [off] ptr:(SP))
2649         // cond: is32Bit(off)
2650         // result: (MOVaddr [int32(off)] ptr)
2651         for {
2652                 off := auxIntToInt64(v.AuxInt)
2653                 ptr := v_0
2654                 if ptr.Op != OpSP || !(is32Bit(off)) {
2655                         break
2656                 }
2657                 v.reset(OpRISCV64MOVaddr)
2658                 v.AuxInt = int32ToAuxInt(int32(off))
2659                 v.AddArg(ptr)
2660                 return true
2661         }
2662         // match: (OffPtr [off] ptr)
2663         // cond: is32Bit(off)
2664         // result: (ADDI [off] ptr)
2665         for {
2666                 off := auxIntToInt64(v.AuxInt)
2667                 ptr := v_0
2668                 if !(is32Bit(off)) {
2669                         break
2670                 }
2671                 v.reset(OpRISCV64ADDI)
2672                 v.AuxInt = int64ToAuxInt(off)
2673                 v.AddArg(ptr)
2674                 return true
2675         }
2676         // match: (OffPtr [off] ptr)
2677         // result: (ADD (MOVDconst [off]) ptr)
2678         for {
2679                 off := auxIntToInt64(v.AuxInt)
2680                 ptr := v_0
2681                 v.reset(OpRISCV64ADD)
2682                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
2683                 v0.AuxInt = int64ToAuxInt(off)
2684                 v.AddArg2(v0, ptr)
2685                 return true
2686         }
2687 }
2688 func rewriteValueRISCV64_OpPanicBounds(v *Value) bool {
2689         v_2 := v.Args[2]
2690         v_1 := v.Args[1]
2691         v_0 := v.Args[0]
2692         // match: (PanicBounds [kind] x y mem)
2693         // cond: boundsABI(kind) == 0
2694         // result: (LoweredPanicBoundsA [kind] x y mem)
2695         for {
2696                 kind := auxIntToInt64(v.AuxInt)
2697                 x := v_0
2698                 y := v_1
2699                 mem := v_2
2700                 if !(boundsABI(kind) == 0) {
2701                         break
2702                 }
2703                 v.reset(OpRISCV64LoweredPanicBoundsA)
2704                 v.AuxInt = int64ToAuxInt(kind)
2705                 v.AddArg3(x, y, mem)
2706                 return true
2707         }
2708         // match: (PanicBounds [kind] x y mem)
2709         // cond: boundsABI(kind) == 1
2710         // result: (LoweredPanicBoundsB [kind] x y mem)
2711         for {
2712                 kind := auxIntToInt64(v.AuxInt)
2713                 x := v_0
2714                 y := v_1
2715                 mem := v_2
2716                 if !(boundsABI(kind) == 1) {
2717                         break
2718                 }
2719                 v.reset(OpRISCV64LoweredPanicBoundsB)
2720                 v.AuxInt = int64ToAuxInt(kind)
2721                 v.AddArg3(x, y, mem)
2722                 return true
2723         }
2724         // match: (PanicBounds [kind] x y mem)
2725         // cond: boundsABI(kind) == 2
2726         // result: (LoweredPanicBoundsC [kind] x y mem)
2727         for {
2728                 kind := auxIntToInt64(v.AuxInt)
2729                 x := v_0
2730                 y := v_1
2731                 mem := v_2
2732                 if !(boundsABI(kind) == 2) {
2733                         break
2734                 }
2735                 v.reset(OpRISCV64LoweredPanicBoundsC)
2736                 v.AuxInt = int64ToAuxInt(kind)
2737                 v.AddArg3(x, y, mem)
2738                 return true
2739         }
2740         return false
2741 }
2742 func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
2743         v_1 := v.Args[1]
2744         v_0 := v.Args[0]
2745         // match: (ADD (MOVDconst [val]) x)
2746         // cond: is32Bit(val)
2747         // result: (ADDI [val] x)
2748         for {
2749                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2750                         if v_0.Op != OpRISCV64MOVDconst {
2751                                 continue
2752                         }
2753                         val := auxIntToInt64(v_0.AuxInt)
2754                         x := v_1
2755                         if !(is32Bit(val)) {
2756                                 continue
2757                         }
2758                         v.reset(OpRISCV64ADDI)
2759                         v.AuxInt = int64ToAuxInt(val)
2760                         v.AddArg(x)
2761                         return true
2762                 }
2763                 break
2764         }
2765         return false
2766 }
2767 func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
2768         v_0 := v.Args[0]
2769         // match: (ADDI [c] (MOVaddr [d] {s} x))
2770         // cond: is32Bit(c+int64(d))
2771         // result: (MOVaddr [int32(c)+d] {s} x)
2772         for {
2773                 c := auxIntToInt64(v.AuxInt)
2774                 if v_0.Op != OpRISCV64MOVaddr {
2775                         break
2776                 }
2777                 d := auxIntToInt32(v_0.AuxInt)
2778                 s := auxToSym(v_0.Aux)
2779                 x := v_0.Args[0]
2780                 if !(is32Bit(c + int64(d))) {
2781                         break
2782                 }
2783                 v.reset(OpRISCV64MOVaddr)
2784                 v.AuxInt = int32ToAuxInt(int32(c) + d)
2785                 v.Aux = symToAux(s)
2786                 v.AddArg(x)
2787                 return true
2788         }
2789         // match: (ADDI [0] x)
2790         // result: x
2791         for {
2792                 if auxIntToInt64(v.AuxInt) != 0 {
2793                         break
2794                 }
2795                 x := v_0
2796                 v.copyOf(x)
2797                 return true
2798         }
2799         return false
2800 }
2801 func rewriteValueRISCV64_OpRISCV64AND(v *Value) bool {
2802         v_1 := v.Args[1]
2803         v_0 := v.Args[0]
2804         // match: (AND (MOVDconst [val]) x)
2805         // cond: is32Bit(val)
2806         // result: (ANDI [val] x)
2807         for {
2808                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
2809                         if v_0.Op != OpRISCV64MOVDconst {
2810                                 continue
2811                         }
2812                         val := auxIntToInt64(v_0.AuxInt)
2813                         x := v_1
2814                         if !(is32Bit(val)) {
2815                                 continue
2816                         }
2817                         v.reset(OpRISCV64ANDI)
2818                         v.AuxInt = int64ToAuxInt(val)
2819                         v.AddArg(x)
2820                         return true
2821                 }
2822                 break
2823         }
2824         return false
2825 }
2826 func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
2827         v_1 := v.Args[1]
2828         v_0 := v.Args[0]
2829         // match: (MOVBUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
2830         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
2831         // result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
2832         for {
2833                 off1 := auxIntToInt32(v.AuxInt)
2834                 sym1 := auxToSym(v.Aux)
2835                 if v_0.Op != OpRISCV64MOVaddr {
2836                         break
2837                 }
2838                 off2 := auxIntToInt32(v_0.AuxInt)
2839                 sym2 := auxToSym(v_0.Aux)
2840                 base := v_0.Args[0]
2841                 mem := v_1
2842                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
2843                         break
2844                 }
2845                 v.reset(OpRISCV64MOVBUload)
2846                 v.AuxInt = int32ToAuxInt(off1 + off2)
2847                 v.Aux = symToAux(mergeSym(sym1, sym2))
2848                 v.AddArg2(base, mem)
2849                 return true
2850         }
2851         // match: (MOVBUload [off1] {sym} (ADDI [off2] base) mem)
2852         // cond: is32Bit(int64(off1)+off2)
2853         // result: (MOVBUload [off1+int32(off2)] {sym} base mem)
2854         for {
2855                 off1 := auxIntToInt32(v.AuxInt)
2856                 sym := auxToSym(v.Aux)
2857                 if v_0.Op != OpRISCV64ADDI {
2858                         break
2859                 }
2860                 off2 := auxIntToInt64(v_0.AuxInt)
2861                 base := v_0.Args[0]
2862                 mem := v_1
2863                 if !(is32Bit(int64(off1) + off2)) {
2864                         break
2865                 }
2866                 v.reset(OpRISCV64MOVBUload)
2867                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
2868                 v.Aux = symToAux(sym)
2869                 v.AddArg2(base, mem)
2870                 return true
2871         }
2872         return false
2873 }
2874 func rewriteValueRISCV64_OpRISCV64MOVBUreg(v *Value) bool {
2875         v_0 := v.Args[0]
2876         b := v.Block
2877         // match: (MOVBUreg (MOVDconst [c]))
2878         // result: (MOVDconst [int64(uint8(c))])
2879         for {
2880                 if v_0.Op != OpRISCV64MOVDconst {
2881                         break
2882                 }
2883                 c := auxIntToInt64(v_0.AuxInt)
2884                 v.reset(OpRISCV64MOVDconst)
2885                 v.AuxInt = int64ToAuxInt(int64(uint8(c)))
2886                 return true
2887         }
2888         // match: (MOVBUreg x:(MOVBUload _ _))
2889         // result: (MOVDreg x)
2890         for {
2891                 x := v_0
2892                 if x.Op != OpRISCV64MOVBUload {
2893                         break
2894                 }
2895                 v.reset(OpRISCV64MOVDreg)
2896                 v.AddArg(x)
2897                 return true
2898         }
2899         // match: (MOVBUreg x:(MOVBUreg _))
2900         // result: (MOVDreg x)
2901         for {
2902                 x := v_0
2903                 if x.Op != OpRISCV64MOVBUreg {
2904                         break
2905                 }
2906                 v.reset(OpRISCV64MOVDreg)
2907                 v.AddArg(x)
2908                 return true
2909         }
2910         // match: (MOVBUreg <t> x:(MOVBload [off] {sym} ptr mem))
2911         // cond: x.Uses == 1 && clobber(x)
2912         // result: @x.Block (MOVBUload <t> [off] {sym} ptr mem)
2913         for {
2914                 t := v.Type
2915                 x := v_0
2916                 if x.Op != OpRISCV64MOVBload {
2917                         break
2918                 }
2919                 off := auxIntToInt32(x.AuxInt)
2920                 sym := auxToSym(x.Aux)
2921                 mem := x.Args[1]
2922                 ptr := x.Args[0]
2923                 if !(x.Uses == 1 && clobber(x)) {
2924                         break
2925                 }
2926                 b = x.Block
2927                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBUload, t)
2928                 v.copyOf(v0)
2929                 v0.AuxInt = int32ToAuxInt(off)
2930                 v0.Aux = symToAux(sym)
2931                 v0.AddArg2(ptr, mem)
2932                 return true
2933         }
2934         return false
2935 }
2936 func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
2937         v_1 := v.Args[1]
2938         v_0 := v.Args[0]
2939         // match: (MOVBload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
2940         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
2941         // result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
2942         for {
2943                 off1 := auxIntToInt32(v.AuxInt)
2944                 sym1 := auxToSym(v.Aux)
2945                 if v_0.Op != OpRISCV64MOVaddr {
2946                         break
2947                 }
2948                 off2 := auxIntToInt32(v_0.AuxInt)
2949                 sym2 := auxToSym(v_0.Aux)
2950                 base := v_0.Args[0]
2951                 mem := v_1
2952                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
2953                         break
2954                 }
2955                 v.reset(OpRISCV64MOVBload)
2956                 v.AuxInt = int32ToAuxInt(off1 + off2)
2957                 v.Aux = symToAux(mergeSym(sym1, sym2))
2958                 v.AddArg2(base, mem)
2959                 return true
2960         }
2961         // match: (MOVBload [off1] {sym} (ADDI [off2] base) mem)
2962         // cond: is32Bit(int64(off1)+off2)
2963         // result: (MOVBload [off1+int32(off2)] {sym} base mem)
2964         for {
2965                 off1 := auxIntToInt32(v.AuxInt)
2966                 sym := auxToSym(v.Aux)
2967                 if v_0.Op != OpRISCV64ADDI {
2968                         break
2969                 }
2970                 off2 := auxIntToInt64(v_0.AuxInt)
2971                 base := v_0.Args[0]
2972                 mem := v_1
2973                 if !(is32Bit(int64(off1) + off2)) {
2974                         break
2975                 }
2976                 v.reset(OpRISCV64MOVBload)
2977                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
2978                 v.Aux = symToAux(sym)
2979                 v.AddArg2(base, mem)
2980                 return true
2981         }
2982         return false
2983 }
2984 func rewriteValueRISCV64_OpRISCV64MOVBreg(v *Value) bool {
2985         v_0 := v.Args[0]
2986         b := v.Block
2987         // match: (MOVBreg (MOVDconst [c]))
2988         // result: (MOVDconst [int64(int8(c))])
2989         for {
2990                 if v_0.Op != OpRISCV64MOVDconst {
2991                         break
2992                 }
2993                 c := auxIntToInt64(v_0.AuxInt)
2994                 v.reset(OpRISCV64MOVDconst)
2995                 v.AuxInt = int64ToAuxInt(int64(int8(c)))
2996                 return true
2997         }
2998         // match: (MOVBreg x:(MOVBload _ _))
2999         // result: (MOVDreg x)
3000         for {
3001                 x := v_0
3002                 if x.Op != OpRISCV64MOVBload {
3003                         break
3004                 }
3005                 v.reset(OpRISCV64MOVDreg)
3006                 v.AddArg(x)
3007                 return true
3008         }
3009         // match: (MOVBreg x:(MOVBreg _))
3010         // result: (MOVDreg x)
3011         for {
3012                 x := v_0
3013                 if x.Op != OpRISCV64MOVBreg {
3014                         break
3015                 }
3016                 v.reset(OpRISCV64MOVDreg)
3017                 v.AddArg(x)
3018                 return true
3019         }
3020         // match: (MOVBreg <t> x:(MOVBUload [off] {sym} ptr mem))
3021         // cond: x.Uses == 1 && clobber(x)
3022         // result: @x.Block (MOVBload <t> [off] {sym} ptr mem)
3023         for {
3024                 t := v.Type
3025                 x := v_0
3026                 if x.Op != OpRISCV64MOVBUload {
3027                         break
3028                 }
3029                 off := auxIntToInt32(x.AuxInt)
3030                 sym := auxToSym(x.Aux)
3031                 mem := x.Args[1]
3032                 ptr := x.Args[0]
3033                 if !(x.Uses == 1 && clobber(x)) {
3034                         break
3035                 }
3036                 b = x.Block
3037                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVBload, t)
3038                 v.copyOf(v0)
3039                 v0.AuxInt = int32ToAuxInt(off)
3040                 v0.Aux = symToAux(sym)
3041                 v0.AddArg2(ptr, mem)
3042                 return true
3043         }
3044         return false
3045 }
3046 func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
3047         v_2 := v.Args[2]
3048         v_1 := v.Args[1]
3049         v_0 := v.Args[0]
3050         // match: (MOVBstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
3051         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3052         // result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
3053         for {
3054                 off1 := auxIntToInt32(v.AuxInt)
3055                 sym1 := auxToSym(v.Aux)
3056                 if v_0.Op != OpRISCV64MOVaddr {
3057                         break
3058                 }
3059                 off2 := auxIntToInt32(v_0.AuxInt)
3060                 sym2 := auxToSym(v_0.Aux)
3061                 base := v_0.Args[0]
3062                 val := v_1
3063                 mem := v_2
3064                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3065                         break
3066                 }
3067                 v.reset(OpRISCV64MOVBstore)
3068                 v.AuxInt = int32ToAuxInt(off1 + off2)
3069                 v.Aux = symToAux(mergeSym(sym1, sym2))
3070                 v.AddArg3(base, val, mem)
3071                 return true
3072         }
3073         // match: (MOVBstore [off1] {sym} (ADDI [off2] base) val mem)
3074         // cond: is32Bit(int64(off1)+off2)
3075         // result: (MOVBstore [off1+int32(off2)] {sym} base val mem)
3076         for {
3077                 off1 := auxIntToInt32(v.AuxInt)
3078                 sym := auxToSym(v.Aux)
3079                 if v_0.Op != OpRISCV64ADDI {
3080                         break
3081                 }
3082                 off2 := auxIntToInt64(v_0.AuxInt)
3083                 base := v_0.Args[0]
3084                 val := v_1
3085                 mem := v_2
3086                 if !(is32Bit(int64(off1) + off2)) {
3087                         break
3088                 }
3089                 v.reset(OpRISCV64MOVBstore)
3090                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3091                 v.Aux = symToAux(sym)
3092                 v.AddArg3(base, val, mem)
3093                 return true
3094         }
3095         // match: (MOVBstore [off] {sym} ptr (MOVDconst [0]) mem)
3096         // result: (MOVBstorezero [off] {sym} ptr mem)
3097         for {
3098                 off := auxIntToInt32(v.AuxInt)
3099                 sym := auxToSym(v.Aux)
3100                 ptr := v_0
3101                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
3102                         break
3103                 }
3104                 mem := v_2
3105                 v.reset(OpRISCV64MOVBstorezero)
3106                 v.AuxInt = int32ToAuxInt(off)
3107                 v.Aux = symToAux(sym)
3108                 v.AddArg2(ptr, mem)
3109                 return true
3110         }
3111         // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
3112         // result: (MOVBstore [off] {sym} ptr x mem)
3113         for {
3114                 off := auxIntToInt32(v.AuxInt)
3115                 sym := auxToSym(v.Aux)
3116                 ptr := v_0
3117                 if v_1.Op != OpRISCV64MOVBreg {
3118                         break
3119                 }
3120                 x := v_1.Args[0]
3121                 mem := v_2
3122                 v.reset(OpRISCV64MOVBstore)
3123                 v.AuxInt = int32ToAuxInt(off)
3124                 v.Aux = symToAux(sym)
3125                 v.AddArg3(ptr, x, mem)
3126                 return true
3127         }
3128         // match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem)
3129         // result: (MOVBstore [off] {sym} ptr x mem)
3130         for {
3131                 off := auxIntToInt32(v.AuxInt)
3132                 sym := auxToSym(v.Aux)
3133                 ptr := v_0
3134                 if v_1.Op != OpRISCV64MOVHreg {
3135                         break
3136                 }
3137                 x := v_1.Args[0]
3138                 mem := v_2
3139                 v.reset(OpRISCV64MOVBstore)
3140                 v.AuxInt = int32ToAuxInt(off)
3141                 v.Aux = symToAux(sym)
3142                 v.AddArg3(ptr, x, mem)
3143                 return true
3144         }
3145         // match: (MOVBstore [off] {sym} ptr (MOVWreg x) mem)
3146         // result: (MOVBstore [off] {sym} ptr x mem)
3147         for {
3148                 off := auxIntToInt32(v.AuxInt)
3149                 sym := auxToSym(v.Aux)
3150                 ptr := v_0
3151                 if v_1.Op != OpRISCV64MOVWreg {
3152                         break
3153                 }
3154                 x := v_1.Args[0]
3155                 mem := v_2
3156                 v.reset(OpRISCV64MOVBstore)
3157                 v.AuxInt = int32ToAuxInt(off)
3158                 v.Aux = symToAux(sym)
3159                 v.AddArg3(ptr, x, mem)
3160                 return true
3161         }
3162         // match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem)
3163         // result: (MOVBstore [off] {sym} ptr x mem)
3164         for {
3165                 off := auxIntToInt32(v.AuxInt)
3166                 sym := auxToSym(v.Aux)
3167                 ptr := v_0
3168                 if v_1.Op != OpRISCV64MOVBUreg {
3169                         break
3170                 }
3171                 x := v_1.Args[0]
3172                 mem := v_2
3173                 v.reset(OpRISCV64MOVBstore)
3174                 v.AuxInt = int32ToAuxInt(off)
3175                 v.Aux = symToAux(sym)
3176                 v.AddArg3(ptr, x, mem)
3177                 return true
3178         }
3179         // match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem)
3180         // result: (MOVBstore [off] {sym} ptr x mem)
3181         for {
3182                 off := auxIntToInt32(v.AuxInt)
3183                 sym := auxToSym(v.Aux)
3184                 ptr := v_0
3185                 if v_1.Op != OpRISCV64MOVHUreg {
3186                         break
3187                 }
3188                 x := v_1.Args[0]
3189                 mem := v_2
3190                 v.reset(OpRISCV64MOVBstore)
3191                 v.AuxInt = int32ToAuxInt(off)
3192                 v.Aux = symToAux(sym)
3193                 v.AddArg3(ptr, x, mem)
3194                 return true
3195         }
3196         // match: (MOVBstore [off] {sym} ptr (MOVWUreg x) mem)
3197         // result: (MOVBstore [off] {sym} ptr x mem)
3198         for {
3199                 off := auxIntToInt32(v.AuxInt)
3200                 sym := auxToSym(v.Aux)
3201                 ptr := v_0
3202                 if v_1.Op != OpRISCV64MOVWUreg {
3203                         break
3204                 }
3205                 x := v_1.Args[0]
3206                 mem := v_2
3207                 v.reset(OpRISCV64MOVBstore)
3208                 v.AuxInt = int32ToAuxInt(off)
3209                 v.Aux = symToAux(sym)
3210                 v.AddArg3(ptr, x, mem)
3211                 return true
3212         }
3213         return false
3214 }
3215 func rewriteValueRISCV64_OpRISCV64MOVBstorezero(v *Value) bool {
3216         v_1 := v.Args[1]
3217         v_0 := v.Args[0]
3218         // match: (MOVBstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
3219         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
3220         // result: (MOVBstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
3221         for {
3222                 off1 := auxIntToInt32(v.AuxInt)
3223                 sym1 := auxToSym(v.Aux)
3224                 if v_0.Op != OpRISCV64MOVaddr {
3225                         break
3226                 }
3227                 off2 := auxIntToInt32(v_0.AuxInt)
3228                 sym2 := auxToSym(v_0.Aux)
3229                 ptr := v_0.Args[0]
3230                 mem := v_1
3231                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
3232                         break
3233                 }
3234                 v.reset(OpRISCV64MOVBstorezero)
3235                 v.AuxInt = int32ToAuxInt(off1 + off2)
3236                 v.Aux = symToAux(mergeSym(sym1, sym2))
3237                 v.AddArg2(ptr, mem)
3238                 return true
3239         }
3240         // match: (MOVBstorezero [off1] {sym} (ADDI [off2] ptr) mem)
3241         // cond: is32Bit(int64(off1)+off2)
3242         // result: (MOVBstorezero [off1+int32(off2)] {sym} ptr mem)
3243         for {
3244                 off1 := auxIntToInt32(v.AuxInt)
3245                 sym := auxToSym(v.Aux)
3246                 if v_0.Op != OpRISCV64ADDI {
3247                         break
3248                 }
3249                 off2 := auxIntToInt64(v_0.AuxInt)
3250                 ptr := v_0.Args[0]
3251                 mem := v_1
3252                 if !(is32Bit(int64(off1) + off2)) {
3253                         break
3254                 }
3255                 v.reset(OpRISCV64MOVBstorezero)
3256                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3257                 v.Aux = symToAux(sym)
3258                 v.AddArg2(ptr, mem)
3259                 return true
3260         }
3261         return false
3262 }
3263 func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
3264         v_1 := v.Args[1]
3265         v_0 := v.Args[0]
3266         // match: (MOVDload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
3267         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3268         // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
3269         for {
3270                 off1 := auxIntToInt32(v.AuxInt)
3271                 sym1 := auxToSym(v.Aux)
3272                 if v_0.Op != OpRISCV64MOVaddr {
3273                         break
3274                 }
3275                 off2 := auxIntToInt32(v_0.AuxInt)
3276                 sym2 := auxToSym(v_0.Aux)
3277                 base := v_0.Args[0]
3278                 mem := v_1
3279                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3280                         break
3281                 }
3282                 v.reset(OpRISCV64MOVDload)
3283                 v.AuxInt = int32ToAuxInt(off1 + off2)
3284                 v.Aux = symToAux(mergeSym(sym1, sym2))
3285                 v.AddArg2(base, mem)
3286                 return true
3287         }
3288         // match: (MOVDload [off1] {sym} (ADDI [off2] base) mem)
3289         // cond: is32Bit(int64(off1)+off2)
3290         // result: (MOVDload [off1+int32(off2)] {sym} base mem)
3291         for {
3292                 off1 := auxIntToInt32(v.AuxInt)
3293                 sym := auxToSym(v.Aux)
3294                 if v_0.Op != OpRISCV64ADDI {
3295                         break
3296                 }
3297                 off2 := auxIntToInt64(v_0.AuxInt)
3298                 base := v_0.Args[0]
3299                 mem := v_1
3300                 if !(is32Bit(int64(off1) + off2)) {
3301                         break
3302                 }
3303                 v.reset(OpRISCV64MOVDload)
3304                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3305                 v.Aux = symToAux(sym)
3306                 v.AddArg2(base, mem)
3307                 return true
3308         }
3309         return false
3310 }
3311 func rewriteValueRISCV64_OpRISCV64MOVDnop(v *Value) bool {
3312         v_0 := v.Args[0]
3313         // match: (MOVDnop (MOVDconst [c]))
3314         // result: (MOVDconst [c])
3315         for {
3316                 if v_0.Op != OpRISCV64MOVDconst {
3317                         break
3318                 }
3319                 c := auxIntToInt64(v_0.AuxInt)
3320                 v.reset(OpRISCV64MOVDconst)
3321                 v.AuxInt = int64ToAuxInt(c)
3322                 return true
3323         }
3324         return false
3325 }
3326 func rewriteValueRISCV64_OpRISCV64MOVDreg(v *Value) bool {
3327         v_0 := v.Args[0]
3328         // match: (MOVDreg x)
3329         // cond: x.Uses == 1
3330         // result: (MOVDnop x)
3331         for {
3332                 x := v_0
3333                 if !(x.Uses == 1) {
3334                         break
3335                 }
3336                 v.reset(OpRISCV64MOVDnop)
3337                 v.AddArg(x)
3338                 return true
3339         }
3340         return false
3341 }
3342 func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
3343         v_2 := v.Args[2]
3344         v_1 := v.Args[1]
3345         v_0 := v.Args[0]
3346         // match: (MOVDstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
3347         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3348         // result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
3349         for {
3350                 off1 := auxIntToInt32(v.AuxInt)
3351                 sym1 := auxToSym(v.Aux)
3352                 if v_0.Op != OpRISCV64MOVaddr {
3353                         break
3354                 }
3355                 off2 := auxIntToInt32(v_0.AuxInt)
3356                 sym2 := auxToSym(v_0.Aux)
3357                 base := v_0.Args[0]
3358                 val := v_1
3359                 mem := v_2
3360                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3361                         break
3362                 }
3363                 v.reset(OpRISCV64MOVDstore)
3364                 v.AuxInt = int32ToAuxInt(off1 + off2)
3365                 v.Aux = symToAux(mergeSym(sym1, sym2))
3366                 v.AddArg3(base, val, mem)
3367                 return true
3368         }
3369         // match: (MOVDstore [off1] {sym} (ADDI [off2] base) val mem)
3370         // cond: is32Bit(int64(off1)+off2)
3371         // result: (MOVDstore [off1+int32(off2)] {sym} base val mem)
3372         for {
3373                 off1 := auxIntToInt32(v.AuxInt)
3374                 sym := auxToSym(v.Aux)
3375                 if v_0.Op != OpRISCV64ADDI {
3376                         break
3377                 }
3378                 off2 := auxIntToInt64(v_0.AuxInt)
3379                 base := v_0.Args[0]
3380                 val := v_1
3381                 mem := v_2
3382                 if !(is32Bit(int64(off1) + off2)) {
3383                         break
3384                 }
3385                 v.reset(OpRISCV64MOVDstore)
3386                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3387                 v.Aux = symToAux(sym)
3388                 v.AddArg3(base, val, mem)
3389                 return true
3390         }
3391         // match: (MOVDstore [off] {sym} ptr (MOVDconst [0]) mem)
3392         // result: (MOVDstorezero [off] {sym} ptr mem)
3393         for {
3394                 off := auxIntToInt32(v.AuxInt)
3395                 sym := auxToSym(v.Aux)
3396                 ptr := v_0
3397                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
3398                         break
3399                 }
3400                 mem := v_2
3401                 v.reset(OpRISCV64MOVDstorezero)
3402                 v.AuxInt = int32ToAuxInt(off)
3403                 v.Aux = symToAux(sym)
3404                 v.AddArg2(ptr, mem)
3405                 return true
3406         }
3407         return false
3408 }
3409 func rewriteValueRISCV64_OpRISCV64MOVDstorezero(v *Value) bool {
3410         v_1 := v.Args[1]
3411         v_0 := v.Args[0]
3412         // match: (MOVDstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
3413         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
3414         // result: (MOVDstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
3415         for {
3416                 off1 := auxIntToInt32(v.AuxInt)
3417                 sym1 := auxToSym(v.Aux)
3418                 if v_0.Op != OpRISCV64MOVaddr {
3419                         break
3420                 }
3421                 off2 := auxIntToInt32(v_0.AuxInt)
3422                 sym2 := auxToSym(v_0.Aux)
3423                 ptr := v_0.Args[0]
3424                 mem := v_1
3425                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
3426                         break
3427                 }
3428                 v.reset(OpRISCV64MOVDstorezero)
3429                 v.AuxInt = int32ToAuxInt(off1 + off2)
3430                 v.Aux = symToAux(mergeSym(sym1, sym2))
3431                 v.AddArg2(ptr, mem)
3432                 return true
3433         }
3434         // match: (MOVDstorezero [off1] {sym} (ADDI [off2] ptr) mem)
3435         // cond: is32Bit(int64(off1)+off2)
3436         // result: (MOVDstorezero [off1+int32(off2)] {sym} ptr mem)
3437         for {
3438                 off1 := auxIntToInt32(v.AuxInt)
3439                 sym := auxToSym(v.Aux)
3440                 if v_0.Op != OpRISCV64ADDI {
3441                         break
3442                 }
3443                 off2 := auxIntToInt64(v_0.AuxInt)
3444                 ptr := v_0.Args[0]
3445                 mem := v_1
3446                 if !(is32Bit(int64(off1) + off2)) {
3447                         break
3448                 }
3449                 v.reset(OpRISCV64MOVDstorezero)
3450                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3451                 v.Aux = symToAux(sym)
3452                 v.AddArg2(ptr, mem)
3453                 return true
3454         }
3455         return false
3456 }
3457 func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
3458         v_1 := v.Args[1]
3459         v_0 := v.Args[0]
3460         // match: (MOVHUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
3461         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3462         // result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
3463         for {
3464                 off1 := auxIntToInt32(v.AuxInt)
3465                 sym1 := auxToSym(v.Aux)
3466                 if v_0.Op != OpRISCV64MOVaddr {
3467                         break
3468                 }
3469                 off2 := auxIntToInt32(v_0.AuxInt)
3470                 sym2 := auxToSym(v_0.Aux)
3471                 base := v_0.Args[0]
3472                 mem := v_1
3473                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3474                         break
3475                 }
3476                 v.reset(OpRISCV64MOVHUload)
3477                 v.AuxInt = int32ToAuxInt(off1 + off2)
3478                 v.Aux = symToAux(mergeSym(sym1, sym2))
3479                 v.AddArg2(base, mem)
3480                 return true
3481         }
3482         // match: (MOVHUload [off1] {sym} (ADDI [off2] base) mem)
3483         // cond: is32Bit(int64(off1)+off2)
3484         // result: (MOVHUload [off1+int32(off2)] {sym} base mem)
3485         for {
3486                 off1 := auxIntToInt32(v.AuxInt)
3487                 sym := auxToSym(v.Aux)
3488                 if v_0.Op != OpRISCV64ADDI {
3489                         break
3490                 }
3491                 off2 := auxIntToInt64(v_0.AuxInt)
3492                 base := v_0.Args[0]
3493                 mem := v_1
3494                 if !(is32Bit(int64(off1) + off2)) {
3495                         break
3496                 }
3497                 v.reset(OpRISCV64MOVHUload)
3498                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3499                 v.Aux = symToAux(sym)
3500                 v.AddArg2(base, mem)
3501                 return true
3502         }
3503         return false
3504 }
3505 func rewriteValueRISCV64_OpRISCV64MOVHUreg(v *Value) bool {
3506         v_0 := v.Args[0]
3507         b := v.Block
3508         // match: (MOVHUreg (MOVDconst [c]))
3509         // result: (MOVDconst [int64(uint16(c))])
3510         for {
3511                 if v_0.Op != OpRISCV64MOVDconst {
3512                         break
3513                 }
3514                 c := auxIntToInt64(v_0.AuxInt)
3515                 v.reset(OpRISCV64MOVDconst)
3516                 v.AuxInt = int64ToAuxInt(int64(uint16(c)))
3517                 return true
3518         }
3519         // match: (MOVHUreg x:(MOVBUload _ _))
3520         // result: (MOVDreg x)
3521         for {
3522                 x := v_0
3523                 if x.Op != OpRISCV64MOVBUload {
3524                         break
3525                 }
3526                 v.reset(OpRISCV64MOVDreg)
3527                 v.AddArg(x)
3528                 return true
3529         }
3530         // match: (MOVHUreg x:(MOVHUload _ _))
3531         // result: (MOVDreg x)
3532         for {
3533                 x := v_0
3534                 if x.Op != OpRISCV64MOVHUload {
3535                         break
3536                 }
3537                 v.reset(OpRISCV64MOVDreg)
3538                 v.AddArg(x)
3539                 return true
3540         }
3541         // match: (MOVHUreg x:(MOVBUreg _))
3542         // result: (MOVDreg x)
3543         for {
3544                 x := v_0
3545                 if x.Op != OpRISCV64MOVBUreg {
3546                         break
3547                 }
3548                 v.reset(OpRISCV64MOVDreg)
3549                 v.AddArg(x)
3550                 return true
3551         }
3552         // match: (MOVHUreg x:(MOVHUreg _))
3553         // result: (MOVDreg x)
3554         for {
3555                 x := v_0
3556                 if x.Op != OpRISCV64MOVHUreg {
3557                         break
3558                 }
3559                 v.reset(OpRISCV64MOVDreg)
3560                 v.AddArg(x)
3561                 return true
3562         }
3563         // match: (MOVHUreg <t> x:(MOVHload [off] {sym} ptr mem))
3564         // cond: x.Uses == 1 && clobber(x)
3565         // result: @x.Block (MOVHUload <t> [off] {sym} ptr mem)
3566         for {
3567                 t := v.Type
3568                 x := v_0
3569                 if x.Op != OpRISCV64MOVHload {
3570                         break
3571                 }
3572                 off := auxIntToInt32(x.AuxInt)
3573                 sym := auxToSym(x.Aux)
3574                 mem := x.Args[1]
3575                 ptr := x.Args[0]
3576                 if !(x.Uses == 1 && clobber(x)) {
3577                         break
3578                 }
3579                 b = x.Block
3580                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHUload, t)
3581                 v.copyOf(v0)
3582                 v0.AuxInt = int32ToAuxInt(off)
3583                 v0.Aux = symToAux(sym)
3584                 v0.AddArg2(ptr, mem)
3585                 return true
3586         }
3587         return false
3588 }
3589 func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
3590         v_1 := v.Args[1]
3591         v_0 := v.Args[0]
3592         // match: (MOVHload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
3593         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3594         // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} base mem)
3595         for {
3596                 off1 := auxIntToInt32(v.AuxInt)
3597                 sym1 := auxToSym(v.Aux)
3598                 if v_0.Op != OpRISCV64MOVaddr {
3599                         break
3600                 }
3601                 off2 := auxIntToInt32(v_0.AuxInt)
3602                 sym2 := auxToSym(v_0.Aux)
3603                 base := v_0.Args[0]
3604                 mem := v_1
3605                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3606                         break
3607                 }
3608                 v.reset(OpRISCV64MOVHload)
3609                 v.AuxInt = int32ToAuxInt(off1 + off2)
3610                 v.Aux = symToAux(mergeSym(sym1, sym2))
3611                 v.AddArg2(base, mem)
3612                 return true
3613         }
3614         // match: (MOVHload [off1] {sym} (ADDI [off2] base) mem)
3615         // cond: is32Bit(int64(off1)+off2)
3616         // result: (MOVHload [off1+int32(off2)] {sym} base mem)
3617         for {
3618                 off1 := auxIntToInt32(v.AuxInt)
3619                 sym := auxToSym(v.Aux)
3620                 if v_0.Op != OpRISCV64ADDI {
3621                         break
3622                 }
3623                 off2 := auxIntToInt64(v_0.AuxInt)
3624                 base := v_0.Args[0]
3625                 mem := v_1
3626                 if !(is32Bit(int64(off1) + off2)) {
3627                         break
3628                 }
3629                 v.reset(OpRISCV64MOVHload)
3630                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3631                 v.Aux = symToAux(sym)
3632                 v.AddArg2(base, mem)
3633                 return true
3634         }
3635         return false
3636 }
3637 func rewriteValueRISCV64_OpRISCV64MOVHreg(v *Value) bool {
3638         v_0 := v.Args[0]
3639         b := v.Block
3640         // match: (MOVHreg (MOVDconst [c]))
3641         // result: (MOVDconst [int64(int16(c))])
3642         for {
3643                 if v_0.Op != OpRISCV64MOVDconst {
3644                         break
3645                 }
3646                 c := auxIntToInt64(v_0.AuxInt)
3647                 v.reset(OpRISCV64MOVDconst)
3648                 v.AuxInt = int64ToAuxInt(int64(int16(c)))
3649                 return true
3650         }
3651         // match: (MOVHreg x:(MOVBload _ _))
3652         // result: (MOVDreg x)
3653         for {
3654                 x := v_0
3655                 if x.Op != OpRISCV64MOVBload {
3656                         break
3657                 }
3658                 v.reset(OpRISCV64MOVDreg)
3659                 v.AddArg(x)
3660                 return true
3661         }
3662         // match: (MOVHreg x:(MOVBUload _ _))
3663         // result: (MOVDreg x)
3664         for {
3665                 x := v_0
3666                 if x.Op != OpRISCV64MOVBUload {
3667                         break
3668                 }
3669                 v.reset(OpRISCV64MOVDreg)
3670                 v.AddArg(x)
3671                 return true
3672         }
3673         // match: (MOVHreg x:(MOVHload _ _))
3674         // result: (MOVDreg x)
3675         for {
3676                 x := v_0
3677                 if x.Op != OpRISCV64MOVHload {
3678                         break
3679                 }
3680                 v.reset(OpRISCV64MOVDreg)
3681                 v.AddArg(x)
3682                 return true
3683         }
3684         // match: (MOVHreg x:(MOVBreg _))
3685         // result: (MOVDreg x)
3686         for {
3687                 x := v_0
3688                 if x.Op != OpRISCV64MOVBreg {
3689                         break
3690                 }
3691                 v.reset(OpRISCV64MOVDreg)
3692                 v.AddArg(x)
3693                 return true
3694         }
3695         // match: (MOVHreg x:(MOVBUreg _))
3696         // result: (MOVDreg x)
3697         for {
3698                 x := v_0
3699                 if x.Op != OpRISCV64MOVBUreg {
3700                         break
3701                 }
3702                 v.reset(OpRISCV64MOVDreg)
3703                 v.AddArg(x)
3704                 return true
3705         }
3706         // match: (MOVHreg x:(MOVHreg _))
3707         // result: (MOVDreg x)
3708         for {
3709                 x := v_0
3710                 if x.Op != OpRISCV64MOVHreg {
3711                         break
3712                 }
3713                 v.reset(OpRISCV64MOVDreg)
3714                 v.AddArg(x)
3715                 return true
3716         }
3717         // match: (MOVHreg <t> x:(MOVHUload [off] {sym} ptr mem))
3718         // cond: x.Uses == 1 && clobber(x)
3719         // result: @x.Block (MOVHload <t> [off] {sym} ptr mem)
3720         for {
3721                 t := v.Type
3722                 x := v_0
3723                 if x.Op != OpRISCV64MOVHUload {
3724                         break
3725                 }
3726                 off := auxIntToInt32(x.AuxInt)
3727                 sym := auxToSym(x.Aux)
3728                 mem := x.Args[1]
3729                 ptr := x.Args[0]
3730                 if !(x.Uses == 1 && clobber(x)) {
3731                         break
3732                 }
3733                 b = x.Block
3734                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVHload, t)
3735                 v.copyOf(v0)
3736                 v0.AuxInt = int32ToAuxInt(off)
3737                 v0.Aux = symToAux(sym)
3738                 v0.AddArg2(ptr, mem)
3739                 return true
3740         }
3741         return false
3742 }
3743 func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
3744         v_2 := v.Args[2]
3745         v_1 := v.Args[1]
3746         v_0 := v.Args[0]
3747         // match: (MOVHstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
3748         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3749         // result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
3750         for {
3751                 off1 := auxIntToInt32(v.AuxInt)
3752                 sym1 := auxToSym(v.Aux)
3753                 if v_0.Op != OpRISCV64MOVaddr {
3754                         break
3755                 }
3756                 off2 := auxIntToInt32(v_0.AuxInt)
3757                 sym2 := auxToSym(v_0.Aux)
3758                 base := v_0.Args[0]
3759                 val := v_1
3760                 mem := v_2
3761                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3762                         break
3763                 }
3764                 v.reset(OpRISCV64MOVHstore)
3765                 v.AuxInt = int32ToAuxInt(off1 + off2)
3766                 v.Aux = symToAux(mergeSym(sym1, sym2))
3767                 v.AddArg3(base, val, mem)
3768                 return true
3769         }
3770         // match: (MOVHstore [off1] {sym} (ADDI [off2] base) val mem)
3771         // cond: is32Bit(int64(off1)+off2)
3772         // result: (MOVHstore [off1+int32(off2)] {sym} base val mem)
3773         for {
3774                 off1 := auxIntToInt32(v.AuxInt)
3775                 sym := auxToSym(v.Aux)
3776                 if v_0.Op != OpRISCV64ADDI {
3777                         break
3778                 }
3779                 off2 := auxIntToInt64(v_0.AuxInt)
3780                 base := v_0.Args[0]
3781                 val := v_1
3782                 mem := v_2
3783                 if !(is32Bit(int64(off1) + off2)) {
3784                         break
3785                 }
3786                 v.reset(OpRISCV64MOVHstore)
3787                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3788                 v.Aux = symToAux(sym)
3789                 v.AddArg3(base, val, mem)
3790                 return true
3791         }
3792         // match: (MOVHstore [off] {sym} ptr (MOVDconst [0]) mem)
3793         // result: (MOVHstorezero [off] {sym} ptr mem)
3794         for {
3795                 off := auxIntToInt32(v.AuxInt)
3796                 sym := auxToSym(v.Aux)
3797                 ptr := v_0
3798                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
3799                         break
3800                 }
3801                 mem := v_2
3802                 v.reset(OpRISCV64MOVHstorezero)
3803                 v.AuxInt = int32ToAuxInt(off)
3804                 v.Aux = symToAux(sym)
3805                 v.AddArg2(ptr, mem)
3806                 return true
3807         }
3808         // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
3809         // result: (MOVHstore [off] {sym} ptr x mem)
3810         for {
3811                 off := auxIntToInt32(v.AuxInt)
3812                 sym := auxToSym(v.Aux)
3813                 ptr := v_0
3814                 if v_1.Op != OpRISCV64MOVHreg {
3815                         break
3816                 }
3817                 x := v_1.Args[0]
3818                 mem := v_2
3819                 v.reset(OpRISCV64MOVHstore)
3820                 v.AuxInt = int32ToAuxInt(off)
3821                 v.Aux = symToAux(sym)
3822                 v.AddArg3(ptr, x, mem)
3823                 return true
3824         }
3825         // match: (MOVHstore [off] {sym} ptr (MOVWreg x) mem)
3826         // result: (MOVHstore [off] {sym} ptr x mem)
3827         for {
3828                 off := auxIntToInt32(v.AuxInt)
3829                 sym := auxToSym(v.Aux)
3830                 ptr := v_0
3831                 if v_1.Op != OpRISCV64MOVWreg {
3832                         break
3833                 }
3834                 x := v_1.Args[0]
3835                 mem := v_2
3836                 v.reset(OpRISCV64MOVHstore)
3837                 v.AuxInt = int32ToAuxInt(off)
3838                 v.Aux = symToAux(sym)
3839                 v.AddArg3(ptr, x, mem)
3840                 return true
3841         }
3842         // match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem)
3843         // result: (MOVHstore [off] {sym} ptr x mem)
3844         for {
3845                 off := auxIntToInt32(v.AuxInt)
3846                 sym := auxToSym(v.Aux)
3847                 ptr := v_0
3848                 if v_1.Op != OpRISCV64MOVHUreg {
3849                         break
3850                 }
3851                 x := v_1.Args[0]
3852                 mem := v_2
3853                 v.reset(OpRISCV64MOVHstore)
3854                 v.AuxInt = int32ToAuxInt(off)
3855                 v.Aux = symToAux(sym)
3856                 v.AddArg3(ptr, x, mem)
3857                 return true
3858         }
3859         // match: (MOVHstore [off] {sym} ptr (MOVWUreg x) mem)
3860         // result: (MOVHstore [off] {sym} ptr x mem)
3861         for {
3862                 off := auxIntToInt32(v.AuxInt)
3863                 sym := auxToSym(v.Aux)
3864                 ptr := v_0
3865                 if v_1.Op != OpRISCV64MOVWUreg {
3866                         break
3867                 }
3868                 x := v_1.Args[0]
3869                 mem := v_2
3870                 v.reset(OpRISCV64MOVHstore)
3871                 v.AuxInt = int32ToAuxInt(off)
3872                 v.Aux = symToAux(sym)
3873                 v.AddArg3(ptr, x, mem)
3874                 return true
3875         }
3876         return false
3877 }
3878 func rewriteValueRISCV64_OpRISCV64MOVHstorezero(v *Value) bool {
3879         v_1 := v.Args[1]
3880         v_0 := v.Args[0]
3881         // match: (MOVHstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
3882         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
3883         // result: (MOVHstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
3884         for {
3885                 off1 := auxIntToInt32(v.AuxInt)
3886                 sym1 := auxToSym(v.Aux)
3887                 if v_0.Op != OpRISCV64MOVaddr {
3888                         break
3889                 }
3890                 off2 := auxIntToInt32(v_0.AuxInt)
3891                 sym2 := auxToSym(v_0.Aux)
3892                 ptr := v_0.Args[0]
3893                 mem := v_1
3894                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
3895                         break
3896                 }
3897                 v.reset(OpRISCV64MOVHstorezero)
3898                 v.AuxInt = int32ToAuxInt(off1 + off2)
3899                 v.Aux = symToAux(mergeSym(sym1, sym2))
3900                 v.AddArg2(ptr, mem)
3901                 return true
3902         }
3903         // match: (MOVHstorezero [off1] {sym} (ADDI [off2] ptr) mem)
3904         // cond: is32Bit(int64(off1)+off2)
3905         // result: (MOVHstorezero [off1+int32(off2)] {sym} ptr mem)
3906         for {
3907                 off1 := auxIntToInt32(v.AuxInt)
3908                 sym := auxToSym(v.Aux)
3909                 if v_0.Op != OpRISCV64ADDI {
3910                         break
3911                 }
3912                 off2 := auxIntToInt64(v_0.AuxInt)
3913                 ptr := v_0.Args[0]
3914                 mem := v_1
3915                 if !(is32Bit(int64(off1) + off2)) {
3916                         break
3917                 }
3918                 v.reset(OpRISCV64MOVHstorezero)
3919                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3920                 v.Aux = symToAux(sym)
3921                 v.AddArg2(ptr, mem)
3922                 return true
3923         }
3924         return false
3925 }
3926 func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
3927         v_1 := v.Args[1]
3928         v_0 := v.Args[0]
3929         // match: (MOVWUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
3930         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
3931         // result: (MOVWUload [off1+off2] {mergeSym(sym1,sym2)} base mem)
3932         for {
3933                 off1 := auxIntToInt32(v.AuxInt)
3934                 sym1 := auxToSym(v.Aux)
3935                 if v_0.Op != OpRISCV64MOVaddr {
3936                         break
3937                 }
3938                 off2 := auxIntToInt32(v_0.AuxInt)
3939                 sym2 := auxToSym(v_0.Aux)
3940                 base := v_0.Args[0]
3941                 mem := v_1
3942                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
3943                         break
3944                 }
3945                 v.reset(OpRISCV64MOVWUload)
3946                 v.AuxInt = int32ToAuxInt(off1 + off2)
3947                 v.Aux = symToAux(mergeSym(sym1, sym2))
3948                 v.AddArg2(base, mem)
3949                 return true
3950         }
3951         // match: (MOVWUload [off1] {sym} (ADDI [off2] base) mem)
3952         // cond: is32Bit(int64(off1)+off2)
3953         // result: (MOVWUload [off1+int32(off2)] {sym} base mem)
3954         for {
3955                 off1 := auxIntToInt32(v.AuxInt)
3956                 sym := auxToSym(v.Aux)
3957                 if v_0.Op != OpRISCV64ADDI {
3958                         break
3959                 }
3960                 off2 := auxIntToInt64(v_0.AuxInt)
3961                 base := v_0.Args[0]
3962                 mem := v_1
3963                 if !(is32Bit(int64(off1) + off2)) {
3964                         break
3965                 }
3966                 v.reset(OpRISCV64MOVWUload)
3967                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
3968                 v.Aux = symToAux(sym)
3969                 v.AddArg2(base, mem)
3970                 return true
3971         }
3972         return false
3973 }
3974 func rewriteValueRISCV64_OpRISCV64MOVWUreg(v *Value) bool {
3975         v_0 := v.Args[0]
3976         b := v.Block
3977         // match: (MOVWUreg (MOVDconst [c]))
3978         // result: (MOVDconst [int64(uint32(c))])
3979         for {
3980                 if v_0.Op != OpRISCV64MOVDconst {
3981                         break
3982                 }
3983                 c := auxIntToInt64(v_0.AuxInt)
3984                 v.reset(OpRISCV64MOVDconst)
3985                 v.AuxInt = int64ToAuxInt(int64(uint32(c)))
3986                 return true
3987         }
3988         // match: (MOVWUreg x:(MOVBUload _ _))
3989         // result: (MOVDreg x)
3990         for {
3991                 x := v_0
3992                 if x.Op != OpRISCV64MOVBUload {
3993                         break
3994                 }
3995                 v.reset(OpRISCV64MOVDreg)
3996                 v.AddArg(x)
3997                 return true
3998         }
3999         // match: (MOVWUreg x:(MOVHUload _ _))
4000         // result: (MOVDreg x)
4001         for {
4002                 x := v_0
4003                 if x.Op != OpRISCV64MOVHUload {
4004                         break
4005                 }
4006                 v.reset(OpRISCV64MOVDreg)
4007                 v.AddArg(x)
4008                 return true
4009         }
4010         // match: (MOVWUreg x:(MOVWUload _ _))
4011         // result: (MOVDreg x)
4012         for {
4013                 x := v_0
4014                 if x.Op != OpRISCV64MOVWUload {
4015                         break
4016                 }
4017                 v.reset(OpRISCV64MOVDreg)
4018                 v.AddArg(x)
4019                 return true
4020         }
4021         // match: (MOVWUreg x:(MOVBUreg _))
4022         // result: (MOVDreg x)
4023         for {
4024                 x := v_0
4025                 if x.Op != OpRISCV64MOVBUreg {
4026                         break
4027                 }
4028                 v.reset(OpRISCV64MOVDreg)
4029                 v.AddArg(x)
4030                 return true
4031         }
4032         // match: (MOVWUreg x:(MOVHUreg _))
4033         // result: (MOVDreg x)
4034         for {
4035                 x := v_0
4036                 if x.Op != OpRISCV64MOVHUreg {
4037                         break
4038                 }
4039                 v.reset(OpRISCV64MOVDreg)
4040                 v.AddArg(x)
4041                 return true
4042         }
4043         // match: (MOVWUreg x:(MOVWUreg _))
4044         // result: (MOVDreg x)
4045         for {
4046                 x := v_0
4047                 if x.Op != OpRISCV64MOVWUreg {
4048                         break
4049                 }
4050                 v.reset(OpRISCV64MOVDreg)
4051                 v.AddArg(x)
4052                 return true
4053         }
4054         // match: (MOVWUreg <t> x:(MOVWload [off] {sym} ptr mem))
4055         // cond: x.Uses == 1 && clobber(x)
4056         // result: @x.Block (MOVWUload <t> [off] {sym} ptr mem)
4057         for {
4058                 t := v.Type
4059                 x := v_0
4060                 if x.Op != OpRISCV64MOVWload {
4061                         break
4062                 }
4063                 off := auxIntToInt32(x.AuxInt)
4064                 sym := auxToSym(x.Aux)
4065                 mem := x.Args[1]
4066                 ptr := x.Args[0]
4067                 if !(x.Uses == 1 && clobber(x)) {
4068                         break
4069                 }
4070                 b = x.Block
4071                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWUload, t)
4072                 v.copyOf(v0)
4073                 v0.AuxInt = int32ToAuxInt(off)
4074                 v0.Aux = symToAux(sym)
4075                 v0.AddArg2(ptr, mem)
4076                 return true
4077         }
4078         return false
4079 }
4080 func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
4081         v_1 := v.Args[1]
4082         v_0 := v.Args[0]
4083         // match: (MOVWload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
4084         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4085         // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem)
4086         for {
4087                 off1 := auxIntToInt32(v.AuxInt)
4088                 sym1 := auxToSym(v.Aux)
4089                 if v_0.Op != OpRISCV64MOVaddr {
4090                         break
4091                 }
4092                 off2 := auxIntToInt32(v_0.AuxInt)
4093                 sym2 := auxToSym(v_0.Aux)
4094                 base := v_0.Args[0]
4095                 mem := v_1
4096                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4097                         break
4098                 }
4099                 v.reset(OpRISCV64MOVWload)
4100                 v.AuxInt = int32ToAuxInt(off1 + off2)
4101                 v.Aux = symToAux(mergeSym(sym1, sym2))
4102                 v.AddArg2(base, mem)
4103                 return true
4104         }
4105         // match: (MOVWload [off1] {sym} (ADDI [off2] base) mem)
4106         // cond: is32Bit(int64(off1)+off2)
4107         // result: (MOVWload [off1+int32(off2)] {sym} base mem)
4108         for {
4109                 off1 := auxIntToInt32(v.AuxInt)
4110                 sym := auxToSym(v.Aux)
4111                 if v_0.Op != OpRISCV64ADDI {
4112                         break
4113                 }
4114                 off2 := auxIntToInt64(v_0.AuxInt)
4115                 base := v_0.Args[0]
4116                 mem := v_1
4117                 if !(is32Bit(int64(off1) + off2)) {
4118                         break
4119                 }
4120                 v.reset(OpRISCV64MOVWload)
4121                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4122                 v.Aux = symToAux(sym)
4123                 v.AddArg2(base, mem)
4124                 return true
4125         }
4126         return false
4127 }
4128 func rewriteValueRISCV64_OpRISCV64MOVWreg(v *Value) bool {
4129         v_0 := v.Args[0]
4130         b := v.Block
4131         // match: (MOVWreg (MOVDconst [c]))
4132         // result: (MOVDconst [int64(int32(c))])
4133         for {
4134                 if v_0.Op != OpRISCV64MOVDconst {
4135                         break
4136                 }
4137                 c := auxIntToInt64(v_0.AuxInt)
4138                 v.reset(OpRISCV64MOVDconst)
4139                 v.AuxInt = int64ToAuxInt(int64(int32(c)))
4140                 return true
4141         }
4142         // match: (MOVWreg x:(MOVBload _ _))
4143         // result: (MOVDreg x)
4144         for {
4145                 x := v_0
4146                 if x.Op != OpRISCV64MOVBload {
4147                         break
4148                 }
4149                 v.reset(OpRISCV64MOVDreg)
4150                 v.AddArg(x)
4151                 return true
4152         }
4153         // match: (MOVWreg x:(MOVBUload _ _))
4154         // result: (MOVDreg x)
4155         for {
4156                 x := v_0
4157                 if x.Op != OpRISCV64MOVBUload {
4158                         break
4159                 }
4160                 v.reset(OpRISCV64MOVDreg)
4161                 v.AddArg(x)
4162                 return true
4163         }
4164         // match: (MOVWreg x:(MOVHload _ _))
4165         // result: (MOVDreg x)
4166         for {
4167                 x := v_0
4168                 if x.Op != OpRISCV64MOVHload {
4169                         break
4170                 }
4171                 v.reset(OpRISCV64MOVDreg)
4172                 v.AddArg(x)
4173                 return true
4174         }
4175         // match: (MOVWreg x:(MOVHUload _ _))
4176         // result: (MOVDreg x)
4177         for {
4178                 x := v_0
4179                 if x.Op != OpRISCV64MOVHUload {
4180                         break
4181                 }
4182                 v.reset(OpRISCV64MOVDreg)
4183                 v.AddArg(x)
4184                 return true
4185         }
4186         // match: (MOVWreg x:(MOVWload _ _))
4187         // result: (MOVDreg x)
4188         for {
4189                 x := v_0
4190                 if x.Op != OpRISCV64MOVWload {
4191                         break
4192                 }
4193                 v.reset(OpRISCV64MOVDreg)
4194                 v.AddArg(x)
4195                 return true
4196         }
4197         // match: (MOVWreg x:(MOVBreg _))
4198         // result: (MOVDreg x)
4199         for {
4200                 x := v_0
4201                 if x.Op != OpRISCV64MOVBreg {
4202                         break
4203                 }
4204                 v.reset(OpRISCV64MOVDreg)
4205                 v.AddArg(x)
4206                 return true
4207         }
4208         // match: (MOVWreg x:(MOVBUreg _))
4209         // result: (MOVDreg x)
4210         for {
4211                 x := v_0
4212                 if x.Op != OpRISCV64MOVBUreg {
4213                         break
4214                 }
4215                 v.reset(OpRISCV64MOVDreg)
4216                 v.AddArg(x)
4217                 return true
4218         }
4219         // match: (MOVWreg x:(MOVHreg _))
4220         // result: (MOVDreg x)
4221         for {
4222                 x := v_0
4223                 if x.Op != OpRISCV64MOVHreg {
4224                         break
4225                 }
4226                 v.reset(OpRISCV64MOVDreg)
4227                 v.AddArg(x)
4228                 return true
4229         }
4230         // match: (MOVWreg x:(MOVWreg _))
4231         // result: (MOVDreg x)
4232         for {
4233                 x := v_0
4234                 if x.Op != OpRISCV64MOVWreg {
4235                         break
4236                 }
4237                 v.reset(OpRISCV64MOVDreg)
4238                 v.AddArg(x)
4239                 return true
4240         }
4241         // match: (MOVWreg <t> x:(MOVWUload [off] {sym} ptr mem))
4242         // cond: x.Uses == 1 && clobber(x)
4243         // result: @x.Block (MOVWload <t> [off] {sym} ptr mem)
4244         for {
4245                 t := v.Type
4246                 x := v_0
4247                 if x.Op != OpRISCV64MOVWUload {
4248                         break
4249                 }
4250                 off := auxIntToInt32(x.AuxInt)
4251                 sym := auxToSym(x.Aux)
4252                 mem := x.Args[1]
4253                 ptr := x.Args[0]
4254                 if !(x.Uses == 1 && clobber(x)) {
4255                         break
4256                 }
4257                 b = x.Block
4258                 v0 := b.NewValue0(x.Pos, OpRISCV64MOVWload, t)
4259                 v.copyOf(v0)
4260                 v0.AuxInt = int32ToAuxInt(off)
4261                 v0.Aux = symToAux(sym)
4262                 v0.AddArg2(ptr, mem)
4263                 return true
4264         }
4265         return false
4266 }
4267 func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
4268         v_2 := v.Args[2]
4269         v_1 := v.Args[1]
4270         v_0 := v.Args[0]
4271         // match: (MOVWstore [off1] {sym1} (MOVaddr [off2] {sym2} base) val mem)
4272         // cond: is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)
4273         // result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
4274         for {
4275                 off1 := auxIntToInt32(v.AuxInt)
4276                 sym1 := auxToSym(v.Aux)
4277                 if v_0.Op != OpRISCV64MOVaddr {
4278                         break
4279                 }
4280                 off2 := auxIntToInt32(v_0.AuxInt)
4281                 sym2 := auxToSym(v_0.Aux)
4282                 base := v_0.Args[0]
4283                 val := v_1
4284                 mem := v_2
4285                 if !(is32Bit(int64(off1)+int64(off2)) && canMergeSym(sym1, sym2)) {
4286                         break
4287                 }
4288                 v.reset(OpRISCV64MOVWstore)
4289                 v.AuxInt = int32ToAuxInt(off1 + off2)
4290                 v.Aux = symToAux(mergeSym(sym1, sym2))
4291                 v.AddArg3(base, val, mem)
4292                 return true
4293         }
4294         // match: (MOVWstore [off1] {sym} (ADDI [off2] base) val mem)
4295         // cond: is32Bit(int64(off1)+off2)
4296         // result: (MOVWstore [off1+int32(off2)] {sym} base val mem)
4297         for {
4298                 off1 := auxIntToInt32(v.AuxInt)
4299                 sym := auxToSym(v.Aux)
4300                 if v_0.Op != OpRISCV64ADDI {
4301                         break
4302                 }
4303                 off2 := auxIntToInt64(v_0.AuxInt)
4304                 base := v_0.Args[0]
4305                 val := v_1
4306                 mem := v_2
4307                 if !(is32Bit(int64(off1) + off2)) {
4308                         break
4309                 }
4310                 v.reset(OpRISCV64MOVWstore)
4311                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4312                 v.Aux = symToAux(sym)
4313                 v.AddArg3(base, val, mem)
4314                 return true
4315         }
4316         // match: (MOVWstore [off] {sym} ptr (MOVDconst [0]) mem)
4317         // result: (MOVWstorezero [off] {sym} ptr mem)
4318         for {
4319                 off := auxIntToInt32(v.AuxInt)
4320                 sym := auxToSym(v.Aux)
4321                 ptr := v_0
4322                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4323                         break
4324                 }
4325                 mem := v_2
4326                 v.reset(OpRISCV64MOVWstorezero)
4327                 v.AuxInt = int32ToAuxInt(off)
4328                 v.Aux = symToAux(sym)
4329                 v.AddArg2(ptr, mem)
4330                 return true
4331         }
4332         // match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
4333         // result: (MOVWstore [off] {sym} ptr x mem)
4334         for {
4335                 off := auxIntToInt32(v.AuxInt)
4336                 sym := auxToSym(v.Aux)
4337                 ptr := v_0
4338                 if v_1.Op != OpRISCV64MOVWreg {
4339                         break
4340                 }
4341                 x := v_1.Args[0]
4342                 mem := v_2
4343                 v.reset(OpRISCV64MOVWstore)
4344                 v.AuxInt = int32ToAuxInt(off)
4345                 v.Aux = symToAux(sym)
4346                 v.AddArg3(ptr, x, mem)
4347                 return true
4348         }
4349         // match: (MOVWstore [off] {sym} ptr (MOVWUreg x) mem)
4350         // result: (MOVWstore [off] {sym} ptr x mem)
4351         for {
4352                 off := auxIntToInt32(v.AuxInt)
4353                 sym := auxToSym(v.Aux)
4354                 ptr := v_0
4355                 if v_1.Op != OpRISCV64MOVWUreg {
4356                         break
4357                 }
4358                 x := v_1.Args[0]
4359                 mem := v_2
4360                 v.reset(OpRISCV64MOVWstore)
4361                 v.AuxInt = int32ToAuxInt(off)
4362                 v.Aux = symToAux(sym)
4363                 v.AddArg3(ptr, x, mem)
4364                 return true
4365         }
4366         return false
4367 }
4368 func rewriteValueRISCV64_OpRISCV64MOVWstorezero(v *Value) bool {
4369         v_1 := v.Args[1]
4370         v_0 := v.Args[0]
4371         // match: (MOVWstorezero [off1] {sym1} (MOVaddr [off2] {sym2} ptr) mem)
4372         // cond: canMergeSym(sym1,sym2) && is32Bit(int64(off1)+int64(off2))
4373         // result: (MOVWstorezero [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
4374         for {
4375                 off1 := auxIntToInt32(v.AuxInt)
4376                 sym1 := auxToSym(v.Aux)
4377                 if v_0.Op != OpRISCV64MOVaddr {
4378                         break
4379                 }
4380                 off2 := auxIntToInt32(v_0.AuxInt)
4381                 sym2 := auxToSym(v_0.Aux)
4382                 ptr := v_0.Args[0]
4383                 mem := v_1
4384                 if !(canMergeSym(sym1, sym2) && is32Bit(int64(off1)+int64(off2))) {
4385                         break
4386                 }
4387                 v.reset(OpRISCV64MOVWstorezero)
4388                 v.AuxInt = int32ToAuxInt(off1 + off2)
4389                 v.Aux = symToAux(mergeSym(sym1, sym2))
4390                 v.AddArg2(ptr, mem)
4391                 return true
4392         }
4393         // match: (MOVWstorezero [off1] {sym} (ADDI [off2] ptr) mem)
4394         // cond: is32Bit(int64(off1)+off2)
4395         // result: (MOVWstorezero [off1+int32(off2)] {sym} ptr mem)
4396         for {
4397                 off1 := auxIntToInt32(v.AuxInt)
4398                 sym := auxToSym(v.Aux)
4399                 if v_0.Op != OpRISCV64ADDI {
4400                         break
4401                 }
4402                 off2 := auxIntToInt64(v_0.AuxInt)
4403                 ptr := v_0.Args[0]
4404                 mem := v_1
4405                 if !(is32Bit(int64(off1) + off2)) {
4406                         break
4407                 }
4408                 v.reset(OpRISCV64MOVWstorezero)
4409                 v.AuxInt = int32ToAuxInt(off1 + int32(off2))
4410                 v.Aux = symToAux(sym)
4411                 v.AddArg2(ptr, mem)
4412                 return true
4413         }
4414         return false
4415 }
4416 func rewriteValueRISCV64_OpRISCV64OR(v *Value) bool {
4417         v_1 := v.Args[1]
4418         v_0 := v.Args[0]
4419         // match: (OR (MOVDconst [val]) x)
4420         // cond: is32Bit(val)
4421         // result: (ORI [val] x)
4422         for {
4423                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4424                         if v_0.Op != OpRISCV64MOVDconst {
4425                                 continue
4426                         }
4427                         val := auxIntToInt64(v_0.AuxInt)
4428                         x := v_1
4429                         if !(is32Bit(val)) {
4430                                 continue
4431                         }
4432                         v.reset(OpRISCV64ORI)
4433                         v.AuxInt = int64ToAuxInt(val)
4434                         v.AddArg(x)
4435                         return true
4436                 }
4437                 break
4438         }
4439         return false
4440 }
4441 func rewriteValueRISCV64_OpRISCV64SLL(v *Value) bool {
4442         v_1 := v.Args[1]
4443         v_0 := v.Args[0]
4444         // match: (SLL x (MOVDconst [val]))
4445         // result: (SLLI [int64(val&63)] x)
4446         for {
4447                 x := v_0
4448                 if v_1.Op != OpRISCV64MOVDconst {
4449                         break
4450                 }
4451                 val := auxIntToInt64(v_1.AuxInt)
4452                 v.reset(OpRISCV64SLLI)
4453                 v.AuxInt = int64ToAuxInt(int64(val & 63))
4454                 v.AddArg(x)
4455                 return true
4456         }
4457         return false
4458 }
4459 func rewriteValueRISCV64_OpRISCV64SRA(v *Value) bool {
4460         v_1 := v.Args[1]
4461         v_0 := v.Args[0]
4462         // match: (SRA x (MOVDconst [val]))
4463         // result: (SRAI [int64(val&63)] x)
4464         for {
4465                 x := v_0
4466                 if v_1.Op != OpRISCV64MOVDconst {
4467                         break
4468                 }
4469                 val := auxIntToInt64(v_1.AuxInt)
4470                 v.reset(OpRISCV64SRAI)
4471                 v.AuxInt = int64ToAuxInt(int64(val & 63))
4472                 v.AddArg(x)
4473                 return true
4474         }
4475         return false
4476 }
4477 func rewriteValueRISCV64_OpRISCV64SRL(v *Value) bool {
4478         v_1 := v.Args[1]
4479         v_0 := v.Args[0]
4480         // match: (SRL x (MOVDconst [val]))
4481         // result: (SRLI [int64(val&63)] x)
4482         for {
4483                 x := v_0
4484                 if v_1.Op != OpRISCV64MOVDconst {
4485                         break
4486                 }
4487                 val := auxIntToInt64(v_1.AuxInt)
4488                 v.reset(OpRISCV64SRLI)
4489                 v.AuxInt = int64ToAuxInt(int64(val & 63))
4490                 v.AddArg(x)
4491                 return true
4492         }
4493         return false
4494 }
4495 func rewriteValueRISCV64_OpRISCV64SUB(v *Value) bool {
4496         v_1 := v.Args[1]
4497         v_0 := v.Args[0]
4498         // match: (SUB x (MOVDconst [val]))
4499         // cond: is32Bit(-val)
4500         // result: (ADDI [-val] x)
4501         for {
4502                 x := v_0
4503                 if v_1.Op != OpRISCV64MOVDconst {
4504                         break
4505                 }
4506                 val := auxIntToInt64(v_1.AuxInt)
4507                 if !(is32Bit(-val)) {
4508                         break
4509                 }
4510                 v.reset(OpRISCV64ADDI)
4511                 v.AuxInt = int64ToAuxInt(-val)
4512                 v.AddArg(x)
4513                 return true
4514         }
4515         // match: (SUB x (MOVDconst [0]))
4516         // result: x
4517         for {
4518                 x := v_0
4519                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4520                         break
4521                 }
4522                 v.copyOf(x)
4523                 return true
4524         }
4525         // match: (SUB (MOVDconst [0]) x)
4526         // result: (NEG x)
4527         for {
4528                 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
4529                         break
4530                 }
4531                 x := v_1
4532                 v.reset(OpRISCV64NEG)
4533                 v.AddArg(x)
4534                 return true
4535         }
4536         return false
4537 }
4538 func rewriteValueRISCV64_OpRISCV64SUBW(v *Value) bool {
4539         v_1 := v.Args[1]
4540         v_0 := v.Args[0]
4541         // match: (SUBW x (MOVDconst [0]))
4542         // result: (ADDIW [0] x)
4543         for {
4544                 x := v_0
4545                 if v_1.Op != OpRISCV64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
4546                         break
4547                 }
4548                 v.reset(OpRISCV64ADDIW)
4549                 v.AuxInt = int64ToAuxInt(0)
4550                 v.AddArg(x)
4551                 return true
4552         }
4553         // match: (SUBW (MOVDconst [0]) x)
4554         // result: (NEGW x)
4555         for {
4556                 if v_0.Op != OpRISCV64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
4557                         break
4558                 }
4559                 x := v_1
4560                 v.reset(OpRISCV64NEGW)
4561                 v.AddArg(x)
4562                 return true
4563         }
4564         return false
4565 }
4566 func rewriteValueRISCV64_OpRISCV64XOR(v *Value) bool {
4567         v_1 := v.Args[1]
4568         v_0 := v.Args[0]
4569         // match: (XOR (MOVDconst [val]) x)
4570         // cond: is32Bit(val)
4571         // result: (XORI [val] x)
4572         for {
4573                 for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
4574                         if v_0.Op != OpRISCV64MOVDconst {
4575                                 continue
4576                         }
4577                         val := auxIntToInt64(v_0.AuxInt)
4578                         x := v_1
4579                         if !(is32Bit(val)) {
4580                                 continue
4581                         }
4582                         v.reset(OpRISCV64XORI)
4583                         v.AuxInt = int64ToAuxInt(val)
4584                         v.AddArg(x)
4585                         return true
4586                 }
4587                 break
4588         }
4589         return false
4590 }
4591 func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
4592         v_1 := v.Args[1]
4593         v_0 := v.Args[0]
4594         b := v.Block
4595         typ := &b.Func.Config.Types
4596         // match: (RotateLeft16 <t> x (MOVDconst [c]))
4597         // result: (Or16 (Lsh16x64 <t> x (MOVDconst [c&15])) (Rsh16Ux64 <t> x (MOVDconst [-c&15])))
4598         for {
4599                 t := v.Type
4600                 x := v_0
4601                 if v_1.Op != OpRISCV64MOVDconst {
4602                         break
4603                 }
4604                 c := auxIntToInt64(v_1.AuxInt)
4605                 v.reset(OpOr16)
4606                 v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
4607                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4608                 v1.AuxInt = int64ToAuxInt(c & 15)
4609                 v0.AddArg2(x, v1)
4610                 v2 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
4611                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4612                 v3.AuxInt = int64ToAuxInt(-c & 15)
4613                 v2.AddArg2(x, v3)
4614                 v.AddArg2(v0, v2)
4615                 return true
4616         }
4617         return false
4618 }
4619 func rewriteValueRISCV64_OpRotateLeft32(v *Value) bool {
4620         v_1 := v.Args[1]
4621         v_0 := v.Args[0]
4622         b := v.Block
4623         typ := &b.Func.Config.Types
4624         // match: (RotateLeft32 <t> x (MOVDconst [c]))
4625         // result: (Or32 (Lsh32x64 <t> x (MOVDconst [c&31])) (Rsh32Ux64 <t> x (MOVDconst [-c&31])))
4626         for {
4627                 t := v.Type
4628                 x := v_0
4629                 if v_1.Op != OpRISCV64MOVDconst {
4630                         break
4631                 }
4632                 c := auxIntToInt64(v_1.AuxInt)
4633                 v.reset(OpOr32)
4634                 v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
4635                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4636                 v1.AuxInt = int64ToAuxInt(c & 31)
4637                 v0.AddArg2(x, v1)
4638                 v2 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
4639                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4640                 v3.AuxInt = int64ToAuxInt(-c & 31)
4641                 v2.AddArg2(x, v3)
4642                 v.AddArg2(v0, v2)
4643                 return true
4644         }
4645         return false
4646 }
4647 func rewriteValueRISCV64_OpRotateLeft64(v *Value) bool {
4648         v_1 := v.Args[1]
4649         v_0 := v.Args[0]
4650         b := v.Block
4651         typ := &b.Func.Config.Types
4652         // match: (RotateLeft64 <t> x (MOVDconst [c]))
4653         // result: (Or64 (Lsh64x64 <t> x (MOVDconst [c&63])) (Rsh64Ux64 <t> x (MOVDconst [-c&63])))
4654         for {
4655                 t := v.Type
4656                 x := v_0
4657                 if v_1.Op != OpRISCV64MOVDconst {
4658                         break
4659                 }
4660                 c := auxIntToInt64(v_1.AuxInt)
4661                 v.reset(OpOr64)
4662                 v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
4663                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4664                 v1.AuxInt = int64ToAuxInt(c & 63)
4665                 v0.AddArg2(x, v1)
4666                 v2 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
4667                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4668                 v3.AuxInt = int64ToAuxInt(-c & 63)
4669                 v2.AddArg2(x, v3)
4670                 v.AddArg2(v0, v2)
4671                 return true
4672         }
4673         return false
4674 }
4675 func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
4676         v_1 := v.Args[1]
4677         v_0 := v.Args[0]
4678         b := v.Block
4679         typ := &b.Func.Config.Types
4680         // match: (RotateLeft8 <t> x (MOVDconst [c]))
4681         // result: (Or8 (Lsh8x64 <t> x (MOVDconst [c&7])) (Rsh8Ux64 <t> x (MOVDconst [-c&7])))
4682         for {
4683                 t := v.Type
4684                 x := v_0
4685                 if v_1.Op != OpRISCV64MOVDconst {
4686                         break
4687                 }
4688                 c := auxIntToInt64(v_1.AuxInt)
4689                 v.reset(OpOr8)
4690                 v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
4691                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4692                 v1.AuxInt = int64ToAuxInt(c & 7)
4693                 v0.AddArg2(x, v1)
4694                 v2 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
4695                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
4696                 v3.AuxInt = int64ToAuxInt(-c & 7)
4697                 v2.AddArg2(x, v3)
4698                 v.AddArg2(v0, v2)
4699                 return true
4700         }
4701         return false
4702 }
4703 func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
4704         v_1 := v.Args[1]
4705         v_0 := v.Args[0]
4706         b := v.Block
4707         typ := &b.Func.Config.Types
4708         // match: (Rsh16Ux16 <t> x y)
4709         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
4710         for {
4711                 t := v.Type
4712                 x := v_0
4713                 y := v_1
4714                 v.reset(OpRISCV64AND)
4715                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4716                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4717                 v1.AddArg(x)
4718                 v0.AddArg2(v1, y)
4719                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
4720                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4721                 v3.AuxInt = int64ToAuxInt(64)
4722                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4723                 v4.AddArg(y)
4724                 v3.AddArg(v4)
4725                 v2.AddArg(v3)
4726                 v.AddArg2(v0, v2)
4727                 return true
4728         }
4729 }
4730 func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
4731         v_1 := v.Args[1]
4732         v_0 := v.Args[0]
4733         b := v.Block
4734         typ := &b.Func.Config.Types
4735         // match: (Rsh16Ux32 <t> x y)
4736         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
4737         for {
4738                 t := v.Type
4739                 x := v_0
4740                 y := v_1
4741                 v.reset(OpRISCV64AND)
4742                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4743                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4744                 v1.AddArg(x)
4745                 v0.AddArg2(v1, y)
4746                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
4747                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4748                 v3.AuxInt = int64ToAuxInt(64)
4749                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4750                 v4.AddArg(y)
4751                 v3.AddArg(v4)
4752                 v2.AddArg(v3)
4753                 v.AddArg2(v0, v2)
4754                 return true
4755         }
4756 }
4757 func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
4758         v_1 := v.Args[1]
4759         v_0 := v.Args[0]
4760         b := v.Block
4761         typ := &b.Func.Config.Types
4762         // match: (Rsh16Ux64 <t> x y)
4763         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] y)))
4764         for {
4765                 t := v.Type
4766                 x := v_0
4767                 y := v_1
4768                 v.reset(OpRISCV64AND)
4769                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4770                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4771                 v1.AddArg(x)
4772                 v0.AddArg2(v1, y)
4773                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
4774                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4775                 v3.AuxInt = int64ToAuxInt(64)
4776                 v3.AddArg(y)
4777                 v2.AddArg(v3)
4778                 v.AddArg2(v0, v2)
4779                 return true
4780         }
4781 }
4782 func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
4783         v_1 := v.Args[1]
4784         v_0 := v.Args[0]
4785         b := v.Block
4786         typ := &b.Func.Config.Types
4787         // match: (Rsh16Ux8 <t> x y)
4788         // result: (AND (SRL <t> (ZeroExt16to64 x) y) (Neg16 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
4789         for {
4790                 t := v.Type
4791                 x := v_0
4792                 y := v_1
4793                 v.reset(OpRISCV64AND)
4794                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4795                 v1 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4796                 v1.AddArg(x)
4797                 v0.AddArg2(v1, y)
4798                 v2 := b.NewValue0(v.Pos, OpNeg16, t)
4799                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4800                 v3.AuxInt = int64ToAuxInt(64)
4801                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4802                 v4.AddArg(y)
4803                 v3.AddArg(v4)
4804                 v2.AddArg(v3)
4805                 v.AddArg2(v0, v2)
4806                 return true
4807         }
4808 }
4809 func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
4810         v_1 := v.Args[1]
4811         v_0 := v.Args[0]
4812         b := v.Block
4813         typ := &b.Func.Config.Types
4814         // match: (Rsh16x16 <t> x y)
4815         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
4816         for {
4817                 t := v.Type
4818                 x := v_0
4819                 y := v_1
4820                 v.reset(OpRISCV64SRA)
4821                 v.Type = t
4822                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
4823                 v0.AddArg(x)
4824                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
4825                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
4826                 v2.AuxInt = int64ToAuxInt(-1)
4827                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
4828                 v3.AuxInt = int64ToAuxInt(64)
4829                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4830                 v4.AddArg(y)
4831                 v3.AddArg(v4)
4832                 v2.AddArg(v3)
4833                 v1.AddArg2(y, v2)
4834                 v.AddArg2(v0, v1)
4835                 return true
4836         }
4837 }
4838 func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
4839         v_1 := v.Args[1]
4840         v_0 := v.Args[0]
4841         b := v.Block
4842         typ := &b.Func.Config.Types
4843         // match: (Rsh16x32 <t> x y)
4844         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
4845         for {
4846                 t := v.Type
4847                 x := v_0
4848                 y := v_1
4849                 v.reset(OpRISCV64SRA)
4850                 v.Type = t
4851                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
4852                 v0.AddArg(x)
4853                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
4854                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
4855                 v2.AuxInt = int64ToAuxInt(-1)
4856                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
4857                 v3.AuxInt = int64ToAuxInt(64)
4858                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4859                 v4.AddArg(y)
4860                 v3.AddArg(v4)
4861                 v2.AddArg(v3)
4862                 v1.AddArg2(y, v2)
4863                 v.AddArg2(v0, v1)
4864                 return true
4865         }
4866 }
4867 func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
4868         v_1 := v.Args[1]
4869         v_0 := v.Args[0]
4870         b := v.Block
4871         typ := &b.Func.Config.Types
4872         // match: (Rsh16x64 <t> x y)
4873         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
4874         for {
4875                 t := v.Type
4876                 x := v_0
4877                 y := v_1
4878                 v.reset(OpRISCV64SRA)
4879                 v.Type = t
4880                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
4881                 v0.AddArg(x)
4882                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
4883                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
4884                 v2.AuxInt = int64ToAuxInt(-1)
4885                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
4886                 v3.AuxInt = int64ToAuxInt(64)
4887                 v3.AddArg(y)
4888                 v2.AddArg(v3)
4889                 v1.AddArg2(y, v2)
4890                 v.AddArg2(v0, v1)
4891                 return true
4892         }
4893 }
4894 func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
4895         v_1 := v.Args[1]
4896         v_0 := v.Args[0]
4897         b := v.Block
4898         typ := &b.Func.Config.Types
4899         // match: (Rsh16x8 <t> x y)
4900         // result: (SRA <t> (SignExt16to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
4901         for {
4902                 t := v.Type
4903                 x := v_0
4904                 y := v_1
4905                 v.reset(OpRISCV64SRA)
4906                 v.Type = t
4907                 v0 := b.NewValue0(v.Pos, OpSignExt16to64, typ.Int64)
4908                 v0.AddArg(x)
4909                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
4910                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
4911                 v2.AuxInt = int64ToAuxInt(-1)
4912                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
4913                 v3.AuxInt = int64ToAuxInt(64)
4914                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
4915                 v4.AddArg(y)
4916                 v3.AddArg(v4)
4917                 v2.AddArg(v3)
4918                 v1.AddArg2(y, v2)
4919                 v.AddArg2(v0, v1)
4920                 return true
4921         }
4922 }
4923 func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
4924         v_1 := v.Args[1]
4925         v_0 := v.Args[0]
4926         b := v.Block
4927         typ := &b.Func.Config.Types
4928         // match: (Rsh32Ux16 <t> x y)
4929         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
4930         for {
4931                 t := v.Type
4932                 x := v_0
4933                 y := v_1
4934                 v.reset(OpRISCV64AND)
4935                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4936                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4937                 v1.AddArg(x)
4938                 v0.AddArg2(v1, y)
4939                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
4940                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4941                 v3.AuxInt = int64ToAuxInt(64)
4942                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
4943                 v4.AddArg(y)
4944                 v3.AddArg(v4)
4945                 v2.AddArg(v3)
4946                 v.AddArg2(v0, v2)
4947                 return true
4948         }
4949 }
4950 func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
4951         v_1 := v.Args[1]
4952         v_0 := v.Args[0]
4953         b := v.Block
4954         typ := &b.Func.Config.Types
4955         // match: (Rsh32Ux32 <t> x y)
4956         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
4957         for {
4958                 t := v.Type
4959                 x := v_0
4960                 y := v_1
4961                 v.reset(OpRISCV64AND)
4962                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4963                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4964                 v1.AddArg(x)
4965                 v0.AddArg2(v1, y)
4966                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
4967                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4968                 v3.AuxInt = int64ToAuxInt(64)
4969                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4970                 v4.AddArg(y)
4971                 v3.AddArg(v4)
4972                 v2.AddArg(v3)
4973                 v.AddArg2(v0, v2)
4974                 return true
4975         }
4976 }
4977 func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
4978         v_1 := v.Args[1]
4979         v_0 := v.Args[0]
4980         b := v.Block
4981         typ := &b.Func.Config.Types
4982         // match: (Rsh32Ux64 <t> x y)
4983         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] y)))
4984         for {
4985                 t := v.Type
4986                 x := v_0
4987                 y := v_1
4988                 v.reset(OpRISCV64AND)
4989                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
4990                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
4991                 v1.AddArg(x)
4992                 v0.AddArg2(v1, y)
4993                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
4994                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
4995                 v3.AuxInt = int64ToAuxInt(64)
4996                 v3.AddArg(y)
4997                 v2.AddArg(v3)
4998                 v.AddArg2(v0, v2)
4999                 return true
5000         }
5001 }
5002 func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
5003         v_1 := v.Args[1]
5004         v_0 := v.Args[0]
5005         b := v.Block
5006         typ := &b.Func.Config.Types
5007         // match: (Rsh32Ux8 <t> x y)
5008         // result: (AND (SRL <t> (ZeroExt32to64 x) y) (Neg32 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
5009         for {
5010                 t := v.Type
5011                 x := v_0
5012                 y := v_1
5013                 v.reset(OpRISCV64AND)
5014                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5015                 v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
5016                 v1.AddArg(x)
5017                 v0.AddArg2(v1, y)
5018                 v2 := b.NewValue0(v.Pos, OpNeg32, t)
5019                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5020                 v3.AuxInt = int64ToAuxInt(64)
5021                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5022                 v4.AddArg(y)
5023                 v3.AddArg(v4)
5024                 v2.AddArg(v3)
5025                 v.AddArg2(v0, v2)
5026                 return true
5027         }
5028 }
5029 func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
5030         v_1 := v.Args[1]
5031         v_0 := v.Args[0]
5032         b := v.Block
5033         typ := &b.Func.Config.Types
5034         // match: (Rsh32x16 <t> x y)
5035         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
5036         for {
5037                 t := v.Type
5038                 x := v_0
5039                 y := v_1
5040                 v.reset(OpRISCV64SRA)
5041                 v.Type = t
5042                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
5043                 v0.AddArg(x)
5044                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5045                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5046                 v2.AuxInt = int64ToAuxInt(-1)
5047                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5048                 v3.AuxInt = int64ToAuxInt(64)
5049                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
5050                 v4.AddArg(y)
5051                 v3.AddArg(v4)
5052                 v2.AddArg(v3)
5053                 v1.AddArg2(y, v2)
5054                 v.AddArg2(v0, v1)
5055                 return true
5056         }
5057 }
5058 func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
5059         v_1 := v.Args[1]
5060         v_0 := v.Args[0]
5061         b := v.Block
5062         typ := &b.Func.Config.Types
5063         // match: (Rsh32x32 <t> x y)
5064         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
5065         for {
5066                 t := v.Type
5067                 x := v_0
5068                 y := v_1
5069                 v.reset(OpRISCV64SRA)
5070                 v.Type = t
5071                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
5072                 v0.AddArg(x)
5073                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5074                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5075                 v2.AuxInt = int64ToAuxInt(-1)
5076                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5077                 v3.AuxInt = int64ToAuxInt(64)
5078                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
5079                 v4.AddArg(y)
5080                 v3.AddArg(v4)
5081                 v2.AddArg(v3)
5082                 v1.AddArg2(y, v2)
5083                 v.AddArg2(v0, v1)
5084                 return true
5085         }
5086 }
5087 func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
5088         v_1 := v.Args[1]
5089         v_0 := v.Args[0]
5090         b := v.Block
5091         typ := &b.Func.Config.Types
5092         // match: (Rsh32x64 <t> x y)
5093         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
5094         for {
5095                 t := v.Type
5096                 x := v_0
5097                 y := v_1
5098                 v.reset(OpRISCV64SRA)
5099                 v.Type = t
5100                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
5101                 v0.AddArg(x)
5102                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5103                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5104                 v2.AuxInt = int64ToAuxInt(-1)
5105                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5106                 v3.AuxInt = int64ToAuxInt(64)
5107                 v3.AddArg(y)
5108                 v2.AddArg(v3)
5109                 v1.AddArg2(y, v2)
5110                 v.AddArg2(v0, v1)
5111                 return true
5112         }
5113 }
5114 func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
5115         v_1 := v.Args[1]
5116         v_0 := v.Args[0]
5117         b := v.Block
5118         typ := &b.Func.Config.Types
5119         // match: (Rsh32x8 <t> x y)
5120         // result: (SRA <t> (SignExt32to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
5121         for {
5122                 t := v.Type
5123                 x := v_0
5124                 y := v_1
5125                 v.reset(OpRISCV64SRA)
5126                 v.Type = t
5127                 v0 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
5128                 v0.AddArg(x)
5129                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5130                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5131                 v2.AuxInt = int64ToAuxInt(-1)
5132                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5133                 v3.AuxInt = int64ToAuxInt(64)
5134                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5135                 v4.AddArg(y)
5136                 v3.AddArg(v4)
5137                 v2.AddArg(v3)
5138                 v1.AddArg2(y, v2)
5139                 v.AddArg2(v0, v1)
5140                 return true
5141         }
5142 }
5143 func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
5144         v_1 := v.Args[1]
5145         v_0 := v.Args[0]
5146         b := v.Block
5147         typ := &b.Func.Config.Types
5148         // match: (Rsh64Ux16 <t> x y)
5149         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
5150         for {
5151                 t := v.Type
5152                 x := v_0
5153                 y := v_1
5154                 v.reset(OpRISCV64AND)
5155                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5156                 v0.AddArg2(x, y)
5157                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
5158                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5159                 v2.AuxInt = int64ToAuxInt(64)
5160                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
5161                 v3.AddArg(y)
5162                 v2.AddArg(v3)
5163                 v1.AddArg(v2)
5164                 v.AddArg2(v0, v1)
5165                 return true
5166         }
5167 }
5168 func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
5169         v_1 := v.Args[1]
5170         v_0 := v.Args[0]
5171         b := v.Block
5172         typ := &b.Func.Config.Types
5173         // match: (Rsh64Ux32 <t> x y)
5174         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
5175         for {
5176                 t := v.Type
5177                 x := v_0
5178                 y := v_1
5179                 v.reset(OpRISCV64AND)
5180                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5181                 v0.AddArg2(x, y)
5182                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
5183                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5184                 v2.AuxInt = int64ToAuxInt(64)
5185                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
5186                 v3.AddArg(y)
5187                 v2.AddArg(v3)
5188                 v1.AddArg(v2)
5189                 v.AddArg2(v0, v1)
5190                 return true
5191         }
5192 }
5193 func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
5194         v_1 := v.Args[1]
5195         v_0 := v.Args[0]
5196         b := v.Block
5197         // match: (Rsh64Ux64 <t> x y)
5198         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] y)))
5199         for {
5200                 t := v.Type
5201                 x := v_0
5202                 y := v_1
5203                 v.reset(OpRISCV64AND)
5204                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5205                 v0.AddArg2(x, y)
5206                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
5207                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5208                 v2.AuxInt = int64ToAuxInt(64)
5209                 v2.AddArg(y)
5210                 v1.AddArg(v2)
5211                 v.AddArg2(v0, v1)
5212                 return true
5213         }
5214 }
5215 func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
5216         v_1 := v.Args[1]
5217         v_0 := v.Args[0]
5218         b := v.Block
5219         typ := &b.Func.Config.Types
5220         // match: (Rsh64Ux8 <t> x y)
5221         // result: (AND (SRL <t> x y) (Neg64 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
5222         for {
5223                 t := v.Type
5224                 x := v_0
5225                 y := v_1
5226                 v.reset(OpRISCV64AND)
5227                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5228                 v0.AddArg2(x, y)
5229                 v1 := b.NewValue0(v.Pos, OpNeg64, t)
5230                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5231                 v2.AuxInt = int64ToAuxInt(64)
5232                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5233                 v3.AddArg(y)
5234                 v2.AddArg(v3)
5235                 v1.AddArg(v2)
5236                 v.AddArg2(v0, v1)
5237                 return true
5238         }
5239 }
5240 func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
5241         v_1 := v.Args[1]
5242         v_0 := v.Args[0]
5243         b := v.Block
5244         typ := &b.Func.Config.Types
5245         // match: (Rsh64x16 <t> x y)
5246         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
5247         for {
5248                 t := v.Type
5249                 x := v_0
5250                 y := v_1
5251                 v.reset(OpRISCV64SRA)
5252                 v.Type = t
5253                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5254                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5255                 v1.AuxInt = int64ToAuxInt(-1)
5256                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5257                 v2.AuxInt = int64ToAuxInt(64)
5258                 v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
5259                 v3.AddArg(y)
5260                 v2.AddArg(v3)
5261                 v1.AddArg(v2)
5262                 v0.AddArg2(y, v1)
5263                 v.AddArg2(x, v0)
5264                 return true
5265         }
5266 }
5267 func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
5268         v_1 := v.Args[1]
5269         v_0 := v.Args[0]
5270         b := v.Block
5271         typ := &b.Func.Config.Types
5272         // match: (Rsh64x32 <t> x y)
5273         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
5274         for {
5275                 t := v.Type
5276                 x := v_0
5277                 y := v_1
5278                 v.reset(OpRISCV64SRA)
5279                 v.Type = t
5280                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5281                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5282                 v1.AuxInt = int64ToAuxInt(-1)
5283                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5284                 v2.AuxInt = int64ToAuxInt(64)
5285                 v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
5286                 v3.AddArg(y)
5287                 v2.AddArg(v3)
5288                 v1.AddArg(v2)
5289                 v0.AddArg2(y, v1)
5290                 v.AddArg2(x, v0)
5291                 return true
5292         }
5293 }
5294 func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
5295         v_1 := v.Args[1]
5296         v_0 := v.Args[0]
5297         b := v.Block
5298         // match: (Rsh64x64 <t> x y)
5299         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
5300         for {
5301                 t := v.Type
5302                 x := v_0
5303                 y := v_1
5304                 v.reset(OpRISCV64SRA)
5305                 v.Type = t
5306                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5307                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5308                 v1.AuxInt = int64ToAuxInt(-1)
5309                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5310                 v2.AuxInt = int64ToAuxInt(64)
5311                 v2.AddArg(y)
5312                 v1.AddArg(v2)
5313                 v0.AddArg2(y, v1)
5314                 v.AddArg2(x, v0)
5315                 return true
5316         }
5317 }
5318 func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
5319         v_1 := v.Args[1]
5320         v_0 := v.Args[0]
5321         b := v.Block
5322         typ := &b.Func.Config.Types
5323         // match: (Rsh64x8 <t> x y)
5324         // result: (SRA <t> x (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
5325         for {
5326                 t := v.Type
5327                 x := v_0
5328                 y := v_1
5329                 v.reset(OpRISCV64SRA)
5330                 v.Type = t
5331                 v0 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5332                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5333                 v1.AuxInt = int64ToAuxInt(-1)
5334                 v2 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5335                 v2.AuxInt = int64ToAuxInt(64)
5336                 v3 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5337                 v3.AddArg(y)
5338                 v2.AddArg(v3)
5339                 v1.AddArg(v2)
5340                 v0.AddArg2(y, v1)
5341                 v.AddArg2(x, v0)
5342                 return true
5343         }
5344 }
5345 func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
5346         v_1 := v.Args[1]
5347         v_0 := v.Args[0]
5348         b := v.Block
5349         typ := &b.Func.Config.Types
5350         // match: (Rsh8Ux16 <t> x y)
5351         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt16to64 y))))
5352         for {
5353                 t := v.Type
5354                 x := v_0
5355                 y := v_1
5356                 v.reset(OpRISCV64AND)
5357                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5358                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5359                 v1.AddArg(x)
5360                 v0.AddArg2(v1, y)
5361                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
5362                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5363                 v3.AuxInt = int64ToAuxInt(64)
5364                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
5365                 v4.AddArg(y)
5366                 v3.AddArg(v4)
5367                 v2.AddArg(v3)
5368                 v.AddArg2(v0, v2)
5369                 return true
5370         }
5371 }
5372 func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
5373         v_1 := v.Args[1]
5374         v_0 := v.Args[0]
5375         b := v.Block
5376         typ := &b.Func.Config.Types
5377         // match: (Rsh8Ux32 <t> x y)
5378         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt32to64 y))))
5379         for {
5380                 t := v.Type
5381                 x := v_0
5382                 y := v_1
5383                 v.reset(OpRISCV64AND)
5384                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5385                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5386                 v1.AddArg(x)
5387                 v0.AddArg2(v1, y)
5388                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
5389                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5390                 v3.AuxInt = int64ToAuxInt(64)
5391                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
5392                 v4.AddArg(y)
5393                 v3.AddArg(v4)
5394                 v2.AddArg(v3)
5395                 v.AddArg2(v0, v2)
5396                 return true
5397         }
5398 }
5399 func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
5400         v_1 := v.Args[1]
5401         v_0 := v.Args[0]
5402         b := v.Block
5403         typ := &b.Func.Config.Types
5404         // match: (Rsh8Ux64 <t> x y)
5405         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] y)))
5406         for {
5407                 t := v.Type
5408                 x := v_0
5409                 y := v_1
5410                 v.reset(OpRISCV64AND)
5411                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5412                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5413                 v1.AddArg(x)
5414                 v0.AddArg2(v1, y)
5415                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
5416                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5417                 v3.AuxInt = int64ToAuxInt(64)
5418                 v3.AddArg(y)
5419                 v2.AddArg(v3)
5420                 v.AddArg2(v0, v2)
5421                 return true
5422         }
5423 }
5424 func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
5425         v_1 := v.Args[1]
5426         v_0 := v.Args[0]
5427         b := v.Block
5428         typ := &b.Func.Config.Types
5429         // match: (Rsh8Ux8 <t> x y)
5430         // result: (AND (SRL <t> (ZeroExt8to64 x) y) (Neg8 <t> (SLTIU <t> [64] (ZeroExt8to64 y))))
5431         for {
5432                 t := v.Type
5433                 x := v_0
5434                 y := v_1
5435                 v.reset(OpRISCV64AND)
5436                 v0 := b.NewValue0(v.Pos, OpRISCV64SRL, t)
5437                 v1 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5438                 v1.AddArg(x)
5439                 v0.AddArg2(v1, y)
5440                 v2 := b.NewValue0(v.Pos, OpNeg8, t)
5441                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, t)
5442                 v3.AuxInt = int64ToAuxInt(64)
5443                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5444                 v4.AddArg(y)
5445                 v3.AddArg(v4)
5446                 v2.AddArg(v3)
5447                 v.AddArg2(v0, v2)
5448                 return true
5449         }
5450 }
5451 func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
5452         v_1 := v.Args[1]
5453         v_0 := v.Args[0]
5454         b := v.Block
5455         typ := &b.Func.Config.Types
5456         // match: (Rsh8x16 <t> x y)
5457         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt16to64 y)))))
5458         for {
5459                 t := v.Type
5460                 x := v_0
5461                 y := v_1
5462                 v.reset(OpRISCV64SRA)
5463                 v.Type = t
5464                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
5465                 v0.AddArg(x)
5466                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5467                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5468                 v2.AuxInt = int64ToAuxInt(-1)
5469                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5470                 v3.AuxInt = int64ToAuxInt(64)
5471                 v4 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
5472                 v4.AddArg(y)
5473                 v3.AddArg(v4)
5474                 v2.AddArg(v3)
5475                 v1.AddArg2(y, v2)
5476                 v.AddArg2(v0, v1)
5477                 return true
5478         }
5479 }
5480 func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
5481         v_1 := v.Args[1]
5482         v_0 := v.Args[0]
5483         b := v.Block
5484         typ := &b.Func.Config.Types
5485         // match: (Rsh8x32 <t> x y)
5486         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt32to64 y)))))
5487         for {
5488                 t := v.Type
5489                 x := v_0
5490                 y := v_1
5491                 v.reset(OpRISCV64SRA)
5492                 v.Type = t
5493                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
5494                 v0.AddArg(x)
5495                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5496                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5497                 v2.AuxInt = int64ToAuxInt(-1)
5498                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5499                 v3.AuxInt = int64ToAuxInt(64)
5500                 v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
5501                 v4.AddArg(y)
5502                 v3.AddArg(v4)
5503                 v2.AddArg(v3)
5504                 v1.AddArg2(y, v2)
5505                 v.AddArg2(v0, v1)
5506                 return true
5507         }
5508 }
5509 func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
5510         v_1 := v.Args[1]
5511         v_0 := v.Args[0]
5512         b := v.Block
5513         typ := &b.Func.Config.Types
5514         // match: (Rsh8x64 <t> x y)
5515         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] y))))
5516         for {
5517                 t := v.Type
5518                 x := v_0
5519                 y := v_1
5520                 v.reset(OpRISCV64SRA)
5521                 v.Type = t
5522                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
5523                 v0.AddArg(x)
5524                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5525                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5526                 v2.AuxInt = int64ToAuxInt(-1)
5527                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5528                 v3.AuxInt = int64ToAuxInt(64)
5529                 v3.AddArg(y)
5530                 v2.AddArg(v3)
5531                 v1.AddArg2(y, v2)
5532                 v.AddArg2(v0, v1)
5533                 return true
5534         }
5535 }
5536 func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
5537         v_1 := v.Args[1]
5538         v_0 := v.Args[0]
5539         b := v.Block
5540         typ := &b.Func.Config.Types
5541         // match: (Rsh8x8 <t> x y)
5542         // result: (SRA <t> (SignExt8to64 x) (OR <y.Type> y (ADDI <y.Type> [-1] (SLTIU <y.Type> [64] (ZeroExt8to64 y)))))
5543         for {
5544                 t := v.Type
5545                 x := v_0
5546                 y := v_1
5547                 v.reset(OpRISCV64SRA)
5548                 v.Type = t
5549                 v0 := b.NewValue0(v.Pos, OpSignExt8to64, typ.Int64)
5550                 v0.AddArg(x)
5551                 v1 := b.NewValue0(v.Pos, OpRISCV64OR, y.Type)
5552                 v2 := b.NewValue0(v.Pos, OpRISCV64ADDI, y.Type)
5553                 v2.AuxInt = int64ToAuxInt(-1)
5554                 v3 := b.NewValue0(v.Pos, OpRISCV64SLTIU, y.Type)
5555                 v3.AuxInt = int64ToAuxInt(64)
5556                 v4 := b.NewValue0(v.Pos, OpZeroExt8to64, typ.UInt64)
5557                 v4.AddArg(y)
5558                 v3.AddArg(v4)
5559                 v2.AddArg(v3)
5560                 v1.AddArg2(y, v2)
5561                 v.AddArg2(v0, v1)
5562                 return true
5563         }
5564 }
5565 func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
5566         v_0 := v.Args[0]
5567         b := v.Block
5568         // match: (Slicemask <t> x)
5569         // result: (NOT (SRAI <t> [63] (ADDI <t> [-1] x)))
5570         for {
5571                 t := v.Type
5572                 x := v_0
5573                 v.reset(OpRISCV64NOT)
5574                 v0 := b.NewValue0(v.Pos, OpRISCV64SRAI, t)
5575                 v0.AuxInt = int64ToAuxInt(63)
5576                 v1 := b.NewValue0(v.Pos, OpRISCV64ADDI, t)
5577                 v1.AuxInt = int64ToAuxInt(-1)
5578                 v1.AddArg(x)
5579                 v0.AddArg(v1)
5580                 v.AddArg(v0)
5581                 return true
5582         }
5583 }
5584 func rewriteValueRISCV64_OpStore(v *Value) bool {
5585         v_2 := v.Args[2]
5586         v_1 := v.Args[1]
5587         v_0 := v.Args[0]
5588         // match: (Store {t} ptr val mem)
5589         // cond: t.Size() == 1
5590         // result: (MOVBstore ptr val mem)
5591         for {
5592                 t := auxToType(v.Aux)
5593                 ptr := v_0
5594                 val := v_1
5595                 mem := v_2
5596                 if !(t.Size() == 1) {
5597                         break
5598                 }
5599                 v.reset(OpRISCV64MOVBstore)
5600                 v.AddArg3(ptr, val, mem)
5601                 return true
5602         }
5603         // match: (Store {t} ptr val mem)
5604         // cond: t.Size() == 2
5605         // result: (MOVHstore ptr val mem)
5606         for {
5607                 t := auxToType(v.Aux)
5608                 ptr := v_0
5609                 val := v_1
5610                 mem := v_2
5611                 if !(t.Size() == 2) {
5612                         break
5613                 }
5614                 v.reset(OpRISCV64MOVHstore)
5615                 v.AddArg3(ptr, val, mem)
5616                 return true
5617         }
5618         // match: (Store {t} ptr val mem)
5619         // cond: t.Size() == 4 && !is32BitFloat(val.Type)
5620         // result: (MOVWstore ptr val mem)
5621         for {
5622                 t := auxToType(v.Aux)
5623                 ptr := v_0
5624                 val := v_1
5625                 mem := v_2
5626                 if !(t.Size() == 4 && !is32BitFloat(val.Type)) {
5627                         break
5628                 }
5629                 v.reset(OpRISCV64MOVWstore)
5630                 v.AddArg3(ptr, val, mem)
5631                 return true
5632         }
5633         // match: (Store {t} ptr val mem)
5634         // cond: t.Size() == 8 && !is64BitFloat(val.Type)
5635         // result: (MOVDstore ptr val mem)
5636         for {
5637                 t := auxToType(v.Aux)
5638                 ptr := v_0
5639                 val := v_1
5640                 mem := v_2
5641                 if !(t.Size() == 8 && !is64BitFloat(val.Type)) {
5642                         break
5643                 }
5644                 v.reset(OpRISCV64MOVDstore)
5645                 v.AddArg3(ptr, val, mem)
5646                 return true
5647         }
5648         // match: (Store {t} ptr val mem)
5649         // cond: t.Size() == 4 && is32BitFloat(val.Type)
5650         // result: (FMOVWstore ptr val mem)
5651         for {
5652                 t := auxToType(v.Aux)
5653                 ptr := v_0
5654                 val := v_1
5655                 mem := v_2
5656                 if !(t.Size() == 4 && is32BitFloat(val.Type)) {
5657                         break
5658                 }
5659                 v.reset(OpRISCV64FMOVWstore)
5660                 v.AddArg3(ptr, val, mem)
5661                 return true
5662         }
5663         // match: (Store {t} ptr val mem)
5664         // cond: t.Size() == 8 && is64BitFloat(val.Type)
5665         // result: (FMOVDstore ptr val mem)
5666         for {
5667                 t := auxToType(v.Aux)
5668                 ptr := v_0
5669                 val := v_1
5670                 mem := v_2
5671                 if !(t.Size() == 8 && is64BitFloat(val.Type)) {
5672                         break
5673                 }
5674                 v.reset(OpRISCV64FMOVDstore)
5675                 v.AddArg3(ptr, val, mem)
5676                 return true
5677         }
5678         return false
5679 }
5680 func rewriteValueRISCV64_OpZero(v *Value) bool {
5681         v_1 := v.Args[1]
5682         v_0 := v.Args[0]
5683         b := v.Block
5684         config := b.Func.Config
5685         typ := &b.Func.Config.Types
5686         // match: (Zero [0] _ mem)
5687         // result: mem
5688         for {
5689                 if auxIntToInt64(v.AuxInt) != 0 {
5690                         break
5691                 }
5692                 mem := v_1
5693                 v.copyOf(mem)
5694                 return true
5695         }
5696         // match: (Zero [1] ptr mem)
5697         // result: (MOVBstore ptr (MOVDconst [0]) mem)
5698         for {
5699                 if auxIntToInt64(v.AuxInt) != 1 {
5700                         break
5701                 }
5702                 ptr := v_0
5703                 mem := v_1
5704                 v.reset(OpRISCV64MOVBstore)
5705                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5706                 v0.AuxInt = int64ToAuxInt(0)
5707                 v.AddArg3(ptr, v0, mem)
5708                 return true
5709         }
5710         // match: (Zero [2] {t} ptr mem)
5711         // cond: t.Alignment()%2 == 0
5712         // result: (MOVHstore ptr (MOVDconst [0]) mem)
5713         for {
5714                 if auxIntToInt64(v.AuxInt) != 2 {
5715                         break
5716                 }
5717                 t := auxToType(v.Aux)
5718                 ptr := v_0
5719                 mem := v_1
5720                 if !(t.Alignment()%2 == 0) {
5721                         break
5722                 }
5723                 v.reset(OpRISCV64MOVHstore)
5724                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5725                 v0.AuxInt = int64ToAuxInt(0)
5726                 v.AddArg3(ptr, v0, mem)
5727                 return true
5728         }
5729         // match: (Zero [2] ptr mem)
5730         // result: (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))
5731         for {
5732                 if auxIntToInt64(v.AuxInt) != 2 {
5733                         break
5734                 }
5735                 ptr := v_0
5736                 mem := v_1
5737                 v.reset(OpRISCV64MOVBstore)
5738                 v.AuxInt = int32ToAuxInt(1)
5739                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5740                 v0.AuxInt = int64ToAuxInt(0)
5741                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
5742                 v1.AddArg3(ptr, v0, mem)
5743                 v.AddArg3(ptr, v0, v1)
5744                 return true
5745         }
5746         // match: (Zero [4] {t} ptr mem)
5747         // cond: t.Alignment()%4 == 0
5748         // result: (MOVWstore ptr (MOVDconst [0]) mem)
5749         for {
5750                 if auxIntToInt64(v.AuxInt) != 4 {
5751                         break
5752                 }
5753                 t := auxToType(v.Aux)
5754                 ptr := v_0
5755                 mem := v_1
5756                 if !(t.Alignment()%4 == 0) {
5757                         break
5758                 }
5759                 v.reset(OpRISCV64MOVWstore)
5760                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5761                 v0.AuxInt = int64ToAuxInt(0)
5762                 v.AddArg3(ptr, v0, mem)
5763                 return true
5764         }
5765         // match: (Zero [4] {t} ptr mem)
5766         // cond: t.Alignment()%2 == 0
5767         // result: (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))
5768         for {
5769                 if auxIntToInt64(v.AuxInt) != 4 {
5770                         break
5771                 }
5772                 t := auxToType(v.Aux)
5773                 ptr := v_0
5774                 mem := v_1
5775                 if !(t.Alignment()%2 == 0) {
5776                         break
5777                 }
5778                 v.reset(OpRISCV64MOVHstore)
5779                 v.AuxInt = int32ToAuxInt(2)
5780                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5781                 v0.AuxInt = int64ToAuxInt(0)
5782                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
5783                 v1.AddArg3(ptr, v0, mem)
5784                 v.AddArg3(ptr, v0, v1)
5785                 return true
5786         }
5787         // match: (Zero [4] ptr mem)
5788         // result: (MOVBstore [3] ptr (MOVDconst [0]) (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem))))
5789         for {
5790                 if auxIntToInt64(v.AuxInt) != 4 {
5791                         break
5792                 }
5793                 ptr := v_0
5794                 mem := v_1
5795                 v.reset(OpRISCV64MOVBstore)
5796                 v.AuxInt = int32ToAuxInt(3)
5797                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5798                 v0.AuxInt = int64ToAuxInt(0)
5799                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
5800                 v1.AuxInt = int32ToAuxInt(2)
5801                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
5802                 v2.AuxInt = int32ToAuxInt(1)
5803                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
5804                 v3.AddArg3(ptr, v0, mem)
5805                 v2.AddArg3(ptr, v0, v3)
5806                 v1.AddArg3(ptr, v0, v2)
5807                 v.AddArg3(ptr, v0, v1)
5808                 return true
5809         }
5810         // match: (Zero [8] {t} ptr mem)
5811         // cond: t.Alignment()%8 == 0
5812         // result: (MOVDstore ptr (MOVDconst [0]) mem)
5813         for {
5814                 if auxIntToInt64(v.AuxInt) != 8 {
5815                         break
5816                 }
5817                 t := auxToType(v.Aux)
5818                 ptr := v_0
5819                 mem := v_1
5820                 if !(t.Alignment()%8 == 0) {
5821                         break
5822                 }
5823                 v.reset(OpRISCV64MOVDstore)
5824                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5825                 v0.AuxInt = int64ToAuxInt(0)
5826                 v.AddArg3(ptr, v0, mem)
5827                 return true
5828         }
5829         // match: (Zero [8] {t} ptr mem)
5830         // cond: t.Alignment()%4 == 0
5831         // result: (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem))
5832         for {
5833                 if auxIntToInt64(v.AuxInt) != 8 {
5834                         break
5835                 }
5836                 t := auxToType(v.Aux)
5837                 ptr := v_0
5838                 mem := v_1
5839                 if !(t.Alignment()%4 == 0) {
5840                         break
5841                 }
5842                 v.reset(OpRISCV64MOVWstore)
5843                 v.AuxInt = int32ToAuxInt(4)
5844                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5845                 v0.AuxInt = int64ToAuxInt(0)
5846                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
5847                 v1.AddArg3(ptr, v0, mem)
5848                 v.AddArg3(ptr, v0, v1)
5849                 return true
5850         }
5851         // match: (Zero [8] {t} ptr mem)
5852         // cond: t.Alignment()%2 == 0
5853         // result: (MOVHstore [6] ptr (MOVDconst [0]) (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem))))
5854         for {
5855                 if auxIntToInt64(v.AuxInt) != 8 {
5856                         break
5857                 }
5858                 t := auxToType(v.Aux)
5859                 ptr := v_0
5860                 mem := v_1
5861                 if !(t.Alignment()%2 == 0) {
5862                         break
5863                 }
5864                 v.reset(OpRISCV64MOVHstore)
5865                 v.AuxInt = int32ToAuxInt(6)
5866                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5867                 v0.AuxInt = int64ToAuxInt(0)
5868                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
5869                 v1.AuxInt = int32ToAuxInt(4)
5870                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
5871                 v2.AuxInt = int32ToAuxInt(2)
5872                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
5873                 v3.AddArg3(ptr, v0, mem)
5874                 v2.AddArg3(ptr, v0, v3)
5875                 v1.AddArg3(ptr, v0, v2)
5876                 v.AddArg3(ptr, v0, v1)
5877                 return true
5878         }
5879         // match: (Zero [3] ptr mem)
5880         // result: (MOVBstore [2] ptr (MOVDconst [0]) (MOVBstore [1] ptr (MOVDconst [0]) (MOVBstore ptr (MOVDconst [0]) mem)))
5881         for {
5882                 if auxIntToInt64(v.AuxInt) != 3 {
5883                         break
5884                 }
5885                 ptr := v_0
5886                 mem := v_1
5887                 v.reset(OpRISCV64MOVBstore)
5888                 v.AuxInt = int32ToAuxInt(2)
5889                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5890                 v0.AuxInt = int64ToAuxInt(0)
5891                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
5892                 v1.AuxInt = int32ToAuxInt(1)
5893                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVBstore, types.TypeMem)
5894                 v2.AddArg3(ptr, v0, mem)
5895                 v1.AddArg3(ptr, v0, v2)
5896                 v.AddArg3(ptr, v0, v1)
5897                 return true
5898         }
5899         // match: (Zero [6] {t} ptr mem)
5900         // cond: t.Alignment()%2 == 0
5901         // result: (MOVHstore [4] ptr (MOVDconst [0]) (MOVHstore [2] ptr (MOVDconst [0]) (MOVHstore ptr (MOVDconst [0]) mem)))
5902         for {
5903                 if auxIntToInt64(v.AuxInt) != 6 {
5904                         break
5905                 }
5906                 t := auxToType(v.Aux)
5907                 ptr := v_0
5908                 mem := v_1
5909                 if !(t.Alignment()%2 == 0) {
5910                         break
5911                 }
5912                 v.reset(OpRISCV64MOVHstore)
5913                 v.AuxInt = int32ToAuxInt(4)
5914                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5915                 v0.AuxInt = int64ToAuxInt(0)
5916                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
5917                 v1.AuxInt = int32ToAuxInt(2)
5918                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVHstore, types.TypeMem)
5919                 v2.AddArg3(ptr, v0, mem)
5920                 v1.AddArg3(ptr, v0, v2)
5921                 v.AddArg3(ptr, v0, v1)
5922                 return true
5923         }
5924         // match: (Zero [12] {t} ptr mem)
5925         // cond: t.Alignment()%4 == 0
5926         // result: (MOVWstore [8] ptr (MOVDconst [0]) (MOVWstore [4] ptr (MOVDconst [0]) (MOVWstore ptr (MOVDconst [0]) mem)))
5927         for {
5928                 if auxIntToInt64(v.AuxInt) != 12 {
5929                         break
5930                 }
5931                 t := auxToType(v.Aux)
5932                 ptr := v_0
5933                 mem := v_1
5934                 if !(t.Alignment()%4 == 0) {
5935                         break
5936                 }
5937                 v.reset(OpRISCV64MOVWstore)
5938                 v.AuxInt = int32ToAuxInt(8)
5939                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5940                 v0.AuxInt = int64ToAuxInt(0)
5941                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
5942                 v1.AuxInt = int32ToAuxInt(4)
5943                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVWstore, types.TypeMem)
5944                 v2.AddArg3(ptr, v0, mem)
5945                 v1.AddArg3(ptr, v0, v2)
5946                 v.AddArg3(ptr, v0, v1)
5947                 return true
5948         }
5949         // match: (Zero [16] {t} ptr mem)
5950         // cond: t.Alignment()%8 == 0
5951         // result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
5952         for {
5953                 if auxIntToInt64(v.AuxInt) != 16 {
5954                         break
5955                 }
5956                 t := auxToType(v.Aux)
5957                 ptr := v_0
5958                 mem := v_1
5959                 if !(t.Alignment()%8 == 0) {
5960                         break
5961                 }
5962                 v.reset(OpRISCV64MOVDstore)
5963                 v.AuxInt = int32ToAuxInt(8)
5964                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5965                 v0.AuxInt = int64ToAuxInt(0)
5966                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
5967                 v1.AddArg3(ptr, v0, mem)
5968                 v.AddArg3(ptr, v0, v1)
5969                 return true
5970         }
5971         // match: (Zero [24] {t} ptr mem)
5972         // cond: t.Alignment()%8 == 0
5973         // result: (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem)))
5974         for {
5975                 if auxIntToInt64(v.AuxInt) != 24 {
5976                         break
5977                 }
5978                 t := auxToType(v.Aux)
5979                 ptr := v_0
5980                 mem := v_1
5981                 if !(t.Alignment()%8 == 0) {
5982                         break
5983                 }
5984                 v.reset(OpRISCV64MOVDstore)
5985                 v.AuxInt = int32ToAuxInt(16)
5986                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
5987                 v0.AuxInt = int64ToAuxInt(0)
5988                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
5989                 v1.AuxInt = int32ToAuxInt(8)
5990                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
5991                 v2.AddArg3(ptr, v0, mem)
5992                 v1.AddArg3(ptr, v0, v2)
5993                 v.AddArg3(ptr, v0, v1)
5994                 return true
5995         }
5996         // match: (Zero [32] {t} ptr mem)
5997         // cond: t.Alignment()%8 == 0
5998         // result: (MOVDstore [24] ptr (MOVDconst [0]) (MOVDstore [16] ptr (MOVDconst [0]) (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))))
5999         for {
6000                 if auxIntToInt64(v.AuxInt) != 32 {
6001                         break
6002                 }
6003                 t := auxToType(v.Aux)
6004                 ptr := v_0
6005                 mem := v_1
6006                 if !(t.Alignment()%8 == 0) {
6007                         break
6008                 }
6009                 v.reset(OpRISCV64MOVDstore)
6010                 v.AuxInt = int32ToAuxInt(24)
6011                 v0 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6012                 v0.AuxInt = int64ToAuxInt(0)
6013                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
6014                 v1.AuxInt = int32ToAuxInt(16)
6015                 v2 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
6016                 v2.AuxInt = int32ToAuxInt(8)
6017                 v3 := b.NewValue0(v.Pos, OpRISCV64MOVDstore, types.TypeMem)
6018                 v3.AddArg3(ptr, v0, mem)
6019                 v2.AddArg3(ptr, v0, v3)
6020                 v1.AddArg3(ptr, v0, v2)
6021                 v.AddArg3(ptr, v0, v1)
6022                 return true
6023         }
6024         // match: (Zero [s] {t} ptr mem)
6025         // cond: s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice
6026         // result: (DUFFZERO [8 * (128 - s/8)] ptr mem)
6027         for {
6028                 s := auxIntToInt64(v.AuxInt)
6029                 t := auxToType(v.Aux)
6030                 ptr := v_0
6031                 mem := v_1
6032                 if !(s%8 == 0 && s <= 8*128 && t.Alignment()%8 == 0 && !config.noDuffDevice) {
6033                         break
6034                 }
6035                 v.reset(OpRISCV64DUFFZERO)
6036                 v.AuxInt = int64ToAuxInt(8 * (128 - s/8))
6037                 v.AddArg2(ptr, mem)
6038                 return true
6039         }
6040         // match: (Zero [s] {t} ptr mem)
6041         // result: (LoweredZero [t.Alignment()] ptr (ADD <ptr.Type> ptr (MOVDconst [s-moveSize(t.Alignment(), config)])) mem)
6042         for {
6043                 s := auxIntToInt64(v.AuxInt)
6044                 t := auxToType(v.Aux)
6045                 ptr := v_0
6046                 mem := v_1
6047                 v.reset(OpRISCV64LoweredZero)
6048                 v.AuxInt = int64ToAuxInt(t.Alignment())
6049                 v0 := b.NewValue0(v.Pos, OpRISCV64ADD, ptr.Type)
6050                 v1 := b.NewValue0(v.Pos, OpRISCV64MOVDconst, typ.UInt64)
6051                 v1.AuxInt = int64ToAuxInt(s - moveSize(t.Alignment(), config))
6052                 v0.AddArg2(ptr, v1)
6053                 v.AddArg3(ptr, v0, mem)
6054                 return true
6055         }
6056 }
6057 func rewriteBlockRISCV64(b *Block) bool {
6058         switch b.Kind {
6059         case BlockRISCV64BEQ:
6060                 // match: (BEQ (MOVDconst [0]) cond yes no)
6061                 // result: (BEQZ cond yes no)
6062                 for b.Controls[0].Op == OpRISCV64MOVDconst {
6063                         v_0 := b.Controls[0]
6064                         if auxIntToInt64(v_0.AuxInt) != 0 {
6065                                 break
6066                         }
6067                         cond := b.Controls[1]
6068                         b.resetWithControl(BlockRISCV64BEQZ, cond)
6069                         return true
6070                 }
6071                 // match: (BEQ cond (MOVDconst [0]) yes no)
6072                 // result: (BEQZ cond yes no)
6073                 for b.Controls[1].Op == OpRISCV64MOVDconst {
6074                         cond := b.Controls[0]
6075                         v_1 := b.Controls[1]
6076                         if auxIntToInt64(v_1.AuxInt) != 0 {
6077                                 break
6078                         }
6079                         b.resetWithControl(BlockRISCV64BEQZ, cond)
6080                         return true
6081                 }
6082         case BlockRISCV64BEQZ:
6083                 // match: (BEQZ (SEQZ x) yes no)
6084                 // result: (BNEZ x yes no)
6085                 for b.Controls[0].Op == OpRISCV64SEQZ {
6086                         v_0 := b.Controls[0]
6087                         x := v_0.Args[0]
6088                         b.resetWithControl(BlockRISCV64BNEZ, x)
6089                         return true
6090                 }
6091                 // match: (BEQZ (SNEZ x) yes no)
6092                 // result: (BEQZ x yes no)
6093                 for b.Controls[0].Op == OpRISCV64SNEZ {
6094                         v_0 := b.Controls[0]
6095                         x := v_0.Args[0]
6096                         b.resetWithControl(BlockRISCV64BEQZ, x)
6097                         return true
6098                 }
6099                 // match: (BEQZ (SUB x y) yes no)
6100                 // result: (BEQ x y yes no)
6101                 for b.Controls[0].Op == OpRISCV64SUB {
6102                         v_0 := b.Controls[0]
6103                         y := v_0.Args[1]
6104                         x := v_0.Args[0]
6105                         b.resetWithControl2(BlockRISCV64BEQ, x, y)
6106                         return true
6107                 }
6108                 // match: (BEQZ (SLT x y) yes no)
6109                 // result: (BGE x y yes no)
6110                 for b.Controls[0].Op == OpRISCV64SLT {
6111                         v_0 := b.Controls[0]
6112                         y := v_0.Args[1]
6113                         x := v_0.Args[0]
6114                         b.resetWithControl2(BlockRISCV64BGE, x, y)
6115                         return true
6116                 }
6117                 // match: (BEQZ (SLTU x y) yes no)
6118                 // result: (BGEU x y yes no)
6119                 for b.Controls[0].Op == OpRISCV64SLTU {
6120                         v_0 := b.Controls[0]
6121                         y := v_0.Args[1]
6122                         x := v_0.Args[0]
6123                         b.resetWithControl2(BlockRISCV64BGEU, x, y)
6124                         return true
6125                 }
6126         case BlockRISCV64BNE:
6127                 // match: (BNE (MOVDconst [0]) cond yes no)
6128                 // result: (BNEZ cond yes no)
6129                 for b.Controls[0].Op == OpRISCV64MOVDconst {
6130                         v_0 := b.Controls[0]
6131                         if auxIntToInt64(v_0.AuxInt) != 0 {
6132                                 break
6133                         }
6134                         cond := b.Controls[1]
6135                         b.resetWithControl(BlockRISCV64BNEZ, cond)
6136                         return true
6137                 }
6138                 // match: (BNE cond (MOVDconst [0]) yes no)
6139                 // result: (BNEZ cond yes no)
6140                 for b.Controls[1].Op == OpRISCV64MOVDconst {
6141                         cond := b.Controls[0]
6142                         v_1 := b.Controls[1]
6143                         if auxIntToInt64(v_1.AuxInt) != 0 {
6144                                 break
6145                         }
6146                         b.resetWithControl(BlockRISCV64BNEZ, cond)
6147                         return true
6148                 }
6149         case BlockRISCV64BNEZ:
6150                 // match: (BNEZ (SEQZ x) yes no)
6151                 // result: (BEQZ x yes no)
6152                 for b.Controls[0].Op == OpRISCV64SEQZ {
6153                         v_0 := b.Controls[0]
6154                         x := v_0.Args[0]
6155                         b.resetWithControl(BlockRISCV64BEQZ, x)
6156                         return true
6157                 }
6158                 // match: (BNEZ (SNEZ x) yes no)
6159                 // result: (BNEZ x yes no)
6160                 for b.Controls[0].Op == OpRISCV64SNEZ {
6161                         v_0 := b.Controls[0]
6162                         x := v_0.Args[0]
6163                         b.resetWithControl(BlockRISCV64BNEZ, x)
6164                         return true
6165                 }
6166                 // match: (BNEZ (SUB x y) yes no)
6167                 // result: (BNE x y yes no)
6168                 for b.Controls[0].Op == OpRISCV64SUB {
6169                         v_0 := b.Controls[0]
6170                         y := v_0.Args[1]
6171                         x := v_0.Args[0]
6172                         b.resetWithControl2(BlockRISCV64BNE, x, y)
6173                         return true
6174                 }
6175                 // match: (BNEZ (SLT x y) yes no)
6176                 // result: (BLT x y yes no)
6177                 for b.Controls[0].Op == OpRISCV64SLT {
6178                         v_0 := b.Controls[0]
6179                         y := v_0.Args[1]
6180                         x := v_0.Args[0]
6181                         b.resetWithControl2(BlockRISCV64BLT, x, y)
6182                         return true
6183                 }
6184                 // match: (BNEZ (SLTU x y) yes no)
6185                 // result: (BLTU x y yes no)
6186                 for b.Controls[0].Op == OpRISCV64SLTU {
6187                         v_0 := b.Controls[0]
6188                         y := v_0.Args[1]
6189                         x := v_0.Args[0]
6190                         b.resetWithControl2(BlockRISCV64BLTU, x, y)
6191                         return true
6192                 }
6193         case BlockIf:
6194                 // match: (If cond yes no)
6195                 // result: (BNEZ cond yes no)
6196                 for {
6197                         cond := b.Controls[0]
6198                         b.resetWithControl(BlockRISCV64BNEZ, cond)
6199                         return true
6200                 }
6201         }
6202         return false
6203 }