...
Run Format

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

View as plain text