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 OpStructMake:
    40  		return rewriteValuedec_OpStructMake(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.IsPtrShaped()
    50  	// result: x
    51  	for {
    52  		x := v_0
    53  		if !(x.Type.IsPtrShaped()) {
    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.IsPtrShaped()
    66  	// result: x
    67  	for {
    68  		if auxIntToInt64(v.AuxInt) != 0 {
    69  			break
    70  		}
    71  		x := v_0
    72  		if !(x.Type.IsPtrShaped()) {
    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 (StructMake val))
   283  	// result: (IMake _typ val)
   284  	for {
   285  		_typ := v_0
   286  		if v_1.Op != OpStructMake || len(v_1.Args) != 1 {
   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 _ (StructMake ___) _)
   722  	// result: rewriteStructStore(v)
   723  	for {
   724  		if v_1.Op != OpStructMake {
   725  			break
   726  		}
   727  		v.copyOf(rewriteStructStore(v))
   728  		return true
   729  	}
   730  	// match: (Store dst (ArrayMake1 e) mem)
   731  	// result: (Store {e.Type} dst e mem)
   732  	for {
   733  		dst := v_0
   734  		if v_1.Op != OpArrayMake1 {
   735  			break
   736  		}
   737  		e := v_1.Args[0]
   738  		mem := v_2
   739  		v.reset(OpStore)
   740  		v.Aux = typeToAux(e.Type)
   741  		v.AddArg3(dst, e, mem)
   742  		return true
   743  	}
   744  	return false
   745  }
   746  func rewriteValuedec_OpStringLen(v *Value) bool {
   747  	v_0 := v.Args[0]
   748  	b := v.Block
   749  	config := b.Func.Config
   750  	typ := &b.Func.Config.Types
   751  	// match: (StringLen (StringMake _ len))
   752  	// result: len
   753  	for {
   754  		if v_0.Op != OpStringMake {
   755  			break
   756  		}
   757  		len := v_0.Args[1]
   758  		v.copyOf(len)
   759  		return true
   760  	}
   761  	// match: (StringLen x:(Load <t> ptr mem))
   762  	// cond: t.IsString()
   763  	// result: @x.Block (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem)
   764  	for {
   765  		x := v_0
   766  		if x.Op != OpLoad {
   767  			break
   768  		}
   769  		t := x.Type
   770  		mem := x.Args[1]
   771  		ptr := x.Args[0]
   772  		if !(t.IsString()) {
   773  			break
   774  		}
   775  		b = x.Block
   776  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   777  		v.copyOf(v0)
   778  		v1 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   779  		v1.AuxInt = int64ToAuxInt(config.PtrSize)
   780  		v1.AddArg(ptr)
   781  		v0.AddArg2(v1, mem)
   782  		return true
   783  	}
   784  	return false
   785  }
   786  func rewriteValuedec_OpStringPtr(v *Value) bool {
   787  	v_0 := v.Args[0]
   788  	b := v.Block
   789  	typ := &b.Func.Config.Types
   790  	// match: (StringPtr (StringMake ptr _))
   791  	// result: ptr
   792  	for {
   793  		if v_0.Op != OpStringMake {
   794  			break
   795  		}
   796  		ptr := v_0.Args[0]
   797  		v.copyOf(ptr)
   798  		return true
   799  	}
   800  	// match: (StringPtr x:(Load <t> ptr mem))
   801  	// cond: t.IsString()
   802  	// result: @x.Block (Load <typ.BytePtr> ptr mem)
   803  	for {
   804  		x := v_0
   805  		if x.Op != OpLoad {
   806  			break
   807  		}
   808  		t := x.Type
   809  		mem := x.Args[1]
   810  		ptr := x.Args[0]
   811  		if !(t.IsString()) {
   812  			break
   813  		}
   814  		b = x.Block
   815  		v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
   816  		v.copyOf(v0)
   817  		v0.AddArg2(ptr, mem)
   818  		return true
   819  	}
   820  	return false
   821  }
   822  func rewriteValuedec_OpStructMake(v *Value) bool {
   823  	// match: (StructMake x)
   824  	// cond: x.Type.IsPtrShaped()
   825  	// result: x
   826  	for {
   827  		if len(v.Args) != 1 {
   828  			break
   829  		}
   830  		x := v.Args[0]
   831  		if !(x.Type.IsPtrShaped()) {
   832  			break
   833  		}
   834  		v.copyOf(x)
   835  		return true
   836  	}
   837  	return false
   838  }
   839  func rewriteValuedec_OpStructSelect(v *Value) bool {
   840  	v_0 := v.Args[0]
   841  	b := v.Block
   842  	// match: (StructSelect [0] (IData x))
   843  	// result: (IData x)
   844  	for {
   845  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpIData {
   846  			break
   847  		}
   848  		x := v_0.Args[0]
   849  		v.reset(OpIData)
   850  		v.AddArg(x)
   851  		return true
   852  	}
   853  	// match: (StructSelect [i] x:(StructMake ___))
   854  	// result: x.Args[i]
   855  	for {
   856  		i := auxIntToInt64(v.AuxInt)
   857  		x := v_0
   858  		if x.Op != OpStructMake {
   859  			break
   860  		}
   861  		v.copyOf(x.Args[i])
   862  		return true
   863  	}
   864  	// match: (StructSelect [0] x)
   865  	// cond: x.Type.IsPtrShaped()
   866  	// result: x
   867  	for {
   868  		if auxIntToInt64(v.AuxInt) != 0 {
   869  			break
   870  		}
   871  		x := v_0
   872  		if !(x.Type.IsPtrShaped()) {
   873  			break
   874  		}
   875  		v.copyOf(x)
   876  		return true
   877  	}
   878  	// match: (StructSelect [i] x:(Load <t> ptr mem))
   879  	// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
   880  	for {
   881  		i := auxIntToInt64(v.AuxInt)
   882  		x := v_0
   883  		if x.Op != OpLoad {
   884  			break
   885  		}
   886  		t := x.Type
   887  		mem := x.Args[1]
   888  		ptr := x.Args[0]
   889  		b = x.Block
   890  		v0 := b.NewValue0(v.Pos, OpLoad, v.Type)
   891  		v.copyOf(v0)
   892  		v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo())
   893  		v1.AuxInt = int64ToAuxInt(t.FieldOff(int(i)))
   894  		v1.AddArg(ptr)
   895  		v0.AddArg2(v1, mem)
   896  		return true
   897  	}
   898  	return false
   899  }
   900  func rewriteBlockdec(b *Block) bool {
   901  	return false
   902  }
   903
View as plain text