[TableGen] [Clang] Clean up arm_mve.td file

[Paul-C-Anagnostopoulos]

Summary

This patch does a little cleanup on the arm_mve.td TableGen file.

Could someone give me suggestions on how to test this? It builds fine, but I'm not sure how to test it. Of course, I will make sure that the resulting .inc files don't change. Anything else?

[dmgreen]

Testing the inc files sounds good to me. There are also tests in places like clang/test/CodeGen/arm-mve-intrinsics that will test this, which seem to all be passing? Anything that does #include <arm_mve.h>

[simon_tatham]

For this kind of pure refactoring on a .td file, my usual approach to testing it is to run the file through Tablegen without any output option (i.e. just in the default -print-records mode), before and after the change. In this case, I'd think, you ought to be able to expect bit-for-bit identical output – and if you get it, then you can be pretty confident that all the directly useful output modes won't have changed either.

[simon_tatham]

For example, that's how I tested the refactoring in D72690.

[craig.topper]

clang/include/clang/Basic/arm_mve.td

579

Did you intend to leave the old lines commented out?

[Paul-C-Anagnostopoulos]

clang/include/clang/Basic/arm_mve.td

579

Just for the first review, in case anyone found anything crazy. I'll remove them when I update the review.

[Paul-C-Anagnostopoulos]

The arm_*.inc files do not change with this revision.

I removed the commented-out code.

[Paul-C-Anagnostopoulos]

One must amend the commit when one makes changes to the files.

[simon_tatham]

clang/include/clang/Basic/arm_mve.td

1530–1531

If you've removed my unreadable foldl then you can also safely remove the comment in which I had to explain what it means :-)

[Paul-C-Anagnostopoulos]

clang/include/clang/Basic/arm_mve.td

1530–1531

Will do!

[Paul-C-Anagnostopoulos]

Could I get an LGTM on this? I have removed the spurious comment.

[jansvoboda11]

LGTM provided the output file stays the same.

[dmgreen]

Sorry. I think we were waiting for the foldl comment to be removed. If you remove that, this LGTM.

[Paul-C-Anagnostopoulos]

Sorry, I removed it but didn't update this review. All set now.

clang/include/clang/Basic/arm_mve.td

 let params = T.Float in {
 defm vminnmvq: Reduction<Scalar, "minnmv", [Scalar, Vector]>;
 defm vmaxnmvq: Reduction<Scalar, "maxnmv", [Scalar, Vector]>;
 defm vminnmavq: Reduction<Scalar, "minnmav", [Scalar, Vector]>;
 defm vmaxnmavq: Reduction<Scalar, "maxnmav", [Scalar, Vector]>;
 }
 
 foreach half = [ "b", "t" ] in {
-  defvar halfconst = !if(!eq(half, "b"), 0, 1);
+  defvar halfconst = !ne(half, "b");
 
   let params = [f32], pnt = PNT_None in {
     def vcvt#half#q_f16: Intrinsic<
       VecOf<f16>, (args VecOf<f16>:$inactive, Vector:$a),
       (IRInt<"vcvt_narrow"> $inactive, $a, halfconst)>;
     def vcvt#half#q_m_f16: Intrinsic<
       VecOf<f16>, (args VecOf<f16>:$inactive, Vector:$a, PredOf<f32>:$pred),
       (IRInt<"vcvt_narrow_predicated"> $inactive, $a, halfconst, $pred)>;
   } // params = [f32], pnt = PNT_None
defm "": IntrinsicMX<DblVector, (args Vector:$v, imm_1toN:$sh,
             $v, $sh, (unsignedflag Scalar), top, $pred, $inactive), 1, "_n">;
   }
 }
 defm vshllbq : vshll_imm<0>;
 defm vshlltq : vshll_imm<1>;
 
 multiclass DyadicImmShift<Type outtype, Immediate imm, string intname = NAME,
                           dag extraargs = (?)> {
-  defvar intparams = !if(!eq(!cast<string>(outtype), !cast<string>(Vector)),
-                         [Vector], [outtype, Vector]);
+  defvar intparams = !if(!eq(outtype, Vector), [Vector], [outtype, Vector]);
 
   def q_n: Intrinsic<
       outtype, (args outtype:$a, Vector:$b, imm:$sh),
       !con((IRInt<intname, intparams> $a, $b, $sh), extraargs)>;
 
   def q_m_n: Intrinsic<
       outtype, (args outtype:$a, Vector:$b, imm:$sh, Predicate:$pred),
       !con((IRInt<intname # "_predicated", intparams # [Predicate]>

 }
 let params = T.Usual in {
   def vrev64q : Intrinsic<Vector, (args Vector:$a), (vrev $a, 64)>;
   defm vrev64q: vrev_predicated<64>;
 }
 
 foreach desttype = T.All in {
   // We want a vreinterpretq between every pair of supported vector types
   // _except_ that there shouldn't be one from a type to itself.
-  //
-  // So this foldl expression implements what you'd write in Python as
-  // [srctype for srctype in T.All if srctype != desttype]
-  let params = !foldl([]<Type>, T.All, tlist, srctype, !listconcat(tlist,
-      !if(!eq(!cast<string>(desttype),!cast<string>(srctype)),[],[srctype])))
-  in {
+  let params = !filter(srctype, T.All, !ne(srctype, desttype)) in {
     def "vreinterpretq_" # desttype: Intrinsic<
         VecOf<desttype>, (args Vector:$x), (vreinterpret $x, VecOf<desttype>)>;
   }
 }
 
 let params = T.All in {
   let pnt = PNT_None in {
     def vcreateq: Intrinsic<Vector, (args u64:$a, u64:$b),
let params = T.All in {
   def vsetq_lane: Intrinsic<Vector, (args unpromoted<Scalar>:$e, Vector:$v, imm_lane:$lane),
                             (ielt_var $v, $e, $lane)>;
 }
 
 foreach desttype = !listconcat(T.Int16, T.Int32, T.Float) in {
   defvar is_dest_float = !eq(desttype.kind, "f");
   defvar is_dest_unsigned = !eq(desttype.kind, "u");
   // First immediate operand of the LLVM intrinsic
-  defvar unsigned_flag = !if(is_dest_float, (unsignedflag Scalar),
-                             !if(is_dest_unsigned, V.True, V.False));
+  defvar unsigned_flag = !cond(is_dest_float: (unsignedflag Scalar),
+                               is_dest_unsigned: V.True,
+                               true: V.False);
   // For float->int conversions _n and _x_n intrinsics are not polymorphic
   // because the signedness of the destination type cannot be inferred.
   defvar pnt_nx = !if(is_dest_float, PNT_2Type, PNT_None);
 
   let params = !if(is_dest_float,
                    !if(!eq(desttype.size, 16), T.Int16, T.Int32),
                    !if(!eq(desttype.size, 16), [f16], [f32])) in {
     let pnt = pnt_nx in