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

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