rewriteRISCV64latelower.go

     1  // Code generated from _gen/RISCV64latelower.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package rewriteriscv64latelower
     4  
     5  import "cmd/compile/internal/ssa/ssaop"
     6  import "cmd/compile/internal/ssa"
     7  
     8  func RewriteValue(v *ssa.Value) bool {
     9  	switch v.Op {
    10  	case ssaop.OpRISCV64AND:
    11  		return rewriteValue_OpRISCV64AND(v)
    12  	case ssaop.OpRISCV64NOT:
    13  		return rewriteValue_OpRISCV64NOT(v)
    14  	case ssaop.OpRISCV64OR:
    15  		return rewriteValue_OpRISCV64OR(v)
    16  	case ssaop.OpRISCV64SLLI:
    17  		return rewriteValue_OpRISCV64SLLI(v)
    18  	case ssaop.OpRISCV64SRAI:
    19  		return rewriteValue_OpRISCV64SRAI(v)
    20  	case ssaop.OpRISCV64SRLI:
    21  		return rewriteValue_OpRISCV64SRLI(v)
    22  	case ssaop.OpRISCV64XOR:
    23  		return rewriteValue_OpRISCV64XOR(v)
    24  	}
    25  	return false
    26  }
    27  func rewriteValue_OpRISCV64AND(v *ssa.Value) bool {
    28  	v_1 := v.Args[1]
    29  	v_0 := v.Args[0]
    30  	// match: (AND x (NOT y))
    31  	// result: (ANDN x y)
    32  	for {
    33  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
    34  			x := v_0
    35  			if v_1.Op != ssaop.OpRISCV64NOT {
    36  				continue
    37  			}
    38  			y := v_1.Args[0]
    39  			v.Reset(ssaop.OpRISCV64ANDN)
    40  			v.AddArg2(x, y)
    41  			return true
    42  		}
    43  		break
    44  	}
    45  	return false
    46  }
    47  func rewriteValue_OpRISCV64NOT(v *ssa.Value) bool {
    48  	v_0 := v.Args[0]
    49  	// match: (NOT (XOR x y))
    50  	// result: (XNOR x y)
    51  	for {
    52  		if v_0.Op != ssaop.OpRISCV64XOR {
    53  			break
    54  		}
    55  		y := v_0.Args[1]
    56  		x := v_0.Args[0]
    57  		v.Reset(ssaop.OpRISCV64XNOR)
    58  		v.AddArg2(x, y)
    59  		return true
    60  	}
    61  	return false
    62  }
    63  func rewriteValue_OpRISCV64OR(v *ssa.Value) bool {
    64  	v_1 := v.Args[1]
    65  	v_0 := v.Args[0]
    66  	// match: (OR x (NOT y))
    67  	// result: (ORN x y)
    68  	for {
    69  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
    70  			x := v_0
    71  			if v_1.Op != ssaop.OpRISCV64NOT {
    72  				continue
    73  			}
    74  			y := v_1.Args[0]
    75  			v.Reset(ssaop.OpRISCV64ORN)
    76  			v.AddArg2(x, y)
    77  			return true
    78  		}
    79  		break
    80  	}
    81  	return false
    82  }
    83  func rewriteValue_OpRISCV64SLLI(v *ssa.Value) bool {
    84  	v_0 := v.Args[0]
    85  	b := v.Block
    86  	typ := &b.Func.Config.Types
    87  	// match: (SLLI [c] (MOVBUreg x))
    88  	// cond: c <= 56
    89  	// result: (SRLI [56-c] (SLLI <typ.UInt64> [56] x))
    90  	for {
    91  		c := ssa.AuxIntToInt64(v.AuxInt)
    92  		if v_0.Op != ssaop.OpRISCV64MOVBUreg {
    93  			break
    94  		}
    95  		x := v_0.Args[0]
    96  		if !(c <= 56) {
    97  			break
    98  		}
    99  		v.Reset(ssaop.OpRISCV64SRLI)
   100  		v.AuxInt = ssa.Int64ToAuxInt(56 - c)
   101  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.UInt64)
   102  		v0.AuxInt = ssa.Int64ToAuxInt(56)
   103  		v0.AddArg(x)
   104  		v.AddArg(v0)
   105  		return true
   106  	}
   107  	// match: (SLLI [c] (MOVHUreg x))
   108  	// cond: c <= 48
   109  	// result: (SRLI [48-c] (SLLI <typ.UInt64> [48] x))
   110  	for {
   111  		c := ssa.AuxIntToInt64(v.AuxInt)
   112  		if v_0.Op != ssaop.OpRISCV64MOVHUreg {
   113  			break
   114  		}
   115  		x := v_0.Args[0]
   116  		if !(c <= 48) {
   117  			break
   118  		}
   119  		v.Reset(ssaop.OpRISCV64SRLI)
   120  		v.AuxInt = ssa.Int64ToAuxInt(48 - c)
   121  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.UInt64)
   122  		v0.AuxInt = ssa.Int64ToAuxInt(48)
   123  		v0.AddArg(x)
   124  		v.AddArg(v0)
   125  		return true
   126  	}
   127  	// match: (SLLI [c] (MOVWUreg x))
   128  	// cond: c <= 32
   129  	// result: (SRLI [32-c] (SLLI <typ.UInt64> [32] x))
   130  	for {
   131  		c := ssa.AuxIntToInt64(v.AuxInt)
   132  		if v_0.Op != ssaop.OpRISCV64MOVWUreg {
   133  			break
   134  		}
   135  		x := v_0.Args[0]
   136  		if !(c <= 32) {
   137  			break
   138  		}
   139  		v.Reset(ssaop.OpRISCV64SRLI)
   140  		v.AuxInt = ssa.Int64ToAuxInt(32 - c)
   141  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.UInt64)
   142  		v0.AuxInt = ssa.Int64ToAuxInt(32)
   143  		v0.AddArg(x)
   144  		v.AddArg(v0)
   145  		return true
   146  	}
   147  	// match: (SLLI [0] x)
   148  	// result: x
   149  	for {
   150  		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
   151  			break
   152  		}
   153  		x := v_0
   154  		v.CopyOf(x)
   155  		return true
   156  	}
   157  	return false
   158  }
   159  func rewriteValue_OpRISCV64SRAI(v *ssa.Value) bool {
   160  	v_0 := v.Args[0]
   161  	b := v.Block
   162  	typ := &b.Func.Config.Types
   163  	// match: (SRAI [c] (MOVBreg x))
   164  	// cond: c < 8
   165  	// result: (SRAI [56+c] (SLLI <typ.Int64> [56] x))
   166  	for {
   167  		c := ssa.AuxIntToInt64(v.AuxInt)
   168  		if v_0.Op != ssaop.OpRISCV64MOVBreg {
   169  			break
   170  		}
   171  		x := v_0.Args[0]
   172  		if !(c < 8) {
   173  			break
   174  		}
   175  		v.Reset(ssaop.OpRISCV64SRAI)
   176  		v.AuxInt = ssa.Int64ToAuxInt(56 + c)
   177  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.Int64)
   178  		v0.AuxInt = ssa.Int64ToAuxInt(56)
   179  		v0.AddArg(x)
   180  		v.AddArg(v0)
   181  		return true
   182  	}
   183  	// match: (SRAI [c] (MOVHreg x))
   184  	// cond: c < 16
   185  	// result: (SRAI [48+c] (SLLI <typ.Int64> [48] x))
   186  	for {
   187  		c := ssa.AuxIntToInt64(v.AuxInt)
   188  		if v_0.Op != ssaop.OpRISCV64MOVHreg {
   189  			break
   190  		}
   191  		x := v_0.Args[0]
   192  		if !(c < 16) {
   193  			break
   194  		}
   195  		v.Reset(ssaop.OpRISCV64SRAI)
   196  		v.AuxInt = ssa.Int64ToAuxInt(48 + c)
   197  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.Int64)
   198  		v0.AuxInt = ssa.Int64ToAuxInt(48)
   199  		v0.AddArg(x)
   200  		v.AddArg(v0)
   201  		return true
   202  	}
   203  	// match: (SRAI [c] (MOVWreg x))
   204  	// cond: c < 32
   205  	// result: (SRAI [32+c] (SLLI <typ.Int64> [32] x))
   206  	for {
   207  		c := ssa.AuxIntToInt64(v.AuxInt)
   208  		if v_0.Op != ssaop.OpRISCV64MOVWreg {
   209  			break
   210  		}
   211  		x := v_0.Args[0]
   212  		if !(c < 32) {
   213  			break
   214  		}
   215  		v.Reset(ssaop.OpRISCV64SRAI)
   216  		v.AuxInt = ssa.Int64ToAuxInt(32 + c)
   217  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.Int64)
   218  		v0.AuxInt = ssa.Int64ToAuxInt(32)
   219  		v0.AddArg(x)
   220  		v.AddArg(v0)
   221  		return true
   222  	}
   223  	// match: (SRAI [0] x)
   224  	// result: x
   225  	for {
   226  		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
   227  			break
   228  		}
   229  		x := v_0
   230  		v.CopyOf(x)
   231  		return true
   232  	}
   233  	return false
   234  }
   235  func rewriteValue_OpRISCV64SRLI(v *ssa.Value) bool {
   236  	v_0 := v.Args[0]
   237  	b := v.Block
   238  	typ := &b.Func.Config.Types
   239  	// match: (SRLI [c] (MOVBUreg x))
   240  	// cond: c < 8
   241  	// result: (SRLI [56+c] (SLLI <typ.UInt64> [56] x))
   242  	for {
   243  		c := ssa.AuxIntToInt64(v.AuxInt)
   244  		if v_0.Op != ssaop.OpRISCV64MOVBUreg {
   245  			break
   246  		}
   247  		x := v_0.Args[0]
   248  		if !(c < 8) {
   249  			break
   250  		}
   251  		v.Reset(ssaop.OpRISCV64SRLI)
   252  		v.AuxInt = ssa.Int64ToAuxInt(56 + c)
   253  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.UInt64)
   254  		v0.AuxInt = ssa.Int64ToAuxInt(56)
   255  		v0.AddArg(x)
   256  		v.AddArg(v0)
   257  		return true
   258  	}
   259  	// match: (SRLI [c] (MOVHUreg x))
   260  	// cond: c < 16
   261  	// result: (SRLI [48+c] (SLLI <typ.UInt64> [48] x))
   262  	for {
   263  		c := ssa.AuxIntToInt64(v.AuxInt)
   264  		if v_0.Op != ssaop.OpRISCV64MOVHUreg {
   265  			break
   266  		}
   267  		x := v_0.Args[0]
   268  		if !(c < 16) {
   269  			break
   270  		}
   271  		v.Reset(ssaop.OpRISCV64SRLI)
   272  		v.AuxInt = ssa.Int64ToAuxInt(48 + c)
   273  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.UInt64)
   274  		v0.AuxInt = ssa.Int64ToAuxInt(48)
   275  		v0.AddArg(x)
   276  		v.AddArg(v0)
   277  		return true
   278  	}
   279  	// match: (SRLI [c] (MOVWUreg x))
   280  	// cond: c < 32
   281  	// result: (SRLI [32+c] (SLLI <typ.UInt64> [32] x))
   282  	for {
   283  		c := ssa.AuxIntToInt64(v.AuxInt)
   284  		if v_0.Op != ssaop.OpRISCV64MOVWUreg {
   285  			break
   286  		}
   287  		x := v_0.Args[0]
   288  		if !(c < 32) {
   289  			break
   290  		}
   291  		v.Reset(ssaop.OpRISCV64SRLI)
   292  		v.AuxInt = ssa.Int64ToAuxInt(32 + c)
   293  		v0 := b.NewValue0(v.Pos, ssaop.OpRISCV64SLLI, typ.UInt64)
   294  		v0.AuxInt = ssa.Int64ToAuxInt(32)
   295  		v0.AddArg(x)
   296  		v.AddArg(v0)
   297  		return true
   298  	}
   299  	// match: (SRLI [0] x)
   300  	// result: x
   301  	for {
   302  		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
   303  			break
   304  		}
   305  		x := v_0
   306  		v.CopyOf(x)
   307  		return true
   308  	}
   309  	return false
   310  }
   311  func rewriteValue_OpRISCV64XOR(v *ssa.Value) bool {
   312  	v_1 := v.Args[1]
   313  	v_0 := v.Args[0]
   314  	// match: (XOR x (NOT y))
   315  	// result: (XNOR x y)
   316  	for {
   317  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   318  			x := v_0
   319  			if v_1.Op != ssaop.OpRISCV64NOT {
   320  				continue
   321  			}
   322  			y := v_1.Args[0]
   323  			v.Reset(ssaop.OpRISCV64XNOR)
   324  			v.AddArg2(x, y)
   325  			return true
   326  		}
   327  		break
   328  	}
   329  	return false
   330  }
   331  func RewriteBlock(b *ssa.Block) bool {
   332  	return false
   333  }
   334
View as plain text