Source file src/cmd/compile/internal/ssarewrite/rewritearm64latelower/rewriteARM64latelower.go

     1  // Code generated from _gen/ARM64latelower.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package rewritearm64latelower
     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.OpARM64ADDSconstflags:
    11  		return rewriteValue_OpARM64ADDSconstflags(v)
    12  	case ssaop.OpARM64ADDconst:
    13  		return rewriteValue_OpARM64ADDconst(v)
    14  	case ssaop.OpARM64ANDconst:
    15  		return rewriteValue_OpARM64ANDconst(v)
    16  	case ssaop.OpARM64CMNWconst:
    17  		return rewriteValue_OpARM64CMNWconst(v)
    18  	case ssaop.OpARM64CMNconst:
    19  		return rewriteValue_OpARM64CMNconst(v)
    20  	case ssaop.OpARM64CMPWconst:
    21  		return rewriteValue_OpARM64CMPWconst(v)
    22  	case ssaop.OpARM64CMPconst:
    23  		return rewriteValue_OpARM64CMPconst(v)
    24  	case ssaop.OpARM64MOVBUreg:
    25  		return rewriteValue_OpARM64MOVBUreg(v)
    26  	case ssaop.OpARM64MOVBreg:
    27  		return rewriteValue_OpARM64MOVBreg(v)
    28  	case ssaop.OpARM64MOVDconst:
    29  		return rewriteValue_OpARM64MOVDconst(v)
    30  	case ssaop.OpARM64MOVDnop:
    31  		return rewriteValue_OpARM64MOVDnop(v)
    32  	case ssaop.OpARM64MOVDreg:
    33  		return rewriteValue_OpARM64MOVDreg(v)
    34  	case ssaop.OpARM64MOVHUreg:
    35  		return rewriteValue_OpARM64MOVHUreg(v)
    36  	case ssaop.OpARM64MOVHreg:
    37  		return rewriteValue_OpARM64MOVHreg(v)
    38  	case ssaop.OpARM64MOVWUreg:
    39  		return rewriteValue_OpARM64MOVWUreg(v)
    40  	case ssaop.OpARM64MOVWreg:
    41  		return rewriteValue_OpARM64MOVWreg(v)
    42  	case ssaop.OpARM64ORconst:
    43  		return rewriteValue_OpARM64ORconst(v)
    44  	case ssaop.OpARM64SLLconst:
    45  		return rewriteValue_OpARM64SLLconst(v)
    46  	case ssaop.OpARM64SUBconst:
    47  		return rewriteValue_OpARM64SUBconst(v)
    48  	case ssaop.OpARM64TSTWconst:
    49  		return rewriteValue_OpARM64TSTWconst(v)
    50  	case ssaop.OpARM64TSTconst:
    51  		return rewriteValue_OpARM64TSTconst(v)
    52  	case ssaop.OpARM64XORconst:
    53  		return rewriteValue_OpARM64XORconst(v)
    54  	}
    55  	return false
    56  }
    57  func rewriteValue_OpARM64ADDSconstflags(v *ssa.Value) bool {
    58  	v_0 := v.Args[0]
    59  	b := v.Block
    60  	typ := &b.Func.Config.Types
    61  	// match: (ADDSconstflags [c] x)
    62  	// cond: !isARM64addcon(c)
    63  	// result: (ADDSflags x (MOVDconst [c]))
    64  	for {
    65  		c := ssa.AuxIntToInt64(v.AuxInt)
    66  		x := v_0
    67  		if !(!isARM64addcon(c)) {
    68  			break
    69  		}
    70  		v.Reset(ssaop.OpARM64ADDSflags)
    71  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
    72  		v0.AuxInt = ssa.Int64ToAuxInt(c)
    73  		v.AddArg2(x, v0)
    74  		return true
    75  	}
    76  	return false
    77  }
    78  func rewriteValue_OpARM64ADDconst(v *ssa.Value) bool {
    79  	v_0 := v.Args[0]
    80  	b := v.Block
    81  	typ := &b.Func.Config.Types
    82  	// match: (ADDconst [c] x)
    83  	// cond: !isARM64addcon(c)
    84  	// result: (ADD x (MOVDconst [c]))
    85  	for {
    86  		c := ssa.AuxIntToInt64(v.AuxInt)
    87  		x := v_0
    88  		if !(!isARM64addcon(c)) {
    89  			break
    90  		}
    91  		v.Reset(ssaop.OpARM64ADD)
    92  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
    93  		v0.AuxInt = ssa.Int64ToAuxInt(c)
    94  		v.AddArg2(x, v0)
    95  		return true
    96  	}
    97  	return false
    98  }
    99  func rewriteValue_OpARM64ANDconst(v *ssa.Value) bool {
   100  	v_0 := v.Args[0]
   101  	b := v.Block
   102  	typ := &b.Func.Config.Types
   103  	// match: (ANDconst [c] x)
   104  	// cond: !isARM64bitcon(uint64(c))
   105  	// result: (AND x (MOVDconst [c]))
   106  	for {
   107  		c := ssa.AuxIntToInt64(v.AuxInt)
   108  		x := v_0
   109  		if !(!isARM64bitcon(uint64(c))) {
   110  			break
   111  		}
   112  		v.Reset(ssaop.OpARM64AND)
   113  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
   114  		v0.AuxInt = ssa.Int64ToAuxInt(c)
   115  		v.AddArg2(x, v0)
   116  		return true
   117  	}
   118  	return false
   119  }
   120  func rewriteValue_OpARM64CMNWconst(v *ssa.Value) bool {
   121  	v_0 := v.Args[0]
   122  	b := v.Block
   123  	typ := &b.Func.Config.Types
   124  	// match: (CMNWconst [c] x)
   125  	// cond: !isARM64addcon(int64(c))
   126  	// result: (CMNW x (MOVDconst [int64(c)]))
   127  	for {
   128  		c := ssa.AuxIntToInt32(v.AuxInt)
   129  		x := v_0
   130  		if !(!isARM64addcon(int64(c))) {
   131  			break
   132  		}
   133  		v.Reset(ssaop.OpARM64CMNW)
   134  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
   135  		v0.AuxInt = ssa.Int64ToAuxInt(int64(c))
   136  		v.AddArg2(x, v0)
   137  		return true
   138  	}
   139  	return false
   140  }
   141  func rewriteValue_OpARM64CMNconst(v *ssa.Value) bool {
   142  	v_0 := v.Args[0]
   143  	b := v.Block
   144  	typ := &b.Func.Config.Types
   145  	// match: (CMNconst [c] x)
   146  	// cond: !isARM64addcon(c)
   147  	// result: (CMN x (MOVDconst [c]))
   148  	for {
   149  		c := ssa.AuxIntToInt64(v.AuxInt)
   150  		x := v_0
   151  		if !(!isARM64addcon(c)) {
   152  			break
   153  		}
   154  		v.Reset(ssaop.OpARM64CMN)
   155  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
   156  		v0.AuxInt = ssa.Int64ToAuxInt(c)
   157  		v.AddArg2(x, v0)
   158  		return true
   159  	}
   160  	return false
   161  }
   162  func rewriteValue_OpARM64CMPWconst(v *ssa.Value) bool {
   163  	v_0 := v.Args[0]
   164  	b := v.Block
   165  	typ := &b.Func.Config.Types
   166  	// match: (CMPWconst [c] x)
   167  	// cond: !isARM64addcon(int64(c))
   168  	// result: (CMPW x (MOVDconst [int64(c)]))
   169  	for {
   170  		c := ssa.AuxIntToInt32(v.AuxInt)
   171  		x := v_0
   172  		if !(!isARM64addcon(int64(c))) {
   173  			break
   174  		}
   175  		v.Reset(ssaop.OpARM64CMPW)
   176  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
   177  		v0.AuxInt = ssa.Int64ToAuxInt(int64(c))
   178  		v.AddArg2(x, v0)
   179  		return true
   180  	}
   181  	return false
   182  }
   183  func rewriteValue_OpARM64CMPconst(v *ssa.Value) bool {
   184  	v_0 := v.Args[0]
   185  	b := v.Block
   186  	typ := &b.Func.Config.Types
   187  	// match: (CMPconst [c] x)
   188  	// cond: !isARM64addcon(c)
   189  	// result: (CMP x (MOVDconst [c]))
   190  	for {
   191  		c := ssa.AuxIntToInt64(v.AuxInt)
   192  		x := v_0
   193  		if !(!isARM64addcon(c)) {
   194  			break
   195  		}
   196  		v.Reset(ssaop.OpARM64CMP)
   197  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
   198  		v0.AuxInt = ssa.Int64ToAuxInt(c)
   199  		v.AddArg2(x, v0)
   200  		return true
   201  	}
   202  	return false
   203  }
   204  func rewriteValue_OpARM64MOVBUreg(v *ssa.Value) bool {
   205  	v_0 := v.Args[0]
   206  	// match: (MOVBUreg x:(Equal _))
   207  	// result: x
   208  	for {
   209  		x := v_0
   210  		if x.Op != ssaop.OpARM64Equal {
   211  			break
   212  		}
   213  		v.CopyOf(x)
   214  		return true
   215  	}
   216  	// match: (MOVBUreg x:(NotEqual _))
   217  	// result: x
   218  	for {
   219  		x := v_0
   220  		if x.Op != ssaop.OpARM64NotEqual {
   221  			break
   222  		}
   223  		v.CopyOf(x)
   224  		return true
   225  	}
   226  	// match: (MOVBUreg x:(LessThan _))
   227  	// result: x
   228  	for {
   229  		x := v_0
   230  		if x.Op != ssaop.OpARM64LessThan {
   231  			break
   232  		}
   233  		v.CopyOf(x)
   234  		return true
   235  	}
   236  	// match: (MOVBUreg x:(LessThanU _))
   237  	// result: x
   238  	for {
   239  		x := v_0
   240  		if x.Op != ssaop.OpARM64LessThanU {
   241  			break
   242  		}
   243  		v.CopyOf(x)
   244  		return true
   245  	}
   246  	// match: (MOVBUreg x:(LessThanF _))
   247  	// result: x
   248  	for {
   249  		x := v_0
   250  		if x.Op != ssaop.OpARM64LessThanF {
   251  			break
   252  		}
   253  		v.CopyOf(x)
   254  		return true
   255  	}
   256  	// match: (MOVBUreg x:(LessEqual _))
   257  	// result: x
   258  	for {
   259  		x := v_0
   260  		if x.Op != ssaop.OpARM64LessEqual {
   261  			break
   262  		}
   263  		v.CopyOf(x)
   264  		return true
   265  	}
   266  	// match: (MOVBUreg x:(LessEqualU _))
   267  	// result: x
   268  	for {
   269  		x := v_0
   270  		if x.Op != ssaop.OpARM64LessEqualU {
   271  			break
   272  		}
   273  		v.CopyOf(x)
   274  		return true
   275  	}
   276  	// match: (MOVBUreg x:(LessEqualF _))
   277  	// result: x
   278  	for {
   279  		x := v_0
   280  		if x.Op != ssaop.OpARM64LessEqualF {
   281  			break
   282  		}
   283  		v.CopyOf(x)
   284  		return true
   285  	}
   286  	// match: (MOVBUreg x:(GreaterThan _))
   287  	// result: x
   288  	for {
   289  		x := v_0
   290  		if x.Op != ssaop.OpARM64GreaterThan {
   291  			break
   292  		}
   293  		v.CopyOf(x)
   294  		return true
   295  	}
   296  	// match: (MOVBUreg x:(GreaterThanU _))
   297  	// result: x
   298  	for {
   299  		x := v_0
   300  		if x.Op != ssaop.OpARM64GreaterThanU {
   301  			break
   302  		}
   303  		v.CopyOf(x)
   304  		return true
   305  	}
   306  	// match: (MOVBUreg x:(GreaterThanF _))
   307  	// result: x
   308  	for {
   309  		x := v_0
   310  		if x.Op != ssaop.OpARM64GreaterThanF {
   311  			break
   312  		}
   313  		v.CopyOf(x)
   314  		return true
   315  	}
   316  	// match: (MOVBUreg x:(GreaterEqual _))
   317  	// result: x
   318  	for {
   319  		x := v_0
   320  		if x.Op != ssaop.OpARM64GreaterEqual {
   321  			break
   322  		}
   323  		v.CopyOf(x)
   324  		return true
   325  	}
   326  	// match: (MOVBUreg x:(GreaterEqualU _))
   327  	// result: x
   328  	for {
   329  		x := v_0
   330  		if x.Op != ssaop.OpARM64GreaterEqualU {
   331  			break
   332  		}
   333  		v.CopyOf(x)
   334  		return true
   335  	}
   336  	// match: (MOVBUreg x:(GreaterEqualF _))
   337  	// result: x
   338  	for {
   339  		x := v_0
   340  		if x.Op != ssaop.OpARM64GreaterEqualF {
   341  			break
   342  		}
   343  		v.CopyOf(x)
   344  		return true
   345  	}
   346  	// match: (MOVBUreg x)
   347  	// cond: ssa.ZeroUpper56Bits(x)
   348  	// result: x
   349  	for {
   350  		x := v_0
   351  		if !(ssa.ZeroUpper56Bits(x)) {
   352  			break
   353  		}
   354  		v.CopyOf(x)
   355  		return true
   356  	}
   357  	// match: (MOVBUreg x:(MOVBUload _ _))
   358  	// result: (MOVDreg x)
   359  	for {
   360  		x := v_0
   361  		if x.Op != ssaop.OpARM64MOVBUload {
   362  			break
   363  		}
   364  		v.Reset(ssaop.OpARM64MOVDreg)
   365  		v.AddArg(x)
   366  		return true
   367  	}
   368  	// match: (MOVBUreg x:(MOVBUloadidx _ _ _))
   369  	// result: (MOVDreg x)
   370  	for {
   371  		x := v_0
   372  		if x.Op != ssaop.OpARM64MOVBUloadidx {
   373  			break
   374  		}
   375  		v.Reset(ssaop.OpARM64MOVDreg)
   376  		v.AddArg(x)
   377  		return true
   378  	}
   379  	// match: (MOVBUreg x:(MOVBUreg _))
   380  	// result: (MOVDreg x)
   381  	for {
   382  		x := v_0
   383  		if x.Op != ssaop.OpARM64MOVBUreg {
   384  			break
   385  		}
   386  		v.Reset(ssaop.OpARM64MOVDreg)
   387  		v.AddArg(x)
   388  		return true
   389  	}
   390  	return false
   391  }
   392  func rewriteValue_OpARM64MOVBreg(v *ssa.Value) bool {
   393  	v_0 := v.Args[0]
   394  	// match: (MOVBreg x:(MOVBload _ _))
   395  	// result: (MOVDreg x)
   396  	for {
   397  		x := v_0
   398  		if x.Op != ssaop.OpARM64MOVBload {
   399  			break
   400  		}
   401  		v.Reset(ssaop.OpARM64MOVDreg)
   402  		v.AddArg(x)
   403  		return true
   404  	}
   405  	// match: (MOVBreg x:(MOVBloadidx _ _ _))
   406  	// result: (MOVDreg x)
   407  	for {
   408  		x := v_0
   409  		if x.Op != ssaop.OpARM64MOVBloadidx {
   410  			break
   411  		}
   412  		v.Reset(ssaop.OpARM64MOVDreg)
   413  		v.AddArg(x)
   414  		return true
   415  	}
   416  	// match: (MOVBreg x:(MOVBreg _))
   417  	// result: (MOVDreg x)
   418  	for {
   419  		x := v_0
   420  		if x.Op != ssaop.OpARM64MOVBreg {
   421  			break
   422  		}
   423  		v.Reset(ssaop.OpARM64MOVDreg)
   424  		v.AddArg(x)
   425  		return true
   426  	}
   427  	return false
   428  }
   429  func rewriteValue_OpARM64MOVDconst(v *ssa.Value) bool {
   430  	// match: (MOVDconst [0])
   431  	// result: (ZERO)
   432  	for {
   433  		if ssa.AuxIntToInt64(v.AuxInt) != 0 {
   434  			break
   435  		}
   436  		v.Reset(ssaop.OpARM64ZERO)
   437  		return true
   438  	}
   439  	return false
   440  }
   441  func rewriteValue_OpARM64MOVDnop(v *ssa.Value) bool {
   442  	v_0 := v.Args[0]
   443  	// match: (MOVDnop (MOVDconst [c]))
   444  	// result: (MOVDconst [c])
   445  	for {
   446  		if v_0.Op != ssaop.OpARM64MOVDconst {
   447  			break
   448  		}
   449  		c := ssa.AuxIntToInt64(v_0.AuxInt)
   450  		v.Reset(ssaop.OpARM64MOVDconst)
   451  		v.AuxInt = ssa.Int64ToAuxInt(c)
   452  		return true
   453  	}
   454  	return false
   455  }
   456  func rewriteValue_OpARM64MOVDreg(v *ssa.Value) bool {
   457  	v_0 := v.Args[0]
   458  	// match: (MOVDreg x)
   459  	// cond: x.Uses == 1
   460  	// result: (MOVDnop x)
   461  	for {
   462  		x := v_0
   463  		if !(x.Uses == 1) {
   464  			break
   465  		}
   466  		v.Reset(ssaop.OpARM64MOVDnop)
   467  		v.AddArg(x)
   468  		return true
   469  	}
   470  	return false
   471  }
   472  func rewriteValue_OpARM64MOVHUreg(v *ssa.Value) bool {
   473  	v_0 := v.Args[0]
   474  	// match: (MOVHUreg x)
   475  	// cond: ssa.ZeroUpper48Bits(x)
   476  	// result: x
   477  	for {
   478  		x := v_0
   479  		if !(ssa.ZeroUpper48Bits(x)) {
   480  			break
   481  		}
   482  		v.CopyOf(x)
   483  		return true
   484  	}
   485  	// match: (MOVHUreg x:(MOVBUload _ _))
   486  	// result: (MOVDreg x)
   487  	for {
   488  		x := v_0
   489  		if x.Op != ssaop.OpARM64MOVBUload {
   490  			break
   491  		}
   492  		v.Reset(ssaop.OpARM64MOVDreg)
   493  		v.AddArg(x)
   494  		return true
   495  	}
   496  	// match: (MOVHUreg x:(MOVHUload _ _))
   497  	// result: (MOVDreg x)
   498  	for {
   499  		x := v_0
   500  		if x.Op != ssaop.OpARM64MOVHUload {
   501  			break
   502  		}
   503  		v.Reset(ssaop.OpARM64MOVDreg)
   504  		v.AddArg(x)
   505  		return true
   506  	}
   507  	// match: (MOVHUreg x:(MOVBUloadidx _ _ _))
   508  	// result: (MOVDreg x)
   509  	for {
   510  		x := v_0
   511  		if x.Op != ssaop.OpARM64MOVBUloadidx {
   512  			break
   513  		}
   514  		v.Reset(ssaop.OpARM64MOVDreg)
   515  		v.AddArg(x)
   516  		return true
   517  	}
   518  	// match: (MOVHUreg x:(MOVHUloadidx _ _ _))
   519  	// result: (MOVDreg x)
   520  	for {
   521  		x := v_0
   522  		if x.Op != ssaop.OpARM64MOVHUloadidx {
   523  			break
   524  		}
   525  		v.Reset(ssaop.OpARM64MOVDreg)
   526  		v.AddArg(x)
   527  		return true
   528  	}
   529  	// match: (MOVHUreg x:(MOVHUloadidx2 _ _ _))
   530  	// result: (MOVDreg x)
   531  	for {
   532  		x := v_0
   533  		if x.Op != ssaop.OpARM64MOVHUloadidx2 {
   534  			break
   535  		}
   536  		v.Reset(ssaop.OpARM64MOVDreg)
   537  		v.AddArg(x)
   538  		return true
   539  	}
   540  	// match: (MOVHUreg x:(MOVBUreg _))
   541  	// result: (MOVDreg x)
   542  	for {
   543  		x := v_0
   544  		if x.Op != ssaop.OpARM64MOVBUreg {
   545  			break
   546  		}
   547  		v.Reset(ssaop.OpARM64MOVDreg)
   548  		v.AddArg(x)
   549  		return true
   550  	}
   551  	// match: (MOVHUreg x:(MOVHUreg _))
   552  	// result: (MOVDreg x)
   553  	for {
   554  		x := v_0
   555  		if x.Op != ssaop.OpARM64MOVHUreg {
   556  			break
   557  		}
   558  		v.Reset(ssaop.OpARM64MOVDreg)
   559  		v.AddArg(x)
   560  		return true
   561  	}
   562  	return false
   563  }
   564  func rewriteValue_OpARM64MOVHreg(v *ssa.Value) bool {
   565  	v_0 := v.Args[0]
   566  	// match: (MOVHreg x:(MOVBload _ _))
   567  	// result: (MOVDreg x)
   568  	for {
   569  		x := v_0
   570  		if x.Op != ssaop.OpARM64MOVBload {
   571  			break
   572  		}
   573  		v.Reset(ssaop.OpARM64MOVDreg)
   574  		v.AddArg(x)
   575  		return true
   576  	}
   577  	// match: (MOVHreg x:(MOVBUload _ _))
   578  	// result: (MOVDreg x)
   579  	for {
   580  		x := v_0
   581  		if x.Op != ssaop.OpARM64MOVBUload {
   582  			break
   583  		}
   584  		v.Reset(ssaop.OpARM64MOVDreg)
   585  		v.AddArg(x)
   586  		return true
   587  	}
   588  	// match: (MOVHreg x:(MOVHload _ _))
   589  	// result: (MOVDreg x)
   590  	for {
   591  		x := v_0
   592  		if x.Op != ssaop.OpARM64MOVHload {
   593  			break
   594  		}
   595  		v.Reset(ssaop.OpARM64MOVDreg)
   596  		v.AddArg(x)
   597  		return true
   598  	}
   599  	// match: (MOVHreg x:(MOVBloadidx _ _ _))
   600  	// result: (MOVDreg x)
   601  	for {
   602  		x := v_0
   603  		if x.Op != ssaop.OpARM64MOVBloadidx {
   604  			break
   605  		}
   606  		v.Reset(ssaop.OpARM64MOVDreg)
   607  		v.AddArg(x)
   608  		return true
   609  	}
   610  	// match: (MOVHreg x:(MOVBUloadidx _ _ _))
   611  	// result: (MOVDreg x)
   612  	for {
   613  		x := v_0
   614  		if x.Op != ssaop.OpARM64MOVBUloadidx {
   615  			break
   616  		}
   617  		v.Reset(ssaop.OpARM64MOVDreg)
   618  		v.AddArg(x)
   619  		return true
   620  	}
   621  	// match: (MOVHreg x:(MOVHloadidx _ _ _))
   622  	// result: (MOVDreg x)
   623  	for {
   624  		x := v_0
   625  		if x.Op != ssaop.OpARM64MOVHloadidx {
   626  			break
   627  		}
   628  		v.Reset(ssaop.OpARM64MOVDreg)
   629  		v.AddArg(x)
   630  		return true
   631  	}
   632  	// match: (MOVHreg x:(MOVHloadidx2 _ _ _))
   633  	// result: (MOVDreg x)
   634  	for {
   635  		x := v_0
   636  		if x.Op != ssaop.OpARM64MOVHloadidx2 {
   637  			break
   638  		}
   639  		v.Reset(ssaop.OpARM64MOVDreg)
   640  		v.AddArg(x)
   641  		return true
   642  	}
   643  	// match: (MOVHreg x:(MOVBreg _))
   644  	// result: (MOVDreg x)
   645  	for {
   646  		x := v_0
   647  		if x.Op != ssaop.OpARM64MOVBreg {
   648  			break
   649  		}
   650  		v.Reset(ssaop.OpARM64MOVDreg)
   651  		v.AddArg(x)
   652  		return true
   653  	}
   654  	// match: (MOVHreg x:(MOVBUreg _))
   655  	// result: (MOVDreg x)
   656  	for {
   657  		x := v_0
   658  		if x.Op != ssaop.OpARM64MOVBUreg {
   659  			break
   660  		}
   661  		v.Reset(ssaop.OpARM64MOVDreg)
   662  		v.AddArg(x)
   663  		return true
   664  	}
   665  	// match: (MOVHreg x:(MOVHreg _))
   666  	// result: (MOVDreg x)
   667  	for {
   668  		x := v_0
   669  		if x.Op != ssaop.OpARM64MOVHreg {
   670  			break
   671  		}
   672  		v.Reset(ssaop.OpARM64MOVDreg)
   673  		v.AddArg(x)
   674  		return true
   675  	}
   676  	return false
   677  }
   678  func rewriteValue_OpARM64MOVWUreg(v *ssa.Value) bool {
   679  	v_0 := v.Args[0]
   680  	// match: (MOVWUreg x)
   681  	// cond: ssa.ZeroUpper32Bits(x)
   682  	// result: x
   683  	for {
   684  		x := v_0
   685  		if !(ssa.ZeroUpper32Bits(x)) {
   686  			break
   687  		}
   688  		v.CopyOf(x)
   689  		return true
   690  	}
   691  	// match: (MOVWUreg x:(MOVBUload _ _))
   692  	// result: (MOVDreg x)
   693  	for {
   694  		x := v_0
   695  		if x.Op != ssaop.OpARM64MOVBUload {
   696  			break
   697  		}
   698  		v.Reset(ssaop.OpARM64MOVDreg)
   699  		v.AddArg(x)
   700  		return true
   701  	}
   702  	// match: (MOVWUreg x:(MOVHUload _ _))
   703  	// result: (MOVDreg x)
   704  	for {
   705  		x := v_0
   706  		if x.Op != ssaop.OpARM64MOVHUload {
   707  			break
   708  		}
   709  		v.Reset(ssaop.OpARM64MOVDreg)
   710  		v.AddArg(x)
   711  		return true
   712  	}
   713  	// match: (MOVWUreg x:(MOVWUload _ _))
   714  	// result: (MOVDreg x)
   715  	for {
   716  		x := v_0
   717  		if x.Op != ssaop.OpARM64MOVWUload {
   718  			break
   719  		}
   720  		v.Reset(ssaop.OpARM64MOVDreg)
   721  		v.AddArg(x)
   722  		return true
   723  	}
   724  	// match: (MOVWUreg x:(MOVBUloadidx _ _ _))
   725  	// result: (MOVDreg x)
   726  	for {
   727  		x := v_0
   728  		if x.Op != ssaop.OpARM64MOVBUloadidx {
   729  			break
   730  		}
   731  		v.Reset(ssaop.OpARM64MOVDreg)
   732  		v.AddArg(x)
   733  		return true
   734  	}
   735  	// match: (MOVWUreg x:(MOVHUloadidx _ _ _))
   736  	// result: (MOVDreg x)
   737  	for {
   738  		x := v_0
   739  		if x.Op != ssaop.OpARM64MOVHUloadidx {
   740  			break
   741  		}
   742  		v.Reset(ssaop.OpARM64MOVDreg)
   743  		v.AddArg(x)
   744  		return true
   745  	}
   746  	// match: (MOVWUreg x:(MOVWUloadidx _ _ _))
   747  	// result: (MOVDreg x)
   748  	for {
   749  		x := v_0
   750  		if x.Op != ssaop.OpARM64MOVWUloadidx {
   751  			break
   752  		}
   753  		v.Reset(ssaop.OpARM64MOVDreg)
   754  		v.AddArg(x)
   755  		return true
   756  	}
   757  	// match: (MOVWUreg x:(MOVHUloadidx2 _ _ _))
   758  	// result: (MOVDreg x)
   759  	for {
   760  		x := v_0
   761  		if x.Op != ssaop.OpARM64MOVHUloadidx2 {
   762  			break
   763  		}
   764  		v.Reset(ssaop.OpARM64MOVDreg)
   765  		v.AddArg(x)
   766  		return true
   767  	}
   768  	// match: (MOVWUreg x:(MOVWUloadidx4 _ _ _))
   769  	// result: (MOVDreg x)
   770  	for {
   771  		x := v_0
   772  		if x.Op != ssaop.OpARM64MOVWUloadidx4 {
   773  			break
   774  		}
   775  		v.Reset(ssaop.OpARM64MOVDreg)
   776  		v.AddArg(x)
   777  		return true
   778  	}
   779  	// match: (MOVWUreg x:(MOVBUreg _))
   780  	// result: (MOVDreg x)
   781  	for {
   782  		x := v_0
   783  		if x.Op != ssaop.OpARM64MOVBUreg {
   784  			break
   785  		}
   786  		v.Reset(ssaop.OpARM64MOVDreg)
   787  		v.AddArg(x)
   788  		return true
   789  	}
   790  	// match: (MOVWUreg x:(MOVHUreg _))
   791  	// result: (MOVDreg x)
   792  	for {
   793  		x := v_0
   794  		if x.Op != ssaop.OpARM64MOVHUreg {
   795  			break
   796  		}
   797  		v.Reset(ssaop.OpARM64MOVDreg)
   798  		v.AddArg(x)
   799  		return true
   800  	}
   801  	// match: (MOVWUreg x:(MOVWUreg _))
   802  	// result: (MOVDreg x)
   803  	for {
   804  		x := v_0
   805  		if x.Op != ssaop.OpARM64MOVWUreg {
   806  			break
   807  		}
   808  		v.Reset(ssaop.OpARM64MOVDreg)
   809  		v.AddArg(x)
   810  		return true
   811  	}
   812  	return false
   813  }
   814  func rewriteValue_OpARM64MOVWreg(v *ssa.Value) bool {
   815  	v_0 := v.Args[0]
   816  	// match: (MOVWreg x:(MOVBload _ _))
   817  	// result: (MOVDreg x)
   818  	for {
   819  		x := v_0
   820  		if x.Op != ssaop.OpARM64MOVBload {
   821  			break
   822  		}
   823  		v.Reset(ssaop.OpARM64MOVDreg)
   824  		v.AddArg(x)
   825  		return true
   826  	}
   827  	// match: (MOVWreg x:(MOVBUload _ _))
   828  	// result: (MOVDreg x)
   829  	for {
   830  		x := v_0
   831  		if x.Op != ssaop.OpARM64MOVBUload {
   832  			break
   833  		}
   834  		v.Reset(ssaop.OpARM64MOVDreg)
   835  		v.AddArg(x)
   836  		return true
   837  	}
   838  	// match: (MOVWreg x:(MOVHload _ _))
   839  	// result: (MOVDreg x)
   840  	for {
   841  		x := v_0
   842  		if x.Op != ssaop.OpARM64MOVHload {
   843  			break
   844  		}
   845  		v.Reset(ssaop.OpARM64MOVDreg)
   846  		v.AddArg(x)
   847  		return true
   848  	}
   849  	// match: (MOVWreg x:(MOVHUload _ _))
   850  	// result: (MOVDreg x)
   851  	for {
   852  		x := v_0
   853  		if x.Op != ssaop.OpARM64MOVHUload {
   854  			break
   855  		}
   856  		v.Reset(ssaop.OpARM64MOVDreg)
   857  		v.AddArg(x)
   858  		return true
   859  	}
   860  	// match: (MOVWreg x:(MOVWload _ _))
   861  	// result: (MOVDreg x)
   862  	for {
   863  		x := v_0
   864  		if x.Op != ssaop.OpARM64MOVWload {
   865  			break
   866  		}
   867  		v.Reset(ssaop.OpARM64MOVDreg)
   868  		v.AddArg(x)
   869  		return true
   870  	}
   871  	// match: (MOVWreg x:(MOVBloadidx _ _ _))
   872  	// result: (MOVDreg x)
   873  	for {
   874  		x := v_0
   875  		if x.Op != ssaop.OpARM64MOVBloadidx {
   876  			break
   877  		}
   878  		v.Reset(ssaop.OpARM64MOVDreg)
   879  		v.AddArg(x)
   880  		return true
   881  	}
   882  	// match: (MOVWreg x:(MOVBUloadidx _ _ _))
   883  	// result: (MOVDreg x)
   884  	for {
   885  		x := v_0
   886  		if x.Op != ssaop.OpARM64MOVBUloadidx {
   887  			break
   888  		}
   889  		v.Reset(ssaop.OpARM64MOVDreg)
   890  		v.AddArg(x)
   891  		return true
   892  	}
   893  	// match: (MOVWreg x:(MOVHloadidx _ _ _))
   894  	// result: (MOVDreg x)
   895  	for {
   896  		x := v_0
   897  		if x.Op != ssaop.OpARM64MOVHloadidx {
   898  			break
   899  		}
   900  		v.Reset(ssaop.OpARM64MOVDreg)
   901  		v.AddArg(x)
   902  		return true
   903  	}
   904  	// match: (MOVWreg x:(MOVHUloadidx _ _ _))
   905  	// result: (MOVDreg x)
   906  	for {
   907  		x := v_0
   908  		if x.Op != ssaop.OpARM64MOVHUloadidx {
   909  			break
   910  		}
   911  		v.Reset(ssaop.OpARM64MOVDreg)
   912  		v.AddArg(x)
   913  		return true
   914  	}
   915  	// match: (MOVWreg x:(MOVWloadidx _ _ _))
   916  	// result: (MOVDreg x)
   917  	for {
   918  		x := v_0
   919  		if x.Op != ssaop.OpARM64MOVWloadidx {
   920  			break
   921  		}
   922  		v.Reset(ssaop.OpARM64MOVDreg)
   923  		v.AddArg(x)
   924  		return true
   925  	}
   926  	// match: (MOVWreg x:(MOVHloadidx2 _ _ _))
   927  	// result: (MOVDreg x)
   928  	for {
   929  		x := v_0
   930  		if x.Op != ssaop.OpARM64MOVHloadidx2 {
   931  			break
   932  		}
   933  		v.Reset(ssaop.OpARM64MOVDreg)
   934  		v.AddArg(x)
   935  		return true
   936  	}
   937  	// match: (MOVWreg x:(MOVHUloadidx2 _ _ _))
   938  	// result: (MOVDreg x)
   939  	for {
   940  		x := v_0
   941  		if x.Op != ssaop.OpARM64MOVHUloadidx2 {
   942  			break
   943  		}
   944  		v.Reset(ssaop.OpARM64MOVDreg)
   945  		v.AddArg(x)
   946  		return true
   947  	}
   948  	// match: (MOVWreg x:(MOVWloadidx4 _ _ _))
   949  	// result: (MOVDreg x)
   950  	for {
   951  		x := v_0
   952  		if x.Op != ssaop.OpARM64MOVWloadidx4 {
   953  			break
   954  		}
   955  		v.Reset(ssaop.OpARM64MOVDreg)
   956  		v.AddArg(x)
   957  		return true
   958  	}
   959  	// match: (MOVWreg x:(MOVBreg _))
   960  	// result: (MOVDreg x)
   961  	for {
   962  		x := v_0
   963  		if x.Op != ssaop.OpARM64MOVBreg {
   964  			break
   965  		}
   966  		v.Reset(ssaop.OpARM64MOVDreg)
   967  		v.AddArg(x)
   968  		return true
   969  	}
   970  	// match: (MOVWreg x:(MOVBUreg _))
   971  	// result: (MOVDreg x)
   972  	for {
   973  		x := v_0
   974  		if x.Op != ssaop.OpARM64MOVBUreg {
   975  			break
   976  		}
   977  		v.Reset(ssaop.OpARM64MOVDreg)
   978  		v.AddArg(x)
   979  		return true
   980  	}
   981  	// match: (MOVWreg x:(MOVHreg _))
   982  	// result: (MOVDreg x)
   983  	for {
   984  		x := v_0
   985  		if x.Op != ssaop.OpARM64MOVHreg {
   986  			break
   987  		}
   988  		v.Reset(ssaop.OpARM64MOVDreg)
   989  		v.AddArg(x)
   990  		return true
   991  	}
   992  	// match: (MOVWreg x:(MOVWreg _))
   993  	// result: (MOVDreg x)
   994  	for {
   995  		x := v_0
   996  		if x.Op != ssaop.OpARM64MOVWreg {
   997  			break
   998  		}
   999  		v.Reset(ssaop.OpARM64MOVDreg)
  1000  		v.AddArg(x)
  1001  		return true
  1002  	}
  1003  	return false
  1004  }
  1005  func rewriteValue_OpARM64ORconst(v *ssa.Value) bool {
  1006  	v_0 := v.Args[0]
  1007  	b := v.Block
  1008  	typ := &b.Func.Config.Types
  1009  	// match: (ORconst [c] x)
  1010  	// cond: !isARM64bitcon(uint64(c))
  1011  	// result: (OR x (MOVDconst [c]))
  1012  	for {
  1013  		c := ssa.AuxIntToInt64(v.AuxInt)
  1014  		x := v_0
  1015  		if !(!isARM64bitcon(uint64(c))) {
  1016  			break
  1017  		}
  1018  		v.Reset(ssaop.OpARM64OR)
  1019  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
  1020  		v0.AuxInt = ssa.Int64ToAuxInt(c)
  1021  		v.AddArg2(x, v0)
  1022  		return true
  1023  	}
  1024  	return false
  1025  }
  1026  func rewriteValue_OpARM64SLLconst(v *ssa.Value) bool {
  1027  	v_0 := v.Args[0]
  1028  	// match: (SLLconst [1] x)
  1029  	// result: (ADD x x)
  1030  	for {
  1031  		if ssa.AuxIntToInt64(v.AuxInt) != 1 {
  1032  			break
  1033  		}
  1034  		x := v_0
  1035  		v.Reset(ssaop.OpARM64ADD)
  1036  		v.AddArg2(x, x)
  1037  		return true
  1038  	}
  1039  	return false
  1040  }
  1041  func rewriteValue_OpARM64SUBconst(v *ssa.Value) bool {
  1042  	v_0 := v.Args[0]
  1043  	b := v.Block
  1044  	typ := &b.Func.Config.Types
  1045  	// match: (SUBconst [c] x)
  1046  	// cond: !isARM64addcon(c)
  1047  	// result: (SUB x (MOVDconst [c]))
  1048  	for {
  1049  		c := ssa.AuxIntToInt64(v.AuxInt)
  1050  		x := v_0
  1051  		if !(!isARM64addcon(c)) {
  1052  			break
  1053  		}
  1054  		v.Reset(ssaop.OpARM64SUB)
  1055  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
  1056  		v0.AuxInt = ssa.Int64ToAuxInt(c)
  1057  		v.AddArg2(x, v0)
  1058  		return true
  1059  	}
  1060  	return false
  1061  }
  1062  func rewriteValue_OpARM64TSTWconst(v *ssa.Value) bool {
  1063  	v_0 := v.Args[0]
  1064  	b := v.Block
  1065  	typ := &b.Func.Config.Types
  1066  	// match: (TSTWconst [c] x)
  1067  	// cond: !isARM64bitcon(uint64(c)|uint64(c)<<32)
  1068  	// result: (TSTW x (MOVDconst [int64(c)]))
  1069  	for {
  1070  		c := ssa.AuxIntToInt32(v.AuxInt)
  1071  		x := v_0
  1072  		if !(!isARM64bitcon(uint64(c) | uint64(c)<<32)) {
  1073  			break
  1074  		}
  1075  		v.Reset(ssaop.OpARM64TSTW)
  1076  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
  1077  		v0.AuxInt = ssa.Int64ToAuxInt(int64(c))
  1078  		v.AddArg2(x, v0)
  1079  		return true
  1080  	}
  1081  	return false
  1082  }
  1083  func rewriteValue_OpARM64TSTconst(v *ssa.Value) bool {
  1084  	v_0 := v.Args[0]
  1085  	b := v.Block
  1086  	typ := &b.Func.Config.Types
  1087  	// match: (TSTconst [c] x)
  1088  	// cond: !isARM64bitcon(uint64(c))
  1089  	// result: (TST x (MOVDconst [c]))
  1090  	for {
  1091  		c := ssa.AuxIntToInt64(v.AuxInt)
  1092  		x := v_0
  1093  		if !(!isARM64bitcon(uint64(c))) {
  1094  			break
  1095  		}
  1096  		v.Reset(ssaop.OpARM64TST)
  1097  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
  1098  		v0.AuxInt = ssa.Int64ToAuxInt(c)
  1099  		v.AddArg2(x, v0)
  1100  		return true
  1101  	}
  1102  	return false
  1103  }
  1104  func rewriteValue_OpARM64XORconst(v *ssa.Value) bool {
  1105  	v_0 := v.Args[0]
  1106  	b := v.Block
  1107  	typ := &b.Func.Config.Types
  1108  	// match: (XORconst [c] x)
  1109  	// cond: !isARM64bitcon(uint64(c))
  1110  	// result: (XOR x (MOVDconst [c]))
  1111  	for {
  1112  		c := ssa.AuxIntToInt64(v.AuxInt)
  1113  		x := v_0
  1114  		if !(!isARM64bitcon(uint64(c))) {
  1115  			break
  1116  		}
  1117  		v.Reset(ssaop.OpARM64XOR)
  1118  		v0 := b.NewValue0(v.Pos, ssaop.OpARM64MOVDconst, typ.UInt64)
  1119  		v0.AuxInt = ssa.Int64ToAuxInt(c)
  1120  		v.AddArg2(x, v0)
  1121  		return true
  1122  	}
  1123  	return false
  1124  }
  1125  func RewriteBlock(b *ssa.Block) bool {
  1126  	return false
  1127  }
  1128  

View as plain text