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

   1 // Code generated from _gen/dec.rules using 'go generate'; DO NOT EDIT.
   2
   3 package ssa
   4
   5 import "cmd/compile/internal/types"
   6
   7 func rewriteValuedec(v *Value) bool {
   8         switch v.Op {
   9         case OpArrayMake1:
  10                 return rewriteValuedec_OpArrayMake1(v)
  11         case OpArraySelect:
  12                 return rewriteValuedec_OpArraySelect(v)
  13         case OpComplexImag:
  14                 return rewriteValuedec_OpComplexImag(v)
  15         case OpComplexReal:
  16                 return rewriteValuedec_OpComplexReal(v)
  17         case OpIData:
  18                 return rewriteValuedec_OpIData(v)
  19         case OpIMake:
  20                 return rewriteValuedec_OpIMake(v)
  21         case OpITab:
  22                 return rewriteValuedec_OpITab(v)
  23         case OpLoad:
  24                 return rewriteValuedec_OpLoad(v)
  25         case OpSliceCap:
  26                 return rewriteValuedec_OpSliceCap(v)
  27         case OpSliceLen:
  28                 return rewriteValuedec_OpSliceLen(v)
  29         case OpSlicePtr:
  30                 return rewriteValuedec_OpSlicePtr(v)
  31         case OpSlicePtrUnchecked:
  32                 return rewriteValuedec_OpSlicePtrUnchecked(v)
  33         case OpStore:
  34                 return rewriteValuedec_OpStore(v)
  35         case OpStringLen:
  36                 return rewriteValuedec_OpStringLen(v)
  37         case OpStringPtr:
  38                 return rewriteValuedec_OpStringPtr(v)
  39         case OpStructMake1:
  40                 return rewriteValuedec_OpStructMake1(v)
  41         case OpStructSelect:
  42                 return rewriteValuedec_OpStructSelect(v)
  43         }
  44         return false
  45 }
  46 func rewriteValuedec_OpArrayMake1(v *Value) bool {
  47         v_0 := v.Args[0]
  48         // match: (ArrayMake1 x)
  49         // cond: x.Type.IsPtr()
  50         // result: x
  51         for {
  52                 x := v_0
  53                 if !(x.Type.IsPtr()) {
  54                         break
  55                 }
  56                 v.copyOf(x)
  57                 return true
  58         }
  59         return false
  60 }
  61 func rewriteValuedec_OpArraySelect(v *Value) bool {
  62         v_0 := v.Args[0]
  63         b := v.Block
  64         // match: (ArraySelect [0] x)
  65         // cond: x.Type.IsPtr()
  66         // result: x
  67         for {
  68                 if auxIntToInt64(v.AuxInt) != 0 {
  69                         break
  70                 }
  71                 x := v_0
  72                 if !(x.Type.IsPtr()) {
  73                         break
  74                 }
  75                 v.copyOf(x)
  76                 return true
  77         }
  78         // match: (ArraySelect (ArrayMake1 x))
  79         // result: x
  80         for {
  81                 if v_0.Op != OpArrayMake1 {
  82                         break
  83                 }
  84                 x := v_0.Args[0]
  85                 v.copyOf(x)
  86                 return true
  87         }
  88         // match: (ArraySelect [0] (IData x))
  89         // result: (IData x)
  90         for {
  91                 if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpIData {
  92                         break
  93                 }
  94                 x := v_0.Args[0]
  95                 v.reset(OpIData)
  96                 v.AddArg(x)
  97                 return true
  98         }
  99         // match: (ArraySelect [i] x:(Load <t> ptr mem))
 100         // result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.Elem().Size()*i] ptr) mem)
 101         for {
 102                 i := auxIntToInt64(v.AuxInt)
 103                 x := v_0
 104                 if x.Op != OpLoad {
 105                         break
 106                 }
 107                 t := x.Type
 108                 mem := x.Args[1]
 109                 ptr := x.Args[0]
 110                 b = x.Block
 111                 v0 := b.NewValue0(v.Pos, OpLoad, v.Type)
 112                 v.copyOf(v0)
 113                 v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo())
 114                 v1.AuxInt = int64ToAuxInt(t.Elem().Size() * i)
 115                 v1.AddArg(ptr)
 116                 v0.AddArg2(v1, mem)
 117                 return true
 118         }
 119         return false
 120 }
 121 func rewriteValuedec_OpComplexImag(v *Value) bool {
 122         v_0 := v.Args[0]
 123         b := v.Block
 124         typ := &b.Func.Config.Types
 125         // match: (ComplexImag (ComplexMake _ imag ))
 126         // result: imag
 127         for {
 128                 if v_0.Op != OpComplexMake {
 129                         break
 130                 }
 131                 imag := v_0.Args[1]
 132                 v.copyOf(imag)
 133                 return true
 134         }
 135         // match: (ComplexImag x:(Load <t> ptr mem))
 136         // cond: t.IsComplex() && t.Size() == 8
 137         // result: @x.Block (Load <typ.Float32> (OffPtr <typ.Float32Ptr> [4] ptr) mem)
 138         for {
 139                 x := v_0
 140                 if x.Op != OpLoad {
 141                         break
 142                 }
 143                 t := x.Type
 144                 mem := x.Args[1]
 145                 ptr := x.Args[0]
 146                 if !(t.IsComplex() && t.Size() == 8) {
 147                         break
 148                 }
 149                 b = x.Block
 150                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
 151                 v.copyOf(v0)
 152                 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
 153                 v1.AuxInt = int64ToAuxInt(4)
 154                 v1.AddArg(ptr)
 155                 v0.AddArg2(v1, mem)
 156                 return true
 157         }
 158         // match: (ComplexImag x:(Load <t> ptr mem))
 159         // cond: t.IsComplex() && t.Size() == 16
 160         // result: @x.Block (Load <typ.Float64> (OffPtr <typ.Float64Ptr> [8] ptr) mem)
 161         for {
 162                 x := v_0
 163                 if x.Op != OpLoad {
 164                         break
 165                 }
 166                 t := x.Type
 167                 mem := x.Args[1]
 168                 ptr := x.Args[0]
 169                 if !(t.IsComplex() && t.Size() == 16) {
 170                         break
 171                 }
 172                 b = x.Block
 173                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
 174                 v.copyOf(v0)
 175                 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
 176                 v1.AuxInt = int64ToAuxInt(8)
 177                 v1.AddArg(ptr)
 178                 v0.AddArg2(v1, mem)
 179                 return true
 180         }
 181         return false
 182 }
 183 func rewriteValuedec_OpComplexReal(v *Value) bool {
 184         v_0 := v.Args[0]
 185         b := v.Block
 186         typ := &b.Func.Config.Types
 187         // match: (ComplexReal (ComplexMake real _ ))
 188         // result: real
 189         for {
 190                 if v_0.Op != OpComplexMake {
 191                         break
 192                 }
 193                 real := v_0.Args[0]
 194                 v.copyOf(real)
 195                 return true
 196         }
 197         // match: (ComplexReal x:(Load <t> ptr mem))
 198         // cond: t.IsComplex() && t.Size() == 8
 199         // result: @x.Block (Load <typ.Float32> ptr mem)
 200         for {
 201                 x := v_0
 202                 if x.Op != OpLoad {
 203                         break
 204                 }
 205                 t := x.Type
 206                 mem := x.Args[1]
 207                 ptr := x.Args[0]
 208                 if !(t.IsComplex() && t.Size() == 8) {
 209                         break
 210                 }
 211                 b = x.Block
 212                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
 213                 v.copyOf(v0)
 214                 v0.AddArg2(ptr, mem)
 215                 return true
 216         }
 217         // match: (ComplexReal x:(Load <t> ptr mem))
 218         // cond: t.IsComplex() && t.Size() == 16
 219         // result: @x.Block (Load <typ.Float64> ptr mem)
 220         for {
 221                 x := v_0
 222                 if x.Op != OpLoad {
 223                         break
 224                 }
 225                 t := x.Type
 226                 mem := x.Args[1]
 227                 ptr := x.Args[0]
 228                 if !(t.IsComplex() && t.Size() == 16) {
 229                         break
 230                 }
 231                 b = x.Block
 232                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
 233                 v.copyOf(v0)
 234                 v0.AddArg2(ptr, mem)
 235                 return true
 236         }
 237         return false
 238 }
 239 func rewriteValuedec_OpIData(v *Value) bool {
 240         v_0 := v.Args[0]
 241         b := v.Block
 242         config := b.Func.Config
 243         typ := &b.Func.Config.Types
 244         // match: (IData (IMake _ data))
 245         // result: data
 246         for {
 247                 if v_0.Op != OpIMake {
 248                         break
 249                 }
 250                 data := v_0.Args[1]
 251                 v.copyOf(data)
 252                 return true
 253         }
 254         // match: (IData x:(Load <t> ptr mem))
 255         // cond: t.IsInterface()
 256         // result: @x.Block (Load <typ.BytePtr> (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr) mem)
 257         for {
 258                 x := v_0
 259                 if x.Op != OpLoad {
 260                         break
 261                 }
 262                 t := x.Type
 263                 mem := x.Args[1]
 264                 ptr := x.Args[0]
 265                 if !(t.IsInterface()) {
 266                         break
 267                 }
 268                 b = x.Block
 269                 v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
 270                 v.copyOf(v0)
 271                 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
 272                 v1.AuxInt = int64ToAuxInt(config.PtrSize)
 273                 v1.AddArg(ptr)
 274                 v0.AddArg2(v1, mem)
 275                 return true
 276         }
 277         return false
 278 }
 279 func rewriteValuedec_OpIMake(v *Value) bool {
 280         v_1 := v.Args[1]
 281         v_0 := v.Args[0]
 282         // match: (IMake _typ (StructMake1 val))
 283         // result: (IMake _typ val)
 284         for {
 285                 _typ := v_0
 286                 if v_1.Op != OpStructMake1 {
 287                         break
 288                 }
 289                 val := v_1.Args[0]
 290                 v.reset(OpIMake)
 291                 v.AddArg2(_typ, val)
 292                 return true
 293         }
 294         return false
 295 }
 296 func rewriteValuedec_OpITab(v *Value) bool {
 297         v_0 := v.Args[0]
 298         b := v.Block
 299         typ := &b.Func.Config.Types
 300         // match: (ITab (IMake itab _))
 301         // result: itab
 302         for {
 303                 if v_0.Op != OpIMake {
 304                         break
 305                 }
 306                 itab := v_0.Args[0]
 307                 v.copyOf(itab)
 308                 return true
 309         }
 310         // match: (ITab x:(Load <t> ptr mem))
 311         // cond: t.IsInterface()
 312         // result: @x.Block (Load <typ.Uintptr> ptr mem)
 313         for {
 314                 x := v_0
 315                 if x.Op != OpLoad {
 316                         break
 317                 }
 318                 t := x.Type
 319                 mem := x.Args[1]
 320                 ptr := x.Args[0]
 321                 if !(t.IsInterface()) {
 322                         break
 323                 }
 324                 b = x.Block
 325                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Uintptr)
 326                 v.copyOf(v0)
 327                 v0.AddArg2(ptr, mem)
 328                 return true
 329         }
 330         return false
 331 }
 332 func rewriteValuedec_OpLoad(v *Value) bool {
 333         v_1 := v.Args[1]
 334         v_0 := v.Args[0]
 335         b := v.Block
 336         config := b.Func.Config
 337         typ := &b.Func.Config.Types
 338         // match: (Load <t> ptr mem)
 339         // cond: t.IsComplex() && t.Size() == 8
 340         // result: (ComplexMake (Load <typ.Float32> ptr mem) (Load <typ.Float32> (OffPtr <typ.Float32Ptr> [4] ptr) mem) )
 341         for {
 342                 t := v.Type
 343                 ptr := v_0
 344                 mem := v_1
 345                 if !(t.IsComplex() && t.Size() == 8) {
 346                         break
 347                 }
 348                 v.reset(OpComplexMake)
 349                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
 350                 v0.AddArg2(ptr, mem)
 351                 v1 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
 352                 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
 353                 v2.AuxInt = int64ToAuxInt(4)
 354                 v2.AddArg(ptr)
 355                 v1.AddArg2(v2, mem)
 356                 v.AddArg2(v0, v1)
 357                 return true
 358         }
 359         // match: (Load <t> ptr mem)
 360         // cond: t.IsComplex() && t.Size() == 16
 361         // result: (ComplexMake (Load <typ.Float64> ptr mem) (Load <typ.Float64> (OffPtr <typ.Float64Ptr> [8] ptr) mem) )
 362         for {
 363                 t := v.Type
 364                 ptr := v_0
 365                 mem := v_1
 366                 if !(t.IsComplex() && t.Size() == 16) {
 367                         break
 368                 }
 369                 v.reset(OpComplexMake)
 370                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
 371                 v0.AddArg2(ptr, mem)
 372                 v1 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
 373                 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
 374                 v2.AuxInt = int64ToAuxInt(8)
 375                 v2.AddArg(ptr)
 376                 v1.AddArg2(v2, mem)
 377                 v.AddArg2(v0, v1)
 378                 return true
 379         }
 380         // match: (Load <t> ptr mem)
 381         // cond: t.IsString()
 382         // result: (StringMake (Load <typ.BytePtr> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem))
 383         for {
 384                 t := v.Type
 385                 ptr := v_0
 386                 mem := v_1
 387                 if !(t.IsString()) {
 388                         break
 389                 }
 390                 v.reset(OpStringMake)
 391                 v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
 392                 v0.AddArg2(ptr, mem)
 393                 v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
 394                 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 395                 v2.AuxInt = int64ToAuxInt(config.PtrSize)
 396                 v2.AddArg(ptr)
 397                 v1.AddArg2(v2, mem)
 398                 v.AddArg2(v0, v1)
 399                 return true
 400         }
 401         // match: (Load <t> ptr mem)
 402         // cond: t.IsSlice()
 403         // result: (SliceMake (Load <t.Elem().PtrTo()> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [2*config.PtrSize] ptr) mem))
 404         for {
 405                 t := v.Type
 406                 ptr := v_0
 407                 mem := v_1
 408                 if !(t.IsSlice()) {
 409                         break
 410                 }
 411                 v.reset(OpSliceMake)
 412                 v0 := b.NewValue0(v.Pos, OpLoad, t.Elem().PtrTo())
 413                 v0.AddArg2(ptr, mem)
 414                 v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
 415                 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 416                 v2.AuxInt = int64ToAuxInt(config.PtrSize)
 417                 v2.AddArg(ptr)
 418                 v1.AddArg2(v2, mem)
 419                 v3 := b.NewValue0(v.Pos, OpLoad, typ.Int)
 420                 v4 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 421                 v4.AuxInt = int64ToAuxInt(2 * config.PtrSize)
 422                 v4.AddArg(ptr)
 423                 v3.AddArg2(v4, mem)
 424                 v.AddArg3(v0, v1, v3)
 425                 return true
 426         }
 427         // match: (Load <t> ptr mem)
 428         // cond: t.IsInterface()
 429         // result: (IMake (Load <typ.Uintptr> ptr mem) (Load <typ.BytePtr> (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr) mem))
 430         for {
 431                 t := v.Type
 432                 ptr := v_0
 433                 mem := v_1
 434                 if !(t.IsInterface()) {
 435                         break
 436                 }
 437                 v.reset(OpIMake)
 438                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Uintptr)
 439                 v0.AddArg2(ptr, mem)
 440                 v1 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
 441                 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
 442                 v2.AuxInt = int64ToAuxInt(config.PtrSize)
 443                 v2.AddArg(ptr)
 444                 v1.AddArg2(v2, mem)
 445                 v.AddArg2(v0, v1)
 446                 return true
 447         }
 448         return false
 449 }
 450 func rewriteValuedec_OpSliceCap(v *Value) bool {
 451         v_0 := v.Args[0]
 452         b := v.Block
 453         config := b.Func.Config
 454         typ := &b.Func.Config.Types
 455         // match: (SliceCap (SliceMake _ _ cap))
 456         // result: cap
 457         for {
 458                 if v_0.Op != OpSliceMake {
 459                         break
 460                 }
 461                 cap := v_0.Args[2]
 462                 v.copyOf(cap)
 463                 return true
 464         }
 465         // match: (SliceCap x:(Load <t> ptr mem))
 466         // cond: t.IsSlice()
 467         // result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [2*config.PtrSize] ptr) mem)
 468         for {
 469                 x := v_0
 470                 if x.Op != OpLoad {
 471                         break
 472                 }
 473                 t := x.Type
 474                 mem := x.Args[1]
 475                 ptr := x.Args[0]
 476                 if !(t.IsSlice()) {
 477                         break
 478                 }
 479                 b = x.Block
 480                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Int)
 481                 v.copyOf(v0)
 482                 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 483                 v1.AuxInt = int64ToAuxInt(2 * config.PtrSize)
 484                 v1.AddArg(ptr)
 485                 v0.AddArg2(v1, mem)
 486                 return true
 487         }
 488         return false
 489 }
 490 func rewriteValuedec_OpSliceLen(v *Value) bool {
 491         v_0 := v.Args[0]
 492         b := v.Block
 493         config := b.Func.Config
 494         typ := &b.Func.Config.Types
 495         // match: (SliceLen (SliceMake _ len _))
 496         // result: len
 497         for {
 498                 if v_0.Op != OpSliceMake {
 499                         break
 500                 }
 501                 len := v_0.Args[1]
 502                 v.copyOf(len)
 503                 return true
 504         }
 505         // match: (SliceLen x:(Load <t> ptr mem))
 506         // cond: t.IsSlice()
 507         // result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem)
 508         for {
 509                 x := v_0
 510                 if x.Op != OpLoad {
 511                         break
 512                 }
 513                 t := x.Type
 514                 mem := x.Args[1]
 515                 ptr := x.Args[0]
 516                 if !(t.IsSlice()) {
 517                         break
 518                 }
 519                 b = x.Block
 520                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Int)
 521                 v.copyOf(v0)
 522                 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 523                 v1.AuxInt = int64ToAuxInt(config.PtrSize)
 524                 v1.AddArg(ptr)
 525                 v0.AddArg2(v1, mem)
 526                 return true
 527         }
 528         return false
 529 }
 530 func rewriteValuedec_OpSlicePtr(v *Value) bool {
 531         v_0 := v.Args[0]
 532         b := v.Block
 533         // match: (SlicePtr (SliceMake ptr _ _ ))
 534         // result: ptr
 535         for {
 536                 if v_0.Op != OpSliceMake {
 537                         break
 538                 }
 539                 ptr := v_0.Args[0]
 540                 v.copyOf(ptr)
 541                 return true
 542         }
 543         // match: (SlicePtr x:(Load <t> ptr mem))
 544         // cond: t.IsSlice()
 545         // result: @x.Block (Load <t.Elem().PtrTo()> ptr mem)
 546         for {
 547                 x := v_0
 548                 if x.Op != OpLoad {
 549                         break
 550                 }
 551                 t := x.Type
 552                 mem := x.Args[1]
 553                 ptr := x.Args[0]
 554                 if !(t.IsSlice()) {
 555                         break
 556                 }
 557                 b = x.Block
 558                 v0 := b.NewValue0(v.Pos, OpLoad, t.Elem().PtrTo())
 559                 v.copyOf(v0)
 560                 v0.AddArg2(ptr, mem)
 561                 return true
 562         }
 563         return false
 564 }
 565 func rewriteValuedec_OpSlicePtrUnchecked(v *Value) bool {
 566         v_0 := v.Args[0]
 567         // match: (SlicePtrUnchecked (SliceMake ptr _ _ ))
 568         // result: ptr
 569         for {
 570                 if v_0.Op != OpSliceMake {
 571                         break
 572                 }
 573                 ptr := v_0.Args[0]
 574                 v.copyOf(ptr)
 575                 return true
 576         }
 577         return false
 578 }
 579 func rewriteValuedec_OpStore(v *Value) bool {
 580         v_2 := v.Args[2]
 581         v_1 := v.Args[1]
 582         v_0 := v.Args[0]
 583         b := v.Block
 584         config := b.Func.Config
 585         typ := &b.Func.Config.Types
 586         // match: (Store {t} _ _ mem)
 587         // cond: t.Size() == 0
 588         // result: mem
 589         for {
 590                 t := auxToType(v.Aux)
 591                 mem := v_2
 592                 if !(t.Size() == 0) {
 593                         break
 594                 }
 595                 v.copyOf(mem)
 596                 return true
 597         }
 598         // match: (Store {t} dst (ComplexMake real imag) mem)
 599         // cond: t.Size() == 8
 600         // result: (Store {typ.Float32} (OffPtr <typ.Float32Ptr> [4] dst) imag (Store {typ.Float32} dst real mem))
 601         for {
 602                 t := auxToType(v.Aux)
 603                 dst := v_0
 604                 if v_1.Op != OpComplexMake {
 605                         break
 606                 }
 607                 imag := v_1.Args[1]
 608                 real := v_1.Args[0]
 609                 mem := v_2
 610                 if !(t.Size() == 8) {
 611                         break
 612                 }
 613                 v.reset(OpStore)
 614                 v.Aux = typeToAux(typ.Float32)
 615                 v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
 616                 v0.AuxInt = int64ToAuxInt(4)
 617                 v0.AddArg(dst)
 618                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 619                 v1.Aux = typeToAux(typ.Float32)
 620                 v1.AddArg3(dst, real, mem)
 621                 v.AddArg3(v0, imag, v1)
 622                 return true
 623         }
 624         // match: (Store {t} dst (ComplexMake real imag) mem)
 625         // cond: t.Size() == 16
 626         // result: (Store {typ.Float64} (OffPtr <typ.Float64Ptr> [8] dst) imag (Store {typ.Float64} dst real mem))
 627         for {
 628                 t := auxToType(v.Aux)
 629                 dst := v_0
 630                 if v_1.Op != OpComplexMake {
 631                         break
 632                 }
 633                 imag := v_1.Args[1]
 634                 real := v_1.Args[0]
 635                 mem := v_2
 636                 if !(t.Size() == 16) {
 637                         break
 638                 }
 639                 v.reset(OpStore)
 640                 v.Aux = typeToAux(typ.Float64)
 641                 v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
 642                 v0.AuxInt = int64ToAuxInt(8)
 643                 v0.AddArg(dst)
 644                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 645                 v1.Aux = typeToAux(typ.Float64)
 646                 v1.AddArg3(dst, real, mem)
 647                 v.AddArg3(v0, imag, v1)
 648                 return true
 649         }
 650         // match: (Store dst (StringMake ptr len) mem)
 651         // result: (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {typ.BytePtr} dst ptr mem))
 652         for {
 653                 dst := v_0
 654                 if v_1.Op != OpStringMake {
 655                         break
 656                 }
 657                 len := v_1.Args[1]
 658                 ptr := v_1.Args[0]
 659                 mem := v_2
 660                 v.reset(OpStore)
 661                 v.Aux = typeToAux(typ.Int)
 662                 v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 663                 v0.AuxInt = int64ToAuxInt(config.PtrSize)
 664                 v0.AddArg(dst)
 665                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 666                 v1.Aux = typeToAux(typ.BytePtr)
 667                 v1.AddArg3(dst, ptr, mem)
 668                 v.AddArg3(v0, len, v1)
 669                 return true
 670         }
 671         // match: (Store {t} dst (SliceMake ptr len cap) mem)
 672         // result: (Store {typ.Int} (OffPtr <typ.IntPtr> [2*config.PtrSize] dst) cap (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {t.Elem().PtrTo()} dst ptr mem)))
 673         for {
 674                 t := auxToType(v.Aux)
 675                 dst := v_0
 676                 if v_1.Op != OpSliceMake {
 677                         break
 678                 }
 679                 cap := v_1.Args[2]
 680                 ptr := v_1.Args[0]
 681                 len := v_1.Args[1]
 682                 mem := v_2
 683                 v.reset(OpStore)
 684                 v.Aux = typeToAux(typ.Int)
 685                 v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 686                 v0.AuxInt = int64ToAuxInt(2 * config.PtrSize)
 687                 v0.AddArg(dst)
 688                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 689                 v1.Aux = typeToAux(typ.Int)
 690                 v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 691                 v2.AuxInt = int64ToAuxInt(config.PtrSize)
 692                 v2.AddArg(dst)
 693                 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 694                 v3.Aux = typeToAux(t.Elem().PtrTo())
 695                 v3.AddArg3(dst, ptr, mem)
 696                 v1.AddArg3(v2, len, v3)
 697                 v.AddArg3(v0, cap, v1)
 698                 return true
 699         }
 700         // match: (Store dst (IMake itab data) mem)
 701         // result: (Store {typ.BytePtr} (OffPtr <typ.BytePtrPtr> [config.PtrSize] dst) data (Store {typ.Uintptr} dst itab mem))
 702         for {
 703                 dst := v_0
 704                 if v_1.Op != OpIMake {
 705                         break
 706                 }
 707                 data := v_1.Args[1]
 708                 itab := v_1.Args[0]
 709                 mem := v_2
 710                 v.reset(OpStore)
 711                 v.Aux = typeToAux(typ.BytePtr)
 712                 v0 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
 713                 v0.AuxInt = int64ToAuxInt(config.PtrSize)
 714                 v0.AddArg(dst)
 715                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 716                 v1.Aux = typeToAux(typ.Uintptr)
 717                 v1.AddArg3(dst, itab, mem)
 718                 v.AddArg3(v0, data, v1)
 719                 return true
 720         }
 721         // match: (Store dst (StructMake1 <t> f0) mem)
 722         // result: (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
 723         for {
 724                 dst := v_0
 725                 if v_1.Op != OpStructMake1 {
 726                         break
 727                 }
 728                 t := v_1.Type
 729                 f0 := v_1.Args[0]
 730                 mem := v_2
 731                 v.reset(OpStore)
 732                 v.Aux = typeToAux(t.FieldType(0))
 733                 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 734                 v0.AuxInt = int64ToAuxInt(0)
 735                 v0.AddArg(dst)
 736                 v.AddArg3(v0, f0, mem)
 737                 return true
 738         }
 739         // match: (Store dst (StructMake2 <t> f0 f1) mem)
 740         // result: (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))
 741         for {
 742                 dst := v_0
 743                 if v_1.Op != OpStructMake2 {
 744                         break
 745                 }
 746                 t := v_1.Type
 747                 f1 := v_1.Args[1]
 748                 f0 := v_1.Args[0]
 749                 mem := v_2
 750                 v.reset(OpStore)
 751                 v.Aux = typeToAux(t.FieldType(1))
 752                 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 753                 v0.AuxInt = int64ToAuxInt(t.FieldOff(1))
 754                 v0.AddArg(dst)
 755                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 756                 v1.Aux = typeToAux(t.FieldType(0))
 757                 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 758                 v2.AuxInt = int64ToAuxInt(0)
 759                 v2.AddArg(dst)
 760                 v1.AddArg3(v2, f0, mem)
 761                 v.AddArg3(v0, f1, v1)
 762                 return true
 763         }
 764         // match: (Store dst (StructMake3 <t> f0 f1 f2) mem)
 765         // result: (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)))
 766         for {
 767                 dst := v_0
 768                 if v_1.Op != OpStructMake3 {
 769                         break
 770                 }
 771                 t := v_1.Type
 772                 f2 := v_1.Args[2]
 773                 f0 := v_1.Args[0]
 774                 f1 := v_1.Args[1]
 775                 mem := v_2
 776                 v.reset(OpStore)
 777                 v.Aux = typeToAux(t.FieldType(2))
 778                 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 779                 v0.AuxInt = int64ToAuxInt(t.FieldOff(2))
 780                 v0.AddArg(dst)
 781                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 782                 v1.Aux = typeToAux(t.FieldType(1))
 783                 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 784                 v2.AuxInt = int64ToAuxInt(t.FieldOff(1))
 785                 v2.AddArg(dst)
 786                 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 787                 v3.Aux = typeToAux(t.FieldType(0))
 788                 v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 789                 v4.AuxInt = int64ToAuxInt(0)
 790                 v4.AddArg(dst)
 791                 v3.AddArg3(v4, f0, mem)
 792                 v1.AddArg3(v2, f1, v3)
 793                 v.AddArg3(v0, f2, v1)
 794                 return true
 795         }
 796         // match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem)
 797         // result: (Store {t.FieldType(3)} (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))))
 798         for {
 799                 dst := v_0
 800                 if v_1.Op != OpStructMake4 {
 801                         break
 802                 }
 803                 t := v_1.Type
 804                 f3 := v_1.Args[3]
 805                 f0 := v_1.Args[0]
 806                 f1 := v_1.Args[1]
 807                 f2 := v_1.Args[2]
 808                 mem := v_2
 809                 v.reset(OpStore)
 810                 v.Aux = typeToAux(t.FieldType(3))
 811                 v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo())
 812                 v0.AuxInt = int64ToAuxInt(t.FieldOff(3))
 813                 v0.AddArg(dst)
 814                 v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 815                 v1.Aux = typeToAux(t.FieldType(2))
 816                 v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 817                 v2.AuxInt = int64ToAuxInt(t.FieldOff(2))
 818                 v2.AddArg(dst)
 819                 v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 820                 v3.Aux = typeToAux(t.FieldType(1))
 821                 v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 822                 v4.AuxInt = int64ToAuxInt(t.FieldOff(1))
 823                 v4.AddArg(dst)
 824                 v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 825                 v5.Aux = typeToAux(t.FieldType(0))
 826                 v6 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 827                 v6.AuxInt = int64ToAuxInt(0)
 828                 v6.AddArg(dst)
 829                 v5.AddArg3(v6, f0, mem)
 830                 v3.AddArg3(v4, f1, v5)
 831                 v1.AddArg3(v2, f2, v3)
 832                 v.AddArg3(v0, f3, v1)
 833                 return true
 834         }
 835         // match: (Store dst (ArrayMake1 e) mem)
 836         // result: (Store {e.Type} dst e mem)
 837         for {
 838                 dst := v_0
 839                 if v_1.Op != OpArrayMake1 {
 840                         break
 841                 }
 842                 e := v_1.Args[0]
 843                 mem := v_2
 844                 v.reset(OpStore)
 845                 v.Aux = typeToAux(e.Type)
 846                 v.AddArg3(dst, e, mem)
 847                 return true
 848         }
 849         return false
 850 }
 851 func rewriteValuedec_OpStringLen(v *Value) bool {
 852         v_0 := v.Args[0]
 853         b := v.Block
 854         config := b.Func.Config
 855         typ := &b.Func.Config.Types
 856         // match: (StringLen (StringMake _ len))
 857         // result: len
 858         for {
 859                 if v_0.Op != OpStringMake {
 860                         break
 861                 }
 862                 len := v_0.Args[1]
 863                 v.copyOf(len)
 864                 return true
 865         }
 866         // match: (StringLen x:(Load <t> ptr mem))
 867         // cond: t.IsString()
 868         // result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem)
 869         for {
 870                 x := v_0
 871                 if x.Op != OpLoad {
 872                         break
 873                 }
 874                 t := x.Type
 875                 mem := x.Args[1]
 876                 ptr := x.Args[0]
 877                 if !(t.IsString()) {
 878                         break
 879                 }
 880                 b = x.Block
 881                 v0 := b.NewValue0(v.Pos, OpLoad, typ.Int)
 882                 v.copyOf(v0)
 883                 v1 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
 884                 v1.AuxInt = int64ToAuxInt(config.PtrSize)
 885                 v1.AddArg(ptr)
 886                 v0.AddArg2(v1, mem)
 887                 return true
 888         }
 889         return false
 890 }
 891 func rewriteValuedec_OpStringPtr(v *Value) bool {
 892         v_0 := v.Args[0]
 893         b := v.Block
 894         typ := &b.Func.Config.Types
 895         // match: (StringPtr (StringMake ptr _))
 896         // result: ptr
 897         for {
 898                 if v_0.Op != OpStringMake {
 899                         break
 900                 }
 901                 ptr := v_0.Args[0]
 902                 v.copyOf(ptr)
 903                 return true
 904         }
 905         // match: (StringPtr x:(Load <t> ptr mem))
 906         // cond: t.IsString()
 907         // result: @x.Block (Load <typ.BytePtr> ptr mem)
 908         for {
 909                 x := v_0
 910                 if x.Op != OpLoad {
 911                         break
 912                 }
 913                 t := x.Type
 914                 mem := x.Args[1]
 915                 ptr := x.Args[0]
 916                 if !(t.IsString()) {
 917                         break
 918                 }
 919                 b = x.Block
 920                 v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
 921                 v.copyOf(v0)
 922                 v0.AddArg2(ptr, mem)
 923                 return true
 924         }
 925         return false
 926 }
 927 func rewriteValuedec_OpStructMake1(v *Value) bool {
 928         v_0 := v.Args[0]
 929         // match: (StructMake1 x)
 930         // cond: x.Type.IsPtr()
 931         // result: x
 932         for {
 933                 x := v_0
 934                 if !(x.Type.IsPtr()) {
 935                         break
 936                 }
 937                 v.copyOf(x)
 938                 return true
 939         }
 940         return false
 941 }
 942 func rewriteValuedec_OpStructSelect(v *Value) bool {
 943         v_0 := v.Args[0]
 944         b := v.Block
 945         // match: (StructSelect [0] (IData x))
 946         // result: (IData x)
 947         for {
 948                 if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpIData {
 949                         break
 950                 }
 951                 x := v_0.Args[0]
 952                 v.reset(OpIData)
 953                 v.AddArg(x)
 954                 return true
 955         }
 956         // match: (StructSelect (StructMake1 x))
 957         // result: x
 958         for {
 959                 if v_0.Op != OpStructMake1 {
 960                         break
 961                 }
 962                 x := v_0.Args[0]
 963                 v.copyOf(x)
 964                 return true
 965         }
 966         // match: (StructSelect [0] (StructMake2 x _))
 967         // result: x
 968         for {
 969                 if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpStructMake2 {
 970                         break
 971                 }
 972                 x := v_0.Args[0]
 973                 v.copyOf(x)
 974                 return true
 975         }
 976         // match: (StructSelect [1] (StructMake2 _ x))
 977         // result: x
 978         for {
 979                 if auxIntToInt64(v.AuxInt) != 1 || v_0.Op != OpStructMake2 {
 980                         break
 981                 }
 982                 x := v_0.Args[1]
 983                 v.copyOf(x)
 984                 return true
 985         }
 986         // match: (StructSelect [0] (StructMake3 x _ _))
 987         // result: x
 988         for {
 989                 if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpStructMake3 {
 990                         break
 991                 }
 992                 x := v_0.Args[0]
 993                 v.copyOf(x)
 994                 return true
 995         }
 996         // match: (StructSelect [1] (StructMake3 _ x _))
 997         // result: x
 998         for {
 999                 if auxIntToInt64(v.AuxInt) != 1 || v_0.Op != OpStructMake3 {
1000                         break
1001                 }
1002                 x := v_0.Args[1]
1003                 v.copyOf(x)
1004                 return true
1005         }
1006         // match: (StructSelect [2] (StructMake3 _ _ x))
1007         // result: x
1008         for {
1009                 if auxIntToInt64(v.AuxInt) != 2 || v_0.Op != OpStructMake3 {
1010                         break
1011                 }
1012                 x := v_0.Args[2]
1013                 v.copyOf(x)
1014                 return true
1015         }
1016         // match: (StructSelect [0] (StructMake4 x _ _ _))
1017         // result: x
1018         for {
1019                 if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpStructMake4 {
1020                         break
1021                 }
1022                 x := v_0.Args[0]
1023                 v.copyOf(x)
1024                 return true
1025         }
1026         // match: (StructSelect [1] (StructMake4 _ x _ _))
1027         // result: x
1028         for {
1029                 if auxIntToInt64(v.AuxInt) != 1 || v_0.Op != OpStructMake4 {
1030                         break
1031                 }
1032                 x := v_0.Args[1]
1033                 v.copyOf(x)
1034                 return true
1035         }
1036         // match: (StructSelect [2] (StructMake4 _ _ x _))
1037         // result: x
1038         for {
1039                 if auxIntToInt64(v.AuxInt) != 2 || v_0.Op != OpStructMake4 {
1040                         break
1041                 }
1042                 x := v_0.Args[2]
1043                 v.copyOf(x)
1044                 return true
1045         }
1046         // match: (StructSelect [3] (StructMake4 _ _ _ x))
1047         // result: x
1048         for {
1049                 if auxIntToInt64(v.AuxInt) != 3 || v_0.Op != OpStructMake4 {
1050                         break
1051                 }
1052                 x := v_0.Args[3]
1053                 v.copyOf(x)
1054                 return true
1055         }
1056         // match: (StructSelect [0] x)
1057         // cond: x.Type.IsPtr()
1058         // result: x
1059         for {
1060                 if auxIntToInt64(v.AuxInt) != 0 {
1061                         break
1062                 }
1063                 x := v_0
1064                 if !(x.Type.IsPtr()) {
1065                         break
1066                 }
1067                 v.copyOf(x)
1068                 return true
1069         }
1070         // match: (StructSelect [i] x:(Load <t> ptr mem))
1071         // result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
1072         for {
1073                 i := auxIntToInt64(v.AuxInt)
1074                 x := v_0
1075                 if x.Op != OpLoad {
1076                         break
1077                 }
1078                 t := x.Type
1079                 mem := x.Args[1]
1080                 ptr := x.Args[0]
1081                 b = x.Block
1082                 v0 := b.NewValue0(v.Pos, OpLoad, v.Type)
1083                 v.copyOf(v0)
1084                 v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo())
1085                 v1.AuxInt = int64ToAuxInt(t.FieldOff(int(i)))
1086                 v1.AddArg(ptr)
1087                 v0.AddArg2(v1, mem)
1088                 return true
1089         }
1090         return false
1091 }
1092 func rewriteBlockdec(b *Block) bool {
1093         return false
1094 }