[Clang] [TableGen] Clean up !if(!eq(boolean, 1) and related booleans

[Paul-C-Anagnostopoulos]

Summary

This patch continues the cleanup of booleans in TableGen files, now that the !not operator has been added.

Note that in this patch an int template argument has been changed to a bit.

I will auto-LGTM this after 24 hours.

[dblaikie]

@lattner minor detail/annoyance: Phabricator doesn't email the mailing lists if a review is "approved" with no comments. To ensure the approval is recorded on the list, please include some text (a stub "." would suffice, but folks usually go with "Thanks!" or similar) - otherwise it looks sort of like patches are being committed without review, if you're just reading the mailing list.
@mehdi_amini: Any chance this might be fixable on the Phab side?

[lattner]

Oops, thanks for the head's up @dblaikie !

[Paul-C-Anagnostopoulos]

I'll remember this, too.

@dblaikie How did you happen to notice?

[dblaikie]

In D89893#2357480, @Paul-C-Anagnostopoulos wrote:

I'll remember this, too.

@dblaikie How did you happen to notice?

Reading the mailing list & seeing the phab review and commit without any emails from anyone else in the review thread, so far as the email list/my mail client were concerned.

clang/include/clang/Basic/arm_mve.td

 
 // Plain intrinsics
 let params = T.Usual in {
 def vabdq: Intrinsic<Vector, (args Vector:$a, Vector:$b),
                      (IRInt<"vabd", [Vector]> $a, $b, (unsignedflag Scalar))>;
 }
 
 multiclass VectorVectorArithmetic<string operation, dag extraArgs = (?),
-                                  int wantXVariant = 1> {
+                                  bit wantXVariant = 1> {
   defm "" : IntrinsicMX<
       Vector, (args Vector:$a, Vector:$b, Predicate:$pred),
       !con((IRInt<operation, [Vector, Predicate]> $a, $b),
            extraArgs, (? $pred, $inactive)), wantXVariant>;
 }
 
 multiclass VectorScalarArithmetic<string operation, string basename,
                                   dag extraArgs = (?),
-                                  int wantXVariant = 1> {
+                                  bit wantXVariant = 1> {
   defm "" : IntrinsicMXNameOverride<
       Vector, (args Vector:$a, unpromoted<Scalar>:$b, Predicate:$pred),
       !con((IRInt<operation, [Vector, Predicate]> $a, (splat $b)),
            extraArgs, (? $pred, $inactive)), basename, wantXVariant, "_n",
            PNT_NType, PNT_NType>;
 }
 
 multiclass VectorVectorArithmeticBitcast<string operation> {
let params = T.Usual in {
   defm vorrq : VectorVectorArithmeticBitcast<"orr_predicated">;
 
   defm : VectorScalarArithmetic<"add_predicated", "vaddq">;
   defm : VectorScalarArithmetic<"sub_predicated", "vsubq">;
   defm : VectorScalarArithmetic<"mul_predicated", "vmulq">;
 }
 
 multiclass DblVectorVectorArithmetic<string operation, dag extraArgs = (?),
-                                     int wantXVariant = 1> {
+                                     bit wantXVariant = 1> {
   defm "" : IntrinsicMX<
       DblVector, (args Vector:$a, Vector:$b, DblPredicate:$pred),
       !con((IRInt<operation, [DblVector, Vector, DblPredicate]> $a, $b),
            extraArgs, (? $pred, $inactive)), wantXVariant>;
 }
 
 multiclass DblVectorScalarArithmetic<string operation, string basename,
                                      dag extraArgs = (?),
-                                     int wantXVariant = 1> {
+                                     bit wantXVariant = 1> {
   defm "" : IntrinsicMXNameOverride<
       DblVector, (args Vector:$a, unpromoted<Scalar>:$b, DblPredicate:$pred),
       !con((IRInt<operation, [DblVector, Vector, DblPredicate]> $a, (splat $b)),
            extraArgs, (? $pred, $inactive)), basename, wantXVariant, "_n",
            PNT_NType, PNT_NType>;
 }
 
 // Predicated intrinsics - Int types only

clang/include/clang/Basic/arm_mve_defs.td

 // A wrapper to define both _m and _x versions of a predicated
 // intrinsic.
 //
 // We provide optional parameters to override the polymorphic name
 // types separately for the _m and _x variants, because sometimes they
 // polymorph differently (typically because the type of the inactive
 // parameter can be used as a disambiguator if it's present).
 multiclass IntrinsicMX<Type rettype, dag arguments, dag cg,
-                       int wantXVariant = 1,
+                       bit wantXVariant = 1,
                        string nameSuffix = "",
                        PolymorphicNameType pnt_m = PNT_Type,
                        PolymorphicNameType pnt_x = PNT_Type> {
   // The _m variant takes an initial parameter called $inactive, which
   // provides the input value of the output register, i.e. all the
   // inactive lanes in the predicated operation take their values from
   // this.
   def : Intrinsic<rettype, !con((args rettype:$inactive), arguments), cg>,
         NameOverride<NAME # "_m" # nameSuffix> {
     let pnt = pnt_m;
   }
 
-  foreach unusedVar = !if(!eq(wantXVariant, 1), [1], []<int>) in {
+  if wantXVariant then {
     // The _x variant leaves off that parameter, and simply uses an
     // undef value of the same type.
 
     def : Intrinsic<rettype, arguments, (seq (undef rettype):$inactive, cg)>,
           NameOverride<NAME # "_x" # nameSuffix> {
       let pnt = pnt_x;
     }
   }
 }
 
 // Same as above, but with an additional parameter 'basename' which overrides
 // the C intrinsic base name
 multiclass IntrinsicMXNameOverride<Type rettype, dag arguments, dag cg,
-                                   string basename, int wantXVariant = 1,
+                                   string basename, bit wantXVariant = 1,
                                    string nameSuffix = "",
                                    PolymorphicNameType pnt_m = PNT_Type,
                                    PolymorphicNameType pnt_x = PNT_Type> {
   def "_m" # nameSuffix:
      Intrinsic<rettype, !con((args rettype:$inactive), arguments), cg>,
      NameOverride<basename # "_m" # nameSuffix> {
     let pnt = pnt_m;
   }
 
-  foreach unusedVar = !if(!eq(wantXVariant, 1), [1], []<int>) in {
+  if wantXVariant then {
     def "_x" # nameSuffix:
       Intrinsic<rettype, arguments, (seq (undef rettype):$inactive, cg)>,
       NameOverride<basename # "_x" # nameSuffix> {
       let pnt = pnt_x;
     }
   }
 }