Source file src/cmd/compile/internal/ssarewrite/rewritedec/rewritedec.go

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

View as plain text