Black Lives Matter. Support the Equal Justice Initiative.

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 "cmd/compile/internal/types"
     7  
     8  func rewriteValuedec(v *Value) bool {
     9  	switch v.Op {
    10  	case OpComplexImag:
    11  		return rewriteValuedec_OpComplexImag(v)
    12  	case OpComplexReal:
    13  		return rewriteValuedec_OpComplexReal(v)
    14  	case OpIData:
    15  		return rewriteValuedec_OpIData(v)
    16  	case OpITab:
    17  		return rewriteValuedec_OpITab(v)
    18  	case OpLoad:
    19  		return rewriteValuedec_OpLoad(v)
    20  	case OpSliceCap:
    21  		return rewriteValuedec_OpSliceCap(v)
    22  	case OpSliceLen:
    23  		return rewriteValuedec_OpSliceLen(v)
    24  	case OpSlicePtr:
    25  		return rewriteValuedec_OpSlicePtr(v)
    26  	case OpStore:
    27  		return rewriteValuedec_OpStore(v)
    28  	case OpStringLen:
    29  		return rewriteValuedec_OpStringLen(v)
    30  	case OpStringPtr:
    31  		return rewriteValuedec_OpStringPtr(v)
    32  	}
    33  	return false
    34  }
    35  func rewriteValuedec_OpComplexImag(v *Value) bool {
    36  	v_0 := v.Args[0]
    37  	// match: (ComplexImag (ComplexMake _ imag ))
    38  	// result: imag
    39  	for {
    40  		if v_0.Op != OpComplexMake {
    41  			break
    42  		}
    43  		imag := v_0.Args[1]
    44  		v.copyOf(imag)
    45  		return true
    46  	}
    47  	return false
    48  }
    49  func rewriteValuedec_OpComplexReal(v *Value) bool {
    50  	v_0 := v.Args[0]
    51  	// match: (ComplexReal (ComplexMake real _ ))
    52  	// result: real
    53  	for {
    54  		if v_0.Op != OpComplexMake {
    55  			break
    56  		}
    57  		real := v_0.Args[0]
    58  		v.copyOf(real)
    59  		return true
    60  	}
    61  	return false
    62  }
    63  func rewriteValuedec_OpIData(v *Value) bool {
    64  	v_0 := v.Args[0]
    65  	// match: (IData (IMake _ data))
    66  	// result: data
    67  	for {
    68  		if v_0.Op != OpIMake {
    69  			break
    70  		}
    71  		data := v_0.Args[1]
    72  		v.copyOf(data)
    73  		return true
    74  	}
    75  	return false
    76  }
    77  func rewriteValuedec_OpITab(v *Value) bool {
    78  	v_0 := v.Args[0]
    79  	// match: (ITab (IMake itab _))
    80  	// result: itab
    81  	for {
    82  		if v_0.Op != OpIMake {
    83  			break
    84  		}
    85  		itab := v_0.Args[0]
    86  		v.copyOf(itab)
    87  		return true
    88  	}
    89  	return false
    90  }
    91  func rewriteValuedec_OpLoad(v *Value) bool {
    92  	v_1 := v.Args[1]
    93  	v_0 := v.Args[0]
    94  	b := v.Block
    95  	config := b.Func.Config
    96  	typ := &b.Func.Config.Types
    97  	// match: (Load <t> ptr mem)
    98  	// cond: t.IsComplex() && t.Size() == 8
    99  	// result: (ComplexMake (Load <typ.Float32> ptr mem) (Load <typ.Float32> (OffPtr <typ.Float32Ptr> [4] ptr) mem) )
   100  	for {
   101  		t := v.Type
   102  		ptr := v_0
   103  		mem := v_1
   104  		if !(t.IsComplex() && t.Size() == 8) {
   105  			break
   106  		}
   107  		v.reset(OpComplexMake)
   108  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
   109  		v0.AddArg2(ptr, mem)
   110  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Float32)
   111  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
   112  		v2.AuxInt = int64ToAuxInt(4)
   113  		v2.AddArg(ptr)
   114  		v1.AddArg2(v2, mem)
   115  		v.AddArg2(v0, v1)
   116  		return true
   117  	}
   118  	// match: (Load <t> ptr mem)
   119  	// cond: t.IsComplex() && t.Size() == 16
   120  	// result: (ComplexMake (Load <typ.Float64> ptr mem) (Load <typ.Float64> (OffPtr <typ.Float64Ptr> [8] ptr) mem) )
   121  	for {
   122  		t := v.Type
   123  		ptr := v_0
   124  		mem := v_1
   125  		if !(t.IsComplex() && t.Size() == 16) {
   126  			break
   127  		}
   128  		v.reset(OpComplexMake)
   129  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
   130  		v0.AddArg2(ptr, mem)
   131  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Float64)
   132  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
   133  		v2.AuxInt = int64ToAuxInt(8)
   134  		v2.AddArg(ptr)
   135  		v1.AddArg2(v2, mem)
   136  		v.AddArg2(v0, v1)
   137  		return true
   138  	}
   139  	// match: (Load <t> ptr mem)
   140  	// cond: t.IsString()
   141  	// result: (StringMake (Load <typ.BytePtr> ptr mem) (Load <typ.Int> (OffPtr <typ.IntPtr> [config.PtrSize] ptr) mem))
   142  	for {
   143  		t := v.Type
   144  		ptr := v_0
   145  		mem := v_1
   146  		if !(t.IsString()) {
   147  			break
   148  		}
   149  		v.reset(OpStringMake)
   150  		v0 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
   151  		v0.AddArg2(ptr, mem)
   152  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   153  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   154  		v2.AuxInt = int64ToAuxInt(config.PtrSize)
   155  		v2.AddArg(ptr)
   156  		v1.AddArg2(v2, mem)
   157  		v.AddArg2(v0, v1)
   158  		return true
   159  	}
   160  	// match: (Load <t> ptr mem)
   161  	// cond: t.IsSlice()
   162  	// 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))
   163  	for {
   164  		t := v.Type
   165  		ptr := v_0
   166  		mem := v_1
   167  		if !(t.IsSlice()) {
   168  			break
   169  		}
   170  		v.reset(OpSliceMake)
   171  		v0 := b.NewValue0(v.Pos, OpLoad, t.Elem().PtrTo())
   172  		v0.AddArg2(ptr, mem)
   173  		v1 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   174  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   175  		v2.AuxInt = int64ToAuxInt(config.PtrSize)
   176  		v2.AddArg(ptr)
   177  		v1.AddArg2(v2, mem)
   178  		v3 := b.NewValue0(v.Pos, OpLoad, typ.Int)
   179  		v4 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   180  		v4.AuxInt = int64ToAuxInt(2 * config.PtrSize)
   181  		v4.AddArg(ptr)
   182  		v3.AddArg2(v4, mem)
   183  		v.AddArg3(v0, v1, v3)
   184  		return true
   185  	}
   186  	// match: (Load <t> ptr mem)
   187  	// cond: t.IsInterface()
   188  	// result: (IMake (Load <typ.Uintptr> ptr mem) (Load <typ.BytePtr> (OffPtr <typ.BytePtrPtr> [config.PtrSize] ptr) mem))
   189  	for {
   190  		t := v.Type
   191  		ptr := v_0
   192  		mem := v_1
   193  		if !(t.IsInterface()) {
   194  			break
   195  		}
   196  		v.reset(OpIMake)
   197  		v0 := b.NewValue0(v.Pos, OpLoad, typ.Uintptr)
   198  		v0.AddArg2(ptr, mem)
   199  		v1 := b.NewValue0(v.Pos, OpLoad, typ.BytePtr)
   200  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
   201  		v2.AuxInt = int64ToAuxInt(config.PtrSize)
   202  		v2.AddArg(ptr)
   203  		v1.AddArg2(v2, mem)
   204  		v.AddArg2(v0, v1)
   205  		return true
   206  	}
   207  	return false
   208  }
   209  func rewriteValuedec_OpSliceCap(v *Value) bool {
   210  	v_0 := v.Args[0]
   211  	// match: (SliceCap (SliceMake _ _ cap))
   212  	// result: cap
   213  	for {
   214  		if v_0.Op != OpSliceMake {
   215  			break
   216  		}
   217  		cap := v_0.Args[2]
   218  		v.copyOf(cap)
   219  		return true
   220  	}
   221  	return false
   222  }
   223  func rewriteValuedec_OpSliceLen(v *Value) bool {
   224  	v_0 := v.Args[0]
   225  	// match: (SliceLen (SliceMake _ len _))
   226  	// result: len
   227  	for {
   228  		if v_0.Op != OpSliceMake {
   229  			break
   230  		}
   231  		len := v_0.Args[1]
   232  		v.copyOf(len)
   233  		return true
   234  	}
   235  	return false
   236  }
   237  func rewriteValuedec_OpSlicePtr(v *Value) bool {
   238  	v_0 := v.Args[0]
   239  	// match: (SlicePtr (SliceMake ptr _ _ ))
   240  	// result: ptr
   241  	for {
   242  		if v_0.Op != OpSliceMake {
   243  			break
   244  		}
   245  		ptr := v_0.Args[0]
   246  		v.copyOf(ptr)
   247  		return true
   248  	}
   249  	return false
   250  }
   251  func rewriteValuedec_OpStore(v *Value) bool {
   252  	v_2 := v.Args[2]
   253  	v_1 := v.Args[1]
   254  	v_0 := v.Args[0]
   255  	b := v.Block
   256  	config := b.Func.Config
   257  	typ := &b.Func.Config.Types
   258  	// match: (Store {t} dst (ComplexMake real imag) mem)
   259  	// cond: t.Size() == 8
   260  	// result: (Store {typ.Float32} (OffPtr <typ.Float32Ptr> [4] dst) imag (Store {typ.Float32} dst real mem))
   261  	for {
   262  		t := auxToType(v.Aux)
   263  		dst := v_0
   264  		if v_1.Op != OpComplexMake {
   265  			break
   266  		}
   267  		imag := v_1.Args[1]
   268  		real := v_1.Args[0]
   269  		mem := v_2
   270  		if !(t.Size() == 8) {
   271  			break
   272  		}
   273  		v.reset(OpStore)
   274  		v.Aux = typeToAux(typ.Float32)
   275  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float32Ptr)
   276  		v0.AuxInt = int64ToAuxInt(4)
   277  		v0.AddArg(dst)
   278  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   279  		v1.Aux = typeToAux(typ.Float32)
   280  		v1.AddArg3(dst, real, mem)
   281  		v.AddArg3(v0, imag, v1)
   282  		return true
   283  	}
   284  	// match: (Store {t} dst (ComplexMake real imag) mem)
   285  	// cond: t.Size() == 16
   286  	// result: (Store {typ.Float64} (OffPtr <typ.Float64Ptr> [8] dst) imag (Store {typ.Float64} dst real mem))
   287  	for {
   288  		t := auxToType(v.Aux)
   289  		dst := v_0
   290  		if v_1.Op != OpComplexMake {
   291  			break
   292  		}
   293  		imag := v_1.Args[1]
   294  		real := v_1.Args[0]
   295  		mem := v_2
   296  		if !(t.Size() == 16) {
   297  			break
   298  		}
   299  		v.reset(OpStore)
   300  		v.Aux = typeToAux(typ.Float64)
   301  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.Float64Ptr)
   302  		v0.AuxInt = int64ToAuxInt(8)
   303  		v0.AddArg(dst)
   304  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   305  		v1.Aux = typeToAux(typ.Float64)
   306  		v1.AddArg3(dst, real, mem)
   307  		v.AddArg3(v0, imag, v1)
   308  		return true
   309  	}
   310  	// match: (Store dst (StringMake ptr len) mem)
   311  	// result: (Store {typ.Int} (OffPtr <typ.IntPtr> [config.PtrSize] dst) len (Store {typ.BytePtr} dst ptr mem))
   312  	for {
   313  		dst := v_0
   314  		if v_1.Op != OpStringMake {
   315  			break
   316  		}
   317  		len := v_1.Args[1]
   318  		ptr := v_1.Args[0]
   319  		mem := v_2
   320  		v.reset(OpStore)
   321  		v.Aux = typeToAux(typ.Int)
   322  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   323  		v0.AuxInt = int64ToAuxInt(config.PtrSize)
   324  		v0.AddArg(dst)
   325  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   326  		v1.Aux = typeToAux(typ.BytePtr)
   327  		v1.AddArg3(dst, ptr, mem)
   328  		v.AddArg3(v0, len, v1)
   329  		return true
   330  	}
   331  	// match: (Store {t} dst (SliceMake ptr len cap) mem)
   332  	// 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)))
   333  	for {
   334  		t := auxToType(v.Aux)
   335  		dst := v_0
   336  		if v_1.Op != OpSliceMake {
   337  			break
   338  		}
   339  		cap := v_1.Args[2]
   340  		ptr := v_1.Args[0]
   341  		len := v_1.Args[1]
   342  		mem := v_2
   343  		v.reset(OpStore)
   344  		v.Aux = typeToAux(typ.Int)
   345  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   346  		v0.AuxInt = int64ToAuxInt(2 * config.PtrSize)
   347  		v0.AddArg(dst)
   348  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   349  		v1.Aux = typeToAux(typ.Int)
   350  		v2 := b.NewValue0(v.Pos, OpOffPtr, typ.IntPtr)
   351  		v2.AuxInt = int64ToAuxInt(config.PtrSize)
   352  		v2.AddArg(dst)
   353  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   354  		v3.Aux = typeToAux(t.Elem().PtrTo())
   355  		v3.AddArg3(dst, ptr, mem)
   356  		v1.AddArg3(v2, len, v3)
   357  		v.AddArg3(v0, cap, v1)
   358  		return true
   359  	}
   360  	// match: (Store dst (IMake itab data) mem)
   361  	// result: (Store {typ.BytePtr} (OffPtr <typ.BytePtrPtr> [config.PtrSize] dst) data (Store {typ.Uintptr} dst itab mem))
   362  	for {
   363  		dst := v_0
   364  		if v_1.Op != OpIMake {
   365  			break
   366  		}
   367  		data := v_1.Args[1]
   368  		itab := v_1.Args[0]
   369  		mem := v_2
   370  		v.reset(OpStore)
   371  		v.Aux = typeToAux(typ.BytePtr)
   372  		v0 := b.NewValue0(v.Pos, OpOffPtr, typ.BytePtrPtr)
   373  		v0.AuxInt = int64ToAuxInt(config.PtrSize)
   374  		v0.AddArg(dst)
   375  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
   376  		v1.Aux = typeToAux(typ.Uintptr)
   377  		v1.AddArg3(dst, itab, mem)
   378  		v.AddArg3(v0, data, v1)
   379  		return true
   380  	}
   381  	return false
   382  }
   383  func rewriteValuedec_OpStringLen(v *Value) bool {
   384  	v_0 := v.Args[0]
   385  	// match: (StringLen (StringMake _ len))
   386  	// result: len
   387  	for {
   388  		if v_0.Op != OpStringMake {
   389  			break
   390  		}
   391  		len := v_0.Args[1]
   392  		v.copyOf(len)
   393  		return true
   394  	}
   395  	return false
   396  }
   397  func rewriteValuedec_OpStringPtr(v *Value) bool {
   398  	v_0 := v.Args[0]
   399  	// match: (StringPtr (StringMake ptr _))
   400  	// result: ptr
   401  	for {
   402  		if v_0.Op != OpStringMake {
   403  			break
   404  		}
   405  		ptr := v_0.Args[0]
   406  		v.copyOf(ptr)
   407  		return true
   408  	}
   409  	return false
   410  }
   411  func rewriteBlockdec(b *Block) bool {
   412  	switch b.Kind {
   413  	}
   414  	return false
   415  }
   416  

View as plain text