github.com/epfl-dcsl/gotee@v0.0.0-20200909122901-014b35f5e5e9/src/cmd/compile/internal/ssa/rewritedec.go (about)

     1  // Code generated from gen/dec.rules; DO NOT EDIT.
     2  // generated with: cd gen; go run *.go
     3  
     4  package ssa
     5  
     6  import "math"
     7  import "cmd/internal/obj"
     8  import "cmd/internal/objabi"
     9  import "cmd/compile/internal/types"
    10  
    11  var _ = math.MinInt8  // in case not otherwise used
    12  var _ = obj.ANOP      // in case not otherwise used
    13  var _ = objabi.GOROOT // in case not otherwise used
    14  var _ = types.TypeMem // in case not otherwise used
    15  
    16  func rewriteValuedec(v *Value) bool {
    17  	switch v.Op {
    18  	case OpComplexImag:
    19  		return rewriteValuedec_OpComplexImag_0(v)
    20  	case OpComplexReal:
    21  		return rewriteValuedec_OpComplexReal_0(v)
    22  	case OpIData:
    23  		return rewriteValuedec_OpIData_0(v)
    24  	case OpITab:
    25  		return rewriteValuedec_OpITab_0(v)
    26  	case OpLoad:
    27  		return rewriteValuedec_OpLoad_0(v)
    28  	case OpSliceCap:
    29  		return rewriteValuedec_OpSliceCap_0(v)
    30  	case OpSliceLen:
    31  		return rewriteValuedec_OpSliceLen_0(v)
    32  	case OpSlicePtr:
    33  		return rewriteValuedec_OpSlicePtr_0(v)
    34  	case OpStore:
    35  		return rewriteValuedec_OpStore_0(v)
    36  	case OpStringLen:
    37  		return rewriteValuedec_OpStringLen_0(v)
    38  	case OpStringPtr:
    39  		return rewriteValuedec_OpStringPtr_0(v)
    40  	}
    41  	return false
    42  }
    43  func rewriteValuedec_OpComplexImag_0(v *Value) bool {
    44  	// match: (ComplexImag (ComplexMake _ imag))
    45  	// cond:
    46  	// result: imag
    47  	for {
    48  		v_0 := v.Args[0]
    49  		if v_0.Op != OpComplexMake {
    50  			break
    51  		}
    52  		_ = v_0.Args[1]
    53  		imag := v_0.Args[1]
    54  		v.reset(OpCopy)
    55  		v.Type = imag.Type
    56  		v.AddArg(imag)
    57  		return true
    58  	}
    59  	return false
    60  }
    61  func rewriteValuedec_OpComplexReal_0(v *Value) bool {
    62  	// match: (ComplexReal (ComplexMake real _))
    63  	// cond:
    64  	// result: real
    65  	for {
    66  		v_0 := v.Args[0]
    67  		if v_0.Op != OpComplexMake {
    68  			break
    69  		}
    70  		_ = v_0.Args[1]
    71  		real := v_0.Args[0]
    72  		v.reset(OpCopy)
    73  		v.Type = real.Type
    74  		v.AddArg(real)
    75  		return true
    76  	}
    77  	return false
    78  }
    79  func rewriteValuedec_OpIData_0(v *Value) bool {
    80  	// match: (IData (IMake _ data))
    81  	// cond:
    82  	// result: data
    83  	for {
    84  		v_0 := v.Args[0]
    85  		if v_0.Op != OpIMake {
    86  			break
    87  		}
    88  		_ = v_0.Args[1]
    89  		data := v_0.Args[1]
    90  		v.reset(OpCopy)
    91  		v.Type = data.Type
    92  		v.AddArg(data)
    93  		return true
    94  	}
    95  	return false
    96  }
    97  func rewriteValuedec_OpITab_0(v *Value) bool {
    98  	b := v.Block
    99  	_ = b
   100  	// match: (ITab (IMake itab _))
   101  	// cond:
   102  	// result: itab
   103  	for {
   104  		v_0 := v.Args[0]
   105  		if v_0.Op != OpIMake {
   106  			break
   107  		}
   108  		_ = v_0.Args[1]
   109  		itab := v_0.Args[0]
   110  		v.reset(OpCopy)
   111  		v.Type = itab.Type
   112  		v.AddArg(itab)
   113  		return true
   114  	}
   115  	return false
   116  }
   117  func rewriteValuedec_OpLoad_0(v *Value) bool {
   118  	b := v.Block
   119  	_ = b
   120  	config := b.Func.Config
   121  	_ = config
   122  	typ := &b.Func.Config.Types
   123  	_ = typ
   124  	// match: (Load <t> ptr mem)
   125  	// cond: t.IsComplex() && t.Size() == 8
   126  	// result: (ComplexMake     (Load <typ.Float32> ptr mem)     (Load <typ.Float32>       (OffPtr <typ.Float32Ptr> [4] ptr)       mem)     )
   127  	for {
   128  		t := v.Type
   129  		_ = v.Args[1]
   130  		ptr := v.Args[0]
   131  		mem := v.Args[1]
   132  		if !(t.IsComplex() && t.Size() == 8) {
   133  			break
   134  		}
   135  		v.reset(OpComplexMake)
   136  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
   137  		v0.AddArg(ptr)
   138  		v0.AddArg(mem)
   139  		v.AddArg(v0)
   140  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
   141  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
   142  		v2.AuxInt = 4
   143  		v2.AddArg(ptr)
   144  		v1.AddArg(v2)
   145  		v1.AddArg(mem)
   146  		v.AddArg(v1)
   147  		return true
   148  	}
   149  	// match: (Load <t> ptr mem)
   150  	// cond: t.IsComplex() && t.Size() == 16
   151  	// result: (ComplexMake     (Load <typ.Float64> ptr mem)     (Load <typ.Float64>       (OffPtr <typ.Float64Ptr> [8] ptr)       mem)     )
   152  	for {
   153  		t := v.Type
   154  		_ = v.Args[1]
   155  		ptr := v.Args[0]
   156  		mem := v.Args[1]
   157  		if !(t.IsComplex() && t.Size() == 16) {
   158  			break
   159  		}
   160  		v.reset(OpComplexMake)
   161  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
   162  		v0.AddArg(ptr)
   163  		v0.AddArg(mem)
   164  		v.AddArg(v0)
   165  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
   166  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
   167  		v2.AuxInt = 8
   168  		v2.AddArg(ptr)
   169  		v1.AddArg(v2)
   170  		v1.AddArg(mem)
   171  		v.AddArg(v1)
   172  		return true
   173  	}
   174  	// match: (Load <t> ptr mem)
   175  	// cond: t.IsString()
   176  	// result: (StringMake     (Load <typ.BytePtr> ptr mem)     (Load <typ.Int>       (OffPtr <typ.IntPtr> [config.PtrSize] ptr)       mem))
   177  	for {
   178  		t := v.Type
   179  		_ = v.Args[1]
   180  		ptr := v.Args[0]
   181  		mem := v.Args[1]
   182  		if !(t.IsString()) {
   183  			break
   184  		}
   185  		v.reset(OpStringMake)
   186  		v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
   187  		v0.AddArg(ptr)
   188  		v0.AddArg(mem)
   189  		v.AddArg(v0)
   190  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   191  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   192  		v2.AuxInt = config.PtrSize
   193  		v2.AddArg(ptr)
   194  		v1.AddArg(v2)
   195  		v1.AddArg(mem)
   196  		v.AddArg(v1)
   197  		return true
   198  	}
   199  	// match: (Load <t> ptr mem)
   200  	// cond: t.IsSlice()
   201  	// result: (SliceMake     (Load <t.ElemType().PtrTo()> ptr mem)     (Load <typ.Int>       (OffPtr <typ.IntPtr> [config.PtrSize] ptr)       mem)     (Load <typ.Int>       (OffPtr <typ.IntPtr> [2*config.PtrSize] ptr)       mem))
   202  	for {
   203  		t := v.Type
   204  		_ = v.Args[1]
   205  		ptr := v.Args[0]
   206  		mem := v.Args[1]
   207  		if !(t.IsSlice()) {
   208  			break
   209  		}
   210  		v.reset(OpSliceMake)
   211  		v0 := b.NewValue0(v.Pos, OpLoad, t.ElemType().PtrTo())
   212  		v0.AddArg(ptr)
   213  		v0.AddArg(mem)
   214  		v.AddArg(v0)
   215  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   216  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   217  		v2.AuxInt = config.PtrSize
   218  		v2.AddArg(ptr)
   219  		v1.AddArg(v2)
   220  		v1.AddArg(mem)
   221  		v.AddArg(v1)
   222  		v3 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   223  		v4 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   224  		v4.AuxInt = 2 * config.PtrSize
   225  		v4.AddArg(ptr)
   226  		v3.AddArg(v4)
   227  		v3.AddArg(mem)
   228  		v.AddArg(v3)
   229  		return true
   230  	}
   231  	// match: (Load <t> ptr mem)
   232  	// cond: t.IsInterface()
   233  	// result: (IMake     (Load <typ.BytePtr> ptr mem)     (Load <typ.BytePtr>       (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr)       mem))
   234  	for {
   235  		t := v.Type
   236  		_ = v.Args[1]
   237  		ptr := v.Args[0]
   238  		mem := v.Args[1]
   239  		if !(t.IsInterface()) {
   240  			break
   241  		}
   242  		v.reset(OpIMake)
   243  		v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
   244  		v0.AddArg(ptr)
   245  		v0.AddArg(mem)
   246  		v.AddArg(v0)
   247  		v1 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
   248  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
   249  		v2.AuxInt = config.PtrSize
   250  		v2.AddArg(ptr)
   251  		v1.AddArg(v2)
   252  		v1.AddArg(mem)
   253  		v.AddArg(v1)
   254  		return true
   255  	}
   256  	return false
   257  }
   258  func rewriteValuedec_OpSliceCap_0(v *Value) bool {
   259  	// match: (SliceCap (SliceMake _ _ cap))
   260  	// cond:
   261  	// result: cap
   262  	for {
   263  		v_0 := v.Args[0]
   264  		if v_0.Op != OpSliceMake {
   265  			break
   266  		}
   267  		_ = v_0.Args[2]
   268  		cap := v_0.Args[2]
   269  		v.reset(OpCopy)
   270  		v.Type = cap.Type
   271  		v.AddArg(cap)
   272  		return true
   273  	}
   274  	return false
   275  }
   276  func rewriteValuedec_OpSliceLen_0(v *Value) bool {
   277  	// match: (SliceLen (SliceMake _ len _))
   278  	// cond:
   279  	// result: len
   280  	for {
   281  		v_0 := v.Args[0]
   282  		if v_0.Op != OpSliceMake {
   283  			break
   284  		}
   285  		_ = v_0.Args[2]
   286  		len := v_0.Args[1]
   287  		v.reset(OpCopy)
   288  		v.Type = len.Type
   289  		v.AddArg(len)
   290  		return true
   291  	}
   292  	return false
   293  }
   294  func rewriteValuedec_OpSlicePtr_0(v *Value) bool {
   295  	// match: (SlicePtr (SliceMake ptr _ _))
   296  	// cond:
   297  	// result: ptr
   298  	for {
   299  		v_0 := v.Args[0]
   300  		if v_0.Op != OpSliceMake {
   301  			break
   302  		}
   303  		_ = v_0.Args[2]
   304  		ptr := v_0.Args[0]
   305  		v.reset(OpCopy)
   306  		v.Type = ptr.Type
   307  		v.AddArg(ptr)
   308  		return true
   309  	}
   310  	return false
   311  }
   312  func rewriteValuedec_OpStore_0(v *Value) bool {
   313  	b := v.Block
   314  	_ = b
   315  	config := b.Func.Config
   316  	_ = config
   317  	typ := &b.Func.Config.Types
   318  	_ = typ
   319  	// match: (Store {t} dst (ComplexMake real imag) mem)
   320  	// cond: t.(*types.Type).Size() == 8
   321  	// result: (Store {typ.Float32}     (OffPtr <typ.Float32Ptr> [4] dst)     imag     (Store {typ.Float32} dst real mem))
   322  	for {
   323  		t := v.Aux
   324  		_ = v.Args[2]
   325  		dst := v.Args[0]
   326  		v_1 := v.Args[1]
   327  		if v_1.Op != OpComplexMake {
   328  			break
   329  		}
   330  		_ = v_1.Args[1]
   331  		real := v_1.Args[0]
   332  		imag := v_1.Args[1]
   333  		mem := v.Args[2]
   334  		if !(t.(*types.Type).Size() == 8) {
   335  			break
   336  		}
   337  		v.reset(OpStore)
   338  		v.Aux = typ.Float32
   339  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
   340  		v0.AuxInt = 4
   341  		v0.AddArg(dst)
   342  		v.AddArg(v0)
   343  		v.AddArg(imag)
   344  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   345  		v1.Aux = typ.Float32
   346  		v1.AddArg(dst)
   347  		v1.AddArg(real)
   348  		v1.AddArg(mem)
   349  		v.AddArg(v1)
   350  		return true
   351  	}
   352  	// match: (Store {t} dst (ComplexMake real imag) mem)
   353  	// cond: t.(*types.Type).Size() == 16
   354  	// result: (Store {typ.Float64}     (OffPtr <typ.Float64Ptr> [8] dst)     imag     (Store {typ.Float64} dst real mem))
   355  	for {
   356  		t := v.Aux
   357  		_ = v.Args[2]
   358  		dst := v.Args[0]
   359  		v_1 := v.Args[1]
   360  		if v_1.Op != OpComplexMake {
   361  			break
   362  		}
   363  		_ = v_1.Args[1]
   364  		real := v_1.Args[0]
   365  		imag := v_1.Args[1]
   366  		mem := v.Args[2]
   367  		if !(t.(*types.Type).Size() == 16) {
   368  			break
   369  		}
   370  		v.reset(OpStore)
   371  		v.Aux = typ.Float64
   372  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
   373  		v0.AuxInt = 8
   374  		v0.AddArg(dst)
   375  		v.AddArg(v0)
   376  		v.AddArg(imag)
   377  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   378  		v1.Aux = typ.Float64
   379  		v1.AddArg(dst)
   380  		v1.AddArg(real)
   381  		v1.AddArg(mem)
   382  		v.AddArg(v1)
   383  		return true
   384  	}
   385  	// match: (Store dst (StringMake ptr len) mem)
   386  	// cond:
   387  	// result: (Store {typ.Int}     (OffPtr <typ.IntPtr> [config.PtrSize] dst)     len     (Store {typ.BytePtr} dst ptr mem))
   388  	for {
   389  		_ = v.Args[2]
   390  		dst := v.Args[0]
   391  		v_1 := v.Args[1]
   392  		if v_1.Op != OpStringMake {
   393  			break
   394  		}
   395  		_ = v_1.Args[1]
   396  		ptr := v_1.Args[0]
   397  		len := v_1.Args[1]
   398  		mem := v.Args[2]
   399  		v.reset(OpStore)
   400  		v.Aux = typ.Int
   401  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   402  		v0.AuxInt = config.PtrSize
   403  		v0.AddArg(dst)
   404  		v.AddArg(v0)
   405  		v.AddArg(len)
   406  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   407  		v1.Aux = typ.BytePtr
   408  		v1.AddArg(dst)
   409  		v1.AddArg(ptr)
   410  		v1.AddArg(mem)
   411  		v.AddArg(v1)
   412  		return true
   413  	}
   414  	// match: (Store dst (SliceMake ptr len cap) mem)
   415  	// cond:
   416  	// result: (Store {typ.Int}     (OffPtr <typ.IntPtr> [2*config.PtrSize] dst)     cap     (Store {typ.Int}       (OffPtr <typ.IntPtr> [config.PtrSize] dst)       len       (Store {typ.BytePtr} dst ptr mem)))
   417  	for {
   418  		_ = v.Args[2]
   419  		dst := v.Args[0]
   420  		v_1 := v.Args[1]
   421  		if v_1.Op != OpSliceMake {
   422  			break
   423  		}
   424  		_ = v_1.Args[2]
   425  		ptr := v_1.Args[0]
   426  		len := v_1.Args[1]
   427  		cap := v_1.Args[2]
   428  		mem := v.Args[2]
   429  		v.reset(OpStore)
   430  		v.Aux = typ.Int
   431  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   432  		v0.AuxInt = 2 * config.PtrSize
   433  		v0.AddArg(dst)
   434  		v.AddArg(v0)
   435  		v.AddArg(cap)
   436  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   437  		v1.Aux = typ.Int
   438  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   439  		v2.AuxInt = config.PtrSize
   440  		v2.AddArg(dst)
   441  		v1.AddArg(v2)
   442  		v1.AddArg(len)
   443  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   444  		v3.Aux = typ.BytePtr
   445  		v3.AddArg(dst)
   446  		v3.AddArg(ptr)
   447  		v3.AddArg(mem)
   448  		v1.AddArg(v3)
   449  		v.AddArg(v1)
   450  		return true
   451  	}
   452  	// match: (Store dst (IMake itab data) mem)
   453  	// cond:
   454  	// result: (Store {typ.BytePtr}     (OffPtr <typ.BytePtrPtr> [config.PtrSize] dst)     data     (Store {typ.Uintptr} dst itab mem))
   455  	for {
   456  		_ = v.Args[2]
   457  		dst := v.Args[0]
   458  		v_1 := v.Args[1]
   459  		if v_1.Op != OpIMake {
   460  			break
   461  		}
   462  		_ = v_1.Args[1]
   463  		itab := v_1.Args[0]
   464  		data := v_1.Args[1]
   465  		mem := v.Args[2]
   466  		v.reset(OpStore)
   467  		v.Aux = typ.BytePtr
   468  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
   469  		v0.AuxInt = config.PtrSize
   470  		v0.AddArg(dst)
   471  		v.AddArg(v0)
   472  		v.AddArg(data)
   473  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   474  		v1.Aux = typ.Uintptr
   475  		v1.AddArg(dst)
   476  		v1.AddArg(itab)
   477  		v1.AddArg(mem)
   478  		v.AddArg(v1)
   479  		return true
   480  	}
   481  	return false
   482  }
   483  func rewriteValuedec_OpStringLen_0(v *Value) bool {
   484  	// match: (StringLen (StringMake _ len))
   485  	// cond:
   486  	// result: len
   487  	for {
   488  		v_0 := v.Args[0]
   489  		if v_0.Op != OpStringMake {
   490  			break
   491  		}
   492  		_ = v_0.Args[1]
   493  		len := v_0.Args[1]
   494  		v.reset(OpCopy)
   495  		v.Type = len.Type
   496  		v.AddArg(len)
   497  		return true
   498  	}
   499  	return false
   500  }
   501  func rewriteValuedec_OpStringPtr_0(v *Value) bool {
   502  	// match: (StringPtr (StringMake ptr _))
   503  	// cond:
   504  	// result: ptr
   505  	for {
   506  		v_0 := v.Args[0]
   507  		if v_0.Op != OpStringMake {
   508  			break
   509  		}
   510  		_ = v_0.Args[1]
   511  		ptr := v_0.Args[0]
   512  		v.reset(OpCopy)
   513  		v.Type = ptr.Type
   514  		v.AddArg(ptr)
   515  		return true
   516  	}
   517  	return false
   518  }
   519  func rewriteBlockdec(b *Block) bool {
   520  	config := b.Func.Config
   521  	_ = config
   522  	fe := b.Func.fe
   523  	_ = fe
   524  	typ := &config.Types
   525  	_ = typ
   526  	switch b.Kind {
   527  	}
   528  	return false
   529  }