rewritePPC64latelower.go

     1  // Code generated from _gen/PPC64latelower.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package ssa
     4  
     5  import "internal/buildcfg"
     6  import "cmd/compile/internal/types"
     7  
     8  func rewriteValuePPC64latelower(v *Value) bool {
     9  	switch v.Op {
    10  	case OpPPC64ADD:
    11  		return rewriteValuePPC64latelower_OpPPC64ADD(v)
    12  	case OpPPC64AND:
    13  		return rewriteValuePPC64latelower_OpPPC64AND(v)
    14  	case OpPPC64CMPconst:
    15  		return rewriteValuePPC64latelower_OpPPC64CMPconst(v)
    16  	case OpPPC64ISEL:
    17  		return rewriteValuePPC64latelower_OpPPC64ISEL(v)
    18  	case OpPPC64RLDICL:
    19  		return rewriteValuePPC64latelower_OpPPC64RLDICL(v)
    20  	case OpPPC64SETBC:
    21  		return rewriteValuePPC64latelower_OpPPC64SETBC(v)
    22  	case OpPPC64SETBCR:
    23  		return rewriteValuePPC64latelower_OpPPC64SETBCR(v)
    24  	case OpSelect0:
    25  		return rewriteValuePPC64latelower_OpSelect0(v)
    26  	}
    27  	return false
    28  }
    29  func rewriteValuePPC64latelower_OpPPC64ADD(v *Value) bool {
    30  	v_1 := v.Args[1]
    31  	v_0 := v.Args[0]
    32  	// match: (ADD (MOVDconst [m]) x)
    33  	// cond: supportsPPC64PCRel() && (m<<30)>>30 == m
    34  	// result: (ADDconst [m] x)
    35  	for {
    36  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
    37  			if v_0.Op != OpPPC64MOVDconst {
    38  				continue
    39  			}
    40  			m := auxIntToInt64(v_0.AuxInt)
    41  			x := v_1
    42  			if !(supportsPPC64PCRel() && (m<<30)>>30 == m) {
    43  				continue
    44  			}
    45  			v.reset(OpPPC64ADDconst)
    46  			v.AuxInt = int64ToAuxInt(m)
    47  			v.AddArg(x)
    48  			return true
    49  		}
    50  		break
    51  	}
    52  	return false
    53  }
    54  func rewriteValuePPC64latelower_OpPPC64AND(v *Value) bool {
    55  	v_1 := v.Args[1]
    56  	v_0 := v.Args[0]
    57  	b := v.Block
    58  	typ := &b.Func.Config.Types
    59  	// match: (AND <t> x:(MOVDconst [m]) n)
    60  	// cond: t.Size() <= 2
    61  	// result: (Select0 (ANDCCconst [int64(int16(m))] n))
    62  	for {
    63  		t := v.Type
    64  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
    65  			x := v_0
    66  			if x.Op != OpPPC64MOVDconst {
    67  				continue
    68  			}
    69  			m := auxIntToInt64(x.AuxInt)
    70  			n := v_1
    71  			if !(t.Size() <= 2) {
    72  				continue
    73  			}
    74  			v.reset(OpSelect0)
    75  			v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.NewTuple(typ.Int, types.TypeFlags))
    76  			v0.AuxInt = int64ToAuxInt(int64(int16(m)))
    77  			v0.AddArg(n)
    78  			v.AddArg(v0)
    79  			return true
    80  		}
    81  		break
    82  	}
    83  	// match: (AND x:(MOVDconst [m]) n)
    84  	// cond: isPPC64ValidShiftMask(m)
    85  	// result: (RLDICL [encodePPC64RotateMask(0,m,64)] n)
    86  	for {
    87  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
    88  			x := v_0
    89  			if x.Op != OpPPC64MOVDconst {
    90  				continue
    91  			}
    92  			m := auxIntToInt64(x.AuxInt)
    93  			n := v_1
    94  			if !(isPPC64ValidShiftMask(m)) {
    95  				continue
    96  			}
    97  			v.reset(OpPPC64RLDICL)
    98  			v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 64))
    99  			v.AddArg(n)
   100  			return true
   101  		}
   102  		break
   103  	}
   104  	// match: (AND x:(MOVDconst [m]) n)
   105  	// cond: m != 0 && isPPC64ValidShiftMask(^m)
   106  	// result: (RLDICR [encodePPC64RotateMask(0,m,64)] n)
   107  	for {
   108  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   109  			x := v_0
   110  			if x.Op != OpPPC64MOVDconst {
   111  				continue
   112  			}
   113  			m := auxIntToInt64(x.AuxInt)
   114  			n := v_1
   115  			if !(m != 0 && isPPC64ValidShiftMask(^m)) {
   116  				continue
   117  			}
   118  			v.reset(OpPPC64RLDICR)
   119  			v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 64))
   120  			v.AddArg(n)
   121  			return true
   122  		}
   123  		break
   124  	}
   125  	// match: (AND <t> x:(MOVDconst [m]) n)
   126  	// cond: t.Size() == 4 && isPPC64WordRotateMask(m)
   127  	// result: (RLWINM [encodePPC64RotateMask(0,m,32)] n)
   128  	for {
   129  		t := v.Type
   130  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   131  			x := v_0
   132  			if x.Op != OpPPC64MOVDconst {
   133  				continue
   134  			}
   135  			m := auxIntToInt64(x.AuxInt)
   136  			n := v_1
   137  			if !(t.Size() == 4 && isPPC64WordRotateMask(m)) {
   138  				continue
   139  			}
   140  			v.reset(OpPPC64RLWINM)
   141  			v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 32))
   142  			v.AddArg(n)
   143  			return true
   144  		}
   145  		break
   146  	}
   147  	return false
   148  }
   149  func rewriteValuePPC64latelower_OpPPC64CMPconst(v *Value) bool {
   150  	v_0 := v.Args[0]
   151  	// match: (CMPconst [0] z:(ADD x y))
   152  	// cond: v.Block == z.Block
   153  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   154  	for {
   155  		if auxIntToInt64(v.AuxInt) != 0 {
   156  			break
   157  		}
   158  		z := v_0
   159  		if z.Op != OpPPC64ADD {
   160  			break
   161  		}
   162  		if !(v.Block == z.Block) {
   163  			break
   164  		}
   165  		v.reset(OpPPC64CMPconst)
   166  		v.AuxInt = int64ToAuxInt(0)
   167  		v.AddArg(convertPPC64OpToOpCC(z))
   168  		return true
   169  	}
   170  	// match: (CMPconst [0] z:(AND x y))
   171  	// cond: v.Block == z.Block
   172  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   173  	for {
   174  		if auxIntToInt64(v.AuxInt) != 0 {
   175  			break
   176  		}
   177  		z := v_0
   178  		if z.Op != OpPPC64AND {
   179  			break
   180  		}
   181  		if !(v.Block == z.Block) {
   182  			break
   183  		}
   184  		v.reset(OpPPC64CMPconst)
   185  		v.AuxInt = int64ToAuxInt(0)
   186  		v.AddArg(convertPPC64OpToOpCC(z))
   187  		return true
   188  	}
   189  	// match: (CMPconst [0] z:(ANDN x y))
   190  	// cond: v.Block == z.Block
   191  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   192  	for {
   193  		if auxIntToInt64(v.AuxInt) != 0 {
   194  			break
   195  		}
   196  		z := v_0
   197  		if z.Op != OpPPC64ANDN {
   198  			break
   199  		}
   200  		if !(v.Block == z.Block) {
   201  			break
   202  		}
   203  		v.reset(OpPPC64CMPconst)
   204  		v.AuxInt = int64ToAuxInt(0)
   205  		v.AddArg(convertPPC64OpToOpCC(z))
   206  		return true
   207  	}
   208  	// match: (CMPconst [0] z:(OR x y))
   209  	// cond: v.Block == z.Block
   210  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   211  	for {
   212  		if auxIntToInt64(v.AuxInt) != 0 {
   213  			break
   214  		}
   215  		z := v_0
   216  		if z.Op != OpPPC64OR {
   217  			break
   218  		}
   219  		if !(v.Block == z.Block) {
   220  			break
   221  		}
   222  		v.reset(OpPPC64CMPconst)
   223  		v.AuxInt = int64ToAuxInt(0)
   224  		v.AddArg(convertPPC64OpToOpCC(z))
   225  		return true
   226  	}
   227  	// match: (CMPconst [0] z:(SUB x y))
   228  	// cond: v.Block == z.Block
   229  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   230  	for {
   231  		if auxIntToInt64(v.AuxInt) != 0 {
   232  			break
   233  		}
   234  		z := v_0
   235  		if z.Op != OpPPC64SUB {
   236  			break
   237  		}
   238  		if !(v.Block == z.Block) {
   239  			break
   240  		}
   241  		v.reset(OpPPC64CMPconst)
   242  		v.AuxInt = int64ToAuxInt(0)
   243  		v.AddArg(convertPPC64OpToOpCC(z))
   244  		return true
   245  	}
   246  	// match: (CMPconst [0] z:(NOR x y))
   247  	// cond: v.Block == z.Block
   248  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   249  	for {
   250  		if auxIntToInt64(v.AuxInt) != 0 {
   251  			break
   252  		}
   253  		z := v_0
   254  		if z.Op != OpPPC64NOR {
   255  			break
   256  		}
   257  		if !(v.Block == z.Block) {
   258  			break
   259  		}
   260  		v.reset(OpPPC64CMPconst)
   261  		v.AuxInt = int64ToAuxInt(0)
   262  		v.AddArg(convertPPC64OpToOpCC(z))
   263  		return true
   264  	}
   265  	// match: (CMPconst [0] z:(XOR x y))
   266  	// cond: v.Block == z.Block
   267  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   268  	for {
   269  		if auxIntToInt64(v.AuxInt) != 0 {
   270  			break
   271  		}
   272  		z := v_0
   273  		if z.Op != OpPPC64XOR {
   274  			break
   275  		}
   276  		if !(v.Block == z.Block) {
   277  			break
   278  		}
   279  		v.reset(OpPPC64CMPconst)
   280  		v.AuxInt = int64ToAuxInt(0)
   281  		v.AddArg(convertPPC64OpToOpCC(z))
   282  		return true
   283  	}
   284  	// match: (CMPconst [0] z:(NEG x))
   285  	// cond: v.Block == z.Block
   286  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   287  	for {
   288  		if auxIntToInt64(v.AuxInt) != 0 {
   289  			break
   290  		}
   291  		z := v_0
   292  		if z.Op != OpPPC64NEG {
   293  			break
   294  		}
   295  		if !(v.Block == z.Block) {
   296  			break
   297  		}
   298  		v.reset(OpPPC64CMPconst)
   299  		v.AuxInt = int64ToAuxInt(0)
   300  		v.AddArg(convertPPC64OpToOpCC(z))
   301  		return true
   302  	}
   303  	// match: (CMPconst [0] z:(CNTLZD x))
   304  	// cond: v.Block == z.Block
   305  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   306  	for {
   307  		if auxIntToInt64(v.AuxInt) != 0 {
   308  			break
   309  		}
   310  		z := v_0
   311  		if z.Op != OpPPC64CNTLZD {
   312  			break
   313  		}
   314  		if !(v.Block == z.Block) {
   315  			break
   316  		}
   317  		v.reset(OpPPC64CMPconst)
   318  		v.AuxInt = int64ToAuxInt(0)
   319  		v.AddArg(convertPPC64OpToOpCC(z))
   320  		return true
   321  	}
   322  	// match: (CMPconst [0] z:(ADDconst [c] x))
   323  	// cond: int64(int16(c)) == c && v.Block == z.Block
   324  	// result: (CMPconst [0] convertPPC64OpToOpCC(z))
   325  	for {
   326  		if auxIntToInt64(v.AuxInt) != 0 {
   327  			break
   328  		}
   329  		z := v_0
   330  		if z.Op != OpPPC64ADDconst {
   331  			break
   332  		}
   333  		c := auxIntToInt64(z.AuxInt)
   334  		if !(int64(int16(c)) == c && v.Block == z.Block) {
   335  			break
   336  		}
   337  		v.reset(OpPPC64CMPconst)
   338  		v.AuxInt = int64ToAuxInt(0)
   339  		v.AddArg(convertPPC64OpToOpCC(z))
   340  		return true
   341  	}
   342  	// match: (CMPconst <t> [0] (Select0 z:(ADDCC x y)))
   343  	// result: (Select1 <t> z)
   344  	for {
   345  		t := v.Type
   346  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   347  			break
   348  		}
   349  		z := v_0.Args[0]
   350  		if z.Op != OpPPC64ADDCC {
   351  			break
   352  		}
   353  		v.reset(OpSelect1)
   354  		v.Type = t
   355  		v.AddArg(z)
   356  		return true
   357  	}
   358  	// match: (CMPconst <t> [0] (Select0 z:(ANDCC x y)))
   359  	// result: (Select1 <t> z)
   360  	for {
   361  		t := v.Type
   362  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   363  			break
   364  		}
   365  		z := v_0.Args[0]
   366  		if z.Op != OpPPC64ANDCC {
   367  			break
   368  		}
   369  		v.reset(OpSelect1)
   370  		v.Type = t
   371  		v.AddArg(z)
   372  		return true
   373  	}
   374  	// match: (CMPconst <t> [0] (Select0 z:(ANDNCC x y)))
   375  	// result: (Select1 <t> z)
   376  	for {
   377  		t := v.Type
   378  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   379  			break
   380  		}
   381  		z := v_0.Args[0]
   382  		if z.Op != OpPPC64ANDNCC {
   383  			break
   384  		}
   385  		v.reset(OpSelect1)
   386  		v.Type = t
   387  		v.AddArg(z)
   388  		return true
   389  	}
   390  	// match: (CMPconst <t> [0] (Select0 z:(ORCC x y)))
   391  	// result: (Select1 <t> z)
   392  	for {
   393  		t := v.Type
   394  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   395  			break
   396  		}
   397  		z := v_0.Args[0]
   398  		if z.Op != OpPPC64ORCC {
   399  			break
   400  		}
   401  		v.reset(OpSelect1)
   402  		v.Type = t
   403  		v.AddArg(z)
   404  		return true
   405  	}
   406  	// match: (CMPconst <t> [0] (Select0 z:(SUBCC x y)))
   407  	// result: (Select1 <t> z)
   408  	for {
   409  		t := v.Type
   410  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   411  			break
   412  		}
   413  		z := v_0.Args[0]
   414  		if z.Op != OpPPC64SUBCC {
   415  			break
   416  		}
   417  		v.reset(OpSelect1)
   418  		v.Type = t
   419  		v.AddArg(z)
   420  		return true
   421  	}
   422  	// match: (CMPconst <t> [0] (Select0 z:(NORCC x y)))
   423  	// result: (Select1 <t> z)
   424  	for {
   425  		t := v.Type
   426  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   427  			break
   428  		}
   429  		z := v_0.Args[0]
   430  		if z.Op != OpPPC64NORCC {
   431  			break
   432  		}
   433  		v.reset(OpSelect1)
   434  		v.Type = t
   435  		v.AddArg(z)
   436  		return true
   437  	}
   438  	// match: (CMPconst <t> [0] (Select0 z:(XORCC x y)))
   439  	// result: (Select1 <t> z)
   440  	for {
   441  		t := v.Type
   442  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   443  			break
   444  		}
   445  		z := v_0.Args[0]
   446  		if z.Op != OpPPC64XORCC {
   447  			break
   448  		}
   449  		v.reset(OpSelect1)
   450  		v.Type = t
   451  		v.AddArg(z)
   452  		return true
   453  	}
   454  	// match: (CMPconst <t> [0] (Select0 z:(ADDCCconst y)))
   455  	// result: (Select1 <t> z)
   456  	for {
   457  		t := v.Type
   458  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   459  			break
   460  		}
   461  		z := v_0.Args[0]
   462  		if z.Op != OpPPC64ADDCCconst {
   463  			break
   464  		}
   465  		v.reset(OpSelect1)
   466  		v.Type = t
   467  		v.AddArg(z)
   468  		return true
   469  	}
   470  	// match: (CMPconst <t> [0] (Select0 z:(NEGCC y)))
   471  	// result: (Select1 <t> z)
   472  	for {
   473  		t := v.Type
   474  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   475  			break
   476  		}
   477  		z := v_0.Args[0]
   478  		if z.Op != OpPPC64NEGCC {
   479  			break
   480  		}
   481  		v.reset(OpSelect1)
   482  		v.Type = t
   483  		v.AddArg(z)
   484  		return true
   485  	}
   486  	// match: (CMPconst <t> [0] (Select0 z:(CNTLZDCC y)))
   487  	// result: (Select1 <t> z)
   488  	for {
   489  		t := v.Type
   490  		if auxIntToInt64(v.AuxInt) != 0 || v_0.Op != OpSelect0 {
   491  			break
   492  		}
   493  		z := v_0.Args[0]
   494  		if z.Op != OpPPC64CNTLZDCC {
   495  			break
   496  		}
   497  		v.reset(OpSelect1)
   498  		v.Type = t
   499  		v.AddArg(z)
   500  		return true
   501  	}
   502  	return false
   503  }
   504  func rewriteValuePPC64latelower_OpPPC64ISEL(v *Value) bool {
   505  	v_2 := v.Args[2]
   506  	v_1 := v.Args[1]
   507  	v_0 := v.Args[0]
   508  	// match: (ISEL [a] x (MOVDconst [0]) z)
   509  	// result: (ISELZ [a] x z)
   510  	for {
   511  		a := auxIntToInt32(v.AuxInt)
   512  		x := v_0
   513  		if v_1.Op != OpPPC64MOVDconst || auxIntToInt64(v_1.AuxInt) != 0 {
   514  			break
   515  		}
   516  		z := v_2
   517  		v.reset(OpPPC64ISELZ)
   518  		v.AuxInt = int32ToAuxInt(a)
   519  		v.AddArg2(x, z)
   520  		return true
   521  	}
   522  	// match: (ISEL [a] (MOVDconst [0]) y z)
   523  	// result: (ISELZ [a^0x4] y z)
   524  	for {
   525  		a := auxIntToInt32(v.AuxInt)
   526  		if v_0.Op != OpPPC64MOVDconst || auxIntToInt64(v_0.AuxInt) != 0 {
   527  			break
   528  		}
   529  		y := v_1
   530  		z := v_2
   531  		v.reset(OpPPC64ISELZ)
   532  		v.AuxInt = int32ToAuxInt(a ^ 0x4)
   533  		v.AddArg2(y, z)
   534  		return true
   535  	}
   536  	return false
   537  }
   538  func rewriteValuePPC64latelower_OpPPC64RLDICL(v *Value) bool {
   539  	v_0 := v.Args[0]
   540  	// match: (RLDICL [em] x:(SRDconst [s] a))
   541  	// cond: (em&0xFF0000) == 0
   542  	// result: (RLDICL [mergePPC64RLDICLandSRDconst(em, s)] a)
   543  	for {
   544  		em := auxIntToInt64(v.AuxInt)
   545  		x := v_0
   546  		if x.Op != OpPPC64SRDconst {
   547  			break
   548  		}
   549  		s := auxIntToInt64(x.AuxInt)
   550  		a := x.Args[0]
   551  		if !((em & 0xFF0000) == 0) {
   552  			break
   553  		}
   554  		v.reset(OpPPC64RLDICL)
   555  		v.AuxInt = int64ToAuxInt(mergePPC64RLDICLandSRDconst(em, s))
   556  		v.AddArg(a)
   557  		return true
   558  	}
   559  	return false
   560  }
   561  func rewriteValuePPC64latelower_OpPPC64SETBC(v *Value) bool {
   562  	v_0 := v.Args[0]
   563  	b := v.Block
   564  	typ := &b.Func.Config.Types
   565  	// match: (SETBC [2] cmp)
   566  	// cond: buildcfg.GOPPC64 <= 9
   567  	// result: (ISELZ [2] (MOVDconst [1]) cmp)
   568  	for {
   569  		if auxIntToInt32(v.AuxInt) != 2 {
   570  			break
   571  		}
   572  		cmp := v_0
   573  		if !(buildcfg.GOPPC64 <= 9) {
   574  			break
   575  		}
   576  		v.reset(OpPPC64ISELZ)
   577  		v.AuxInt = int32ToAuxInt(2)
   578  		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
   579  		v0.AuxInt = int64ToAuxInt(1)
   580  		v.AddArg2(v0, cmp)
   581  		return true
   582  	}
   583  	// match: (SETBC [0] cmp)
   584  	// cond: buildcfg.GOPPC64 <= 9
   585  	// result: (ISELZ [0] (MOVDconst [1]) cmp)
   586  	for {
   587  		if auxIntToInt32(v.AuxInt) != 0 {
   588  			break
   589  		}
   590  		cmp := v_0
   591  		if !(buildcfg.GOPPC64 <= 9) {
   592  			break
   593  		}
   594  		v.reset(OpPPC64ISELZ)
   595  		v.AuxInt = int32ToAuxInt(0)
   596  		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
   597  		v0.AuxInt = int64ToAuxInt(1)
   598  		v.AddArg2(v0, cmp)
   599  		return true
   600  	}
   601  	// match: (SETBC [1] cmp)
   602  	// cond: buildcfg.GOPPC64 <= 9
   603  	// result: (ISELZ [1] (MOVDconst [1]) cmp)
   604  	for {
   605  		if auxIntToInt32(v.AuxInt) != 1 {
   606  			break
   607  		}
   608  		cmp := v_0
   609  		if !(buildcfg.GOPPC64 <= 9) {
   610  			break
   611  		}
   612  		v.reset(OpPPC64ISELZ)
   613  		v.AuxInt = int32ToAuxInt(1)
   614  		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
   615  		v0.AuxInt = int64ToAuxInt(1)
   616  		v.AddArg2(v0, cmp)
   617  		return true
   618  	}
   619  	return false
   620  }
   621  func rewriteValuePPC64latelower_OpPPC64SETBCR(v *Value) bool {
   622  	v_0 := v.Args[0]
   623  	b := v.Block
   624  	typ := &b.Func.Config.Types
   625  	// match: (SETBCR [2] cmp)
   626  	// cond: buildcfg.GOPPC64 <= 9
   627  	// result: (ISELZ [6] (MOVDconst [1]) cmp)
   628  	for {
   629  		if auxIntToInt32(v.AuxInt) != 2 {
   630  			break
   631  		}
   632  		cmp := v_0
   633  		if !(buildcfg.GOPPC64 <= 9) {
   634  			break
   635  		}
   636  		v.reset(OpPPC64ISELZ)
   637  		v.AuxInt = int32ToAuxInt(6)
   638  		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
   639  		v0.AuxInt = int64ToAuxInt(1)
   640  		v.AddArg2(v0, cmp)
   641  		return true
   642  	}
   643  	// match: (SETBCR [0] cmp)
   644  	// cond: buildcfg.GOPPC64 <= 9
   645  	// result: (ISELZ [4] (MOVDconst [1]) cmp)
   646  	for {
   647  		if auxIntToInt32(v.AuxInt) != 0 {
   648  			break
   649  		}
   650  		cmp := v_0
   651  		if !(buildcfg.GOPPC64 <= 9) {
   652  			break
   653  		}
   654  		v.reset(OpPPC64ISELZ)
   655  		v.AuxInt = int32ToAuxInt(4)
   656  		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
   657  		v0.AuxInt = int64ToAuxInt(1)
   658  		v.AddArg2(v0, cmp)
   659  		return true
   660  	}
   661  	// match: (SETBCR [1] cmp)
   662  	// cond: buildcfg.GOPPC64 <= 9
   663  	// result: (ISELZ [5] (MOVDconst [1]) cmp)
   664  	for {
   665  		if auxIntToInt32(v.AuxInt) != 1 {
   666  			break
   667  		}
   668  		cmp := v_0
   669  		if !(buildcfg.GOPPC64 <= 9) {
   670  			break
   671  		}
   672  		v.reset(OpPPC64ISELZ)
   673  		v.AuxInt = int32ToAuxInt(5)
   674  		v0 := b.NewValue0(v.Pos, OpPPC64MOVDconst, typ.Int64)
   675  		v0.AuxInt = int64ToAuxInt(1)
   676  		v.AddArg2(v0, cmp)
   677  		return true
   678  	}
   679  	return false
   680  }
   681  func rewriteValuePPC64latelower_OpSelect0(v *Value) bool {
   682  	v_0 := v.Args[0]
   683  	// match: (Select0 z:(ANDCCconst [m] x))
   684  	// cond: z.Uses == 1 && isPPC64ValidShiftMask(m)
   685  	// result: (RLDICL [encodePPC64RotateMask(0,m,64)] x)
   686  	for {
   687  		z := v_0
   688  		if z.Op != OpPPC64ANDCCconst {
   689  			break
   690  		}
   691  		m := auxIntToInt64(z.AuxInt)
   692  		x := z.Args[0]
   693  		if !(z.Uses == 1 && isPPC64ValidShiftMask(m)) {
   694  			break
   695  		}
   696  		v.reset(OpPPC64RLDICL)
   697  		v.AuxInt = int64ToAuxInt(encodePPC64RotateMask(0, m, 64))
   698  		v.AddArg(x)
   699  		return true
   700  	}
   701  	return false
   702  }
   703  func rewriteBlockPPC64latelower(b *Block) bool {
   704  	return false
   705  }
   706
View as plain text