Introduced XXEvalUnaryPattern class. Removed DagUnaryVNot

Author: Tony Varghese

llvm/lib/Target/PowerPC/PPCInstrP10.td

@@ -2159,7 +2159,7 @@ let AddedComplexity = 400, Predicates = [IsISA3_1, HasVSX] in {
                                (COPY_TO_REGCLASS $VRB, VSRC), 2)))>;
 }
 
-class XXEvalPattern <ValueType vt, dag pattern, bits<8> imm> :
+class xxevalPattern <ValueType vt, dag pattern, bits<8> imm> :
   Pat<(vt pattern), (XXEVAL $vA, $vB, $vC, imm)> {}
 
 class DagCondVNot<dag d, bit negate> {
@@ -2196,91 +2196,91 @@ class XXEvalBinaryPattern<ValueType vt, SDPatternOperator op, bit notResult = 0>
 multiclass XXEvalVSelectWithXAnd<ValueType vt, bits<8> baseImm> {
   // Multiclass for Ternary(A, X, and(B, C)) style patterns.
   // Ternary(A, xor(B,C), and(B,C)) => imm: baseImm
-  def : XXEvalPattern<vt, 
+  def : xxevalPattern<vt, 
         (vselect vt:$vA, XXEvalBinaryPattern<vt, xor>.opPat, XXEvalBinaryPattern<vt, and>.opPat), 
         baseImm>;
   // Ternary(A, nor(B,C), and(B,C)) => imm: baseImm + 2
-  def : XXEvalPattern<vt, 
+  def : xxevalPattern<vt, 
         (vselect vt:$vA, XXEvalBinaryPattern<vt, or, 1>.opPat, XXEvalBinaryPattern<vt, and>.opPat), 
         !add(baseImm, 2)>;
   // Ternary(A, eqv(B,C), and(B,C)) => imm: baseImm + 3
-  def : XXEvalPattern<vt, 
+  def : xxevalPattern<vt, 
         (vselect vt:$vA, XXEvalBinaryPattern<vt, xor, 1>.opPat, XXEvalBinaryPattern<vt, and>.opPat), 
         !add(baseImm, 3)>;
   // Ternary(A, not(C), and(B,C)) => imm: baseImm + 4
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalUnaryPattern<vt>.vnotC, XXEvalBinaryPattern<vt, and>.opPat), 
         !add(baseImm, 4)>;
   // Ternary(A, not(B), and(B,C)) => imm: baseImm + 6
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalUnaryPattern<vt>.vnotB, XXEvalBinaryPattern<vt, and>.opPat), 
         !add(baseImm, 6)>;
 }
 
 multiclass XXEvalVSelectWithXB<ValueType vt, bits<8> baseImm>{
   // Multiclass for Ternary(A, X, B) style patterns
   // Ternary(A, and(B,C), B) => imm: baseImm
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, and>.opPat, vt:$vB), 
         baseImm>;
   // Ternary(A, nor(B,C), B) => imm: baseImm + 7
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, or, 1>.opPat, vt:$vB), 
         !add(baseImm, 7)>;
   // Ternary(A, eqv(B,C), B) => imm: baseImm + 8
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, xor, 1>.opPat, vt:$vB), 
         !add(baseImm, 8)>;
   // Ternary(A, not(C), B) => imm: baseImm + 9
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalUnaryPattern<vt>.vnotC, vt:$vB), 
         !add(baseImm, 9)>;
   // Ternary(A, nand(B,C), B) => imm: baseImm + 13
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, and, 1>.opPat, vt:$vB), 
         !add(baseImm, 13)>;
 }
 
 multiclass XXEvalVSelectWithXC<ValueType vt, bits<8> baseImm>{
   // Multiclass for Ternary(A, X, C) style patterns
   // Ternary(A, and(B,C), C) => imm: baseImm
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, and>.opPat, vt:$vC), 
         baseImm>;
   // Ternary(A, nor(B,C), C) => imm: baseImm + 7
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, or, 1>.opPat, vt:$vC), 
         !add(baseImm, 7)>;
   // Ternary(A, eqv(B,C), C) => imm: baseImm + 8
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, xor, 1>.opPat, vt:$vC), 
         !add(baseImm, 8)>;
   // Ternary(A, nand(B,C), C) => imm: baseImm + 13
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, and, 1>.opPat, vt:$vC), 
         !add(baseImm, 13)>;
 }
 
 multiclass XXEvalVSelectWithXXor<ValueType vt, bits<8> baseImm>{
   // Multiclass for Ternary(A, X, xor(B,C)) style patterns
   // Ternary(A, and(B,C), xor(B,C)) => imm: baseImm
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, and>.opPat, XXEvalBinaryPattern<vt, xor>.opPat), 
         baseImm>;
   // Ternary(A, B, xor(B,C)) => imm: baseImm + 2
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, vt:$vB, XXEvalBinaryPattern<vt, xor>.opPat), 
         !add(baseImm, 2)>;
   // Ternary(A, C, xor(B,C)) => imm: baseImm + 4
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, vt:$vC, XXEvalBinaryPattern<vt, xor>.opPat), 
         !add(baseImm, 4)>;
   // Ternary(A, or(B,C), xor(B,C)) => imm: baseImm + 6
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, or>.opPat, XXEvalBinaryPattern<vt, xor>.opPat), 
         !add(baseImm, 6)>;
   // Ternary(A, nor(B,C), xor(B,C)) => imm: baseImm + 7
-  def : XXEvalPattern<vt,
+  def : xxevalPattern<vt,
         (vselect vt:$vA, XXEvalBinaryPattern<vt, or, 1>.opPat, XXEvalBinaryPattern<vt, xor>.opPat), 
         !add(baseImm, 7)>; 
 }
@@ -2315,83 +2315,83 @@ let Predicates = [PrefixInstrs, HasP10Vector] in {
     // Anonymous patterns for XXEVAL
     // AND
     // and(A, B, C)
-    def : XXEvalPattern<v4i32, (and v4i32:$vA, (and v4i32:$vB, v4i32:$vC)), 1>;
+    def : xxevalPattern<v4i32, (and v4i32:$vA, (and v4i32:$vB, v4i32:$vC)), 1>;
     // and(A, xor(B, C))
-    def : XXEvalPattern<v4i32, (and v4i32:$vA, (xor v4i32:$vB, v4i32:$vC)), 6>;
+    def : xxevalPattern<v4i32, (and v4i32:$vA, (xor v4i32:$vB, v4i32:$vC)), 6>;
     // and(A, or(B, C))
-    def : XXEvalPattern<v4i32, (and v4i32:$vA, (or v4i32:$vB, v4i32:$vC)), 7>;
+    def : xxevalPattern<v4i32, (and v4i32:$vA, (or v4i32:$vB, v4i32:$vC)), 7>;
     // and(A, nor(B, C))
-    def : XXEvalPattern<v4i32, (and v4i32:$vA, (vnot (or v4i32:$vB, v4i32:$vC))), 8>;
+    def : xxevalPattern<v4i32, (and v4i32:$vA, (vnot (or v4i32:$vB, v4i32:$vC))), 8>;
     // and(A, eqv(B, C))
-    def : XXEvalPattern<v4i32, (and v4i32:$vA, (vnot (xor v4i32:$vB, v4i32:$vC))), 9>;
+    def : xxevalPattern<v4i32, (and v4i32:$vA, (vnot (xor v4i32:$vB, v4i32:$vC))), 9>;
     // and(A, nand(B, C))
-    def : XXEvalPattern<v4i32, (and v4i32:$vA, (vnot (and v4i32:$vB, v4i32:$vC))), 14>;
+    def : xxevalPattern<v4i32, (and v4i32:$vA, (vnot (and v4i32:$vB, v4i32:$vC))), 14>;
 
     // NAND
     // nand(A, B, C)
-    def : XXEvalPattern<v4i32, (vnot (and v4i32:$vA, (and v4i32:$vB, v4i32:$vC))),
+    def : xxevalPattern<v4i32, (vnot (and v4i32:$vA, (and v4i32:$vB, v4i32:$vC))),
                          !sub(255, 1)>;
     // nand(A, xor(B, C))
-    def : XXEvalPattern<v4i32, (vnot (and v4i32:$vA, (xor v4i32:$vB, v4i32:$vC))),
+    def : xxevalPattern<v4i32, (vnot (and v4i32:$vA, (xor v4i32:$vB, v4i32:$vC))),
                          !sub(255, 6)>;
     // nand(A, or(B, C))
-    def : XXEvalPattern<v4i32, (vnot (and v4i32:$vA, (or v4i32:$vB, v4i32:$vC))),
+    def : xxevalPattern<v4i32, (vnot (and v4i32:$vA, (or v4i32:$vB, v4i32:$vC))),
                          !sub(255, 7)>;
     // nand(A, nor(B, C))
-    def : XXEvalPattern<v4i32, (or (vnot v4i32:$vA), (or v4i32:$vB, v4i32:$vC)),
+    def : xxevalPattern<v4i32, (or (vnot v4i32:$vA), (or v4i32:$vB, v4i32:$vC)),
                          !sub(255, 8)>;
     // nand(A, eqv(B, C))
-    def : XXEvalPattern<v4i32, (or (vnot v4i32:$vA), (xor v4i32:$vB, v4i32:$vC)),
+    def : xxevalPattern<v4i32, (or (vnot v4i32:$vA), (xor v4i32:$vB, v4i32:$vC)),
                          !sub(255, 9)>;
     // nand(A, nand(B, C))
-    def : XXEvalPattern<v4i32, (or (vnot v4i32:$vA), (and v4i32:$vB, v4i32:$vC)),
+    def : xxevalPattern<v4i32, (or (vnot v4i32:$vA), (and v4i32:$vB, v4i32:$vC)),
                          !sub(255, 14)>;
 
     // EQV
     // (eqv A, B, C)
-    def : XXEvalPattern<v4i32, (or (and v4i32:$vA, (and v4i32:$vB, v4i32:$vC)),
+    def : xxevalPattern<v4i32, (or (and v4i32:$vA, (and v4i32:$vB, v4i32:$vC)),
                             (vnot (or v4i32:$vA, (or v4i32:$vB, v4i32:$vC)))),
                          150>;
     // (eqv A, (and B, C))
-    def : XXEvalPattern<v4i32, (vnot (xor v4i32:$vA, (and v4i32:$vB, v4i32:$vC))), 225>;
+    def : xxevalPattern<v4i32, (vnot (xor v4i32:$vA, (and v4i32:$vB, v4i32:$vC))), 225>;
     // (eqv A, (or B, C))
-    def : XXEvalPattern<v4i32, (vnot (xor v4i32:$vA, (or v4i32:$vB, v4i32:$vC))), 135>;
+    def : xxevalPattern<v4i32, (vnot (xor v4i32:$vA, (or v4i32:$vB, v4i32:$vC))), 135>;
 
     // NOR
     // (nor A, B, C)
-    def : XXEvalPattern<v4i32, (vnot (or v4i32:$vA, (or v4i32:$vB, v4i32:$vC))), 128>;
+    def : xxevalPattern<v4i32, (vnot (or v4i32:$vA, (or v4i32:$vB, v4i32:$vC))), 128>;
     // (nor A, (and B, C))
-    def : XXEvalPattern<v4i32, (vnot (or v4i32:$vA, (and v4i32:$vB, v4i32:$vC))), 224>;
+    def : xxevalPattern<v4i32, (vnot (or v4i32:$vA, (and v4i32:$vB, v4i32:$vC))), 224>;
     // (nor A, (eqv B, C))
-    def : XXEvalPattern<v4i32, (and (vnot v4i32:$vA), (xor v4i32:$vB, v4i32:$vC)), 96>;
+    def : xxevalPattern<v4i32, (and (vnot v4i32:$vA), (xor v4i32:$vB, v4i32:$vC)), 96>;
     // (nor A, (nand B, C))
-    def : XXEvalPattern<v4i32, (and (vnot v4i32:$vA), (and v4i32:$vB, v4i32:$vC)), 16>;
+    def : xxevalPattern<v4i32, (and (vnot v4i32:$vA), (and v4i32:$vB, v4i32:$vC)), 16>;
     // (nor A, (nor B, C))
-    def : XXEvalPattern<v4i32, (and (vnot v4i32:$vA), (or v4i32:$vB, v4i32:$vC)), 112>;
+    def : xxevalPattern<v4i32, (and (vnot v4i32:$vA), (or v4i32:$vB, v4i32:$vC)), 112>;
     // (nor A, (xor B, C))
-    def : XXEvalPattern<v4i32, (vnot (or v4i32:$vA, (xor v4i32:$vB, v4i32:$vC))), 144>;
+    def : xxevalPattern<v4i32, (vnot (or v4i32:$vA, (xor v4i32:$vB, v4i32:$vC))), 144>;
 
     // OR
     // (or A, B, C)
-    def : XXEvalPattern<v4i32, (or v4i32:$vA, (or v4i32:$vB, v4i32:$vC)), 127>;
+    def : xxevalPattern<v4i32, (or v4i32:$vA, (or v4i32:$vB, v4i32:$vC)), 127>;
     // (or A, (and B, C))
-    def : XXEvalPattern<v4i32, (or v4i32:$vA, (and v4i32:$vB, v4i32:$vC)), 31>;
+    def : xxevalPattern<v4i32, (or v4i32:$vA, (and v4i32:$vB, v4i32:$vC)), 31>;
     // (or A, (eqv B, C))
-    def : XXEvalPattern<v4i32, (or v4i32:$vA, (vnot (xor v4i32:$vB, v4i32:$vC))), 159>;
+    def : xxevalPattern<v4i32, (or v4i32:$vA, (vnot (xor v4i32:$vB, v4i32:$vC))), 159>;
     // (or A, (nand B, C))
-    def : XXEvalPattern<v4i32, (or v4i32:$vA, (vnot (and v4i32:$vB, v4i32:$vC))), 239>;
+    def : xxevalPattern<v4i32, (or v4i32:$vA, (vnot (and v4i32:$vB, v4i32:$vC))), 239>;
     // (or A, (nor B, C))
-    def : XXEvalPattern<v4i32, (or v4i32:$vA, (vnot (or v4i32:$vB, v4i32:$vC))), 143>;
+    def : xxevalPattern<v4i32, (or v4i32:$vA, (vnot (or v4i32:$vB, v4i32:$vC))), 143>;
     // (or A, (xor B, C))
-    def : XXEvalPattern<v4i32, (or v4i32:$vA, (xor v4i32:$vB, v4i32:$vC)), 111>;
+    def : xxevalPattern<v4i32, (or v4i32:$vA, (xor v4i32:$vB, v4i32:$vC)), 111>;
 
     // XOR
     // (xor A, B, C)
-    def : XXEvalPattern<v4i32, (xor v4i32:$vA, (xor v4i32:$vB, v4i32:$vC)), 105>;
+    def : xxevalPattern<v4i32, (xor v4i32:$vA, (xor v4i32:$vB, v4i32:$vC)), 105>;
     // (xor A, (and B, C))
-    def : XXEvalPattern<v4i32, (xor v4i32:$vA, (and v4i32:$vB, v4i32:$vC)), 30>;
+    def : xxevalPattern<v4i32, (xor v4i32:$vA, (and v4i32:$vB, v4i32:$vC)), 30>;
     // (xor A, (or B, C))
-    def : XXEvalPattern<v4i32, (xor v4i32:$vA, (or v4i32:$vB, v4i32:$vC)), 120>;
+    def : xxevalPattern<v4i32, (xor v4i32:$vA, (or v4i32:$vB, v4i32:$vC)), 120>;
 
     // Utilize xxeval instruction for ternary vector expressions.
     defm : XXEvalVSelectWithXAnd<v4i32, 22>;