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

Documentation: cmd/compile/internal/ssa

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

View as plain text