[ARM] Keeping sign information on bitcasts for Neon vdot_lane intrinsics

[pratlucas]

Summary

Sign information was being lost on Neon's vdot_lane intrinsics arguments
when bitcasting explicitly to uint32 vector types. This patch introduces
a new cast option to allow casting the operand to the equivalent vector
type of 32-bit integers, keeping the sign information.

[dnsampaio]

Is this missing a test?

[pratlucas]

This patch by itself is a NFC. It aims to enable the proper overload resolution of intrinsic calls when using the call_mangled operation introduced on D74618.
To make this more clear, I'll discard this review and merge this changes into D74619, where call_mangled gets used.

clang/include/clang/Basic/arm_neon.td

def OP_SCALAR_HALF_SET_LN : Op<(bitcast "float16x4_t",
                                          (bitcast "int16x4_t", $p1), $p2))>;
 def OP_SCALAR_HALF_SET_LNQ : Op<(bitcast "float16x8_t",
                                     (call "vset_lane",
                                           (bitcast "int16_t", $p0),
                                           (bitcast "int16x8_t", $p1), $p2))>;
 
 def OP_DOT_LN
     : Op<(call "vdot", $p0, $p1,
-          (bitcast $p1, (splat(bitcast "uint32x2_t", $p2), $p3)))>;
+          (bitcast $p1, (splat(bitcast "32", $p2), $p3)))>;
 def OP_DOT_LNQ
     : Op<(call "vdot", $p0, $p1,
-          (bitcast $p1, (splat(bitcast "uint32x4_t", $p2), $p3)))>;
+          (bitcast $p1, (splat(bitcast "32", $p2), $p3)))>;
 
 def OP_FMLAL_LN     : Op<(call "vfmlal_low", $p0, $p1,
                            (dup_typed $p1, (call "vget_lane", $p2, $p3)))>;
 def OP_FMLSL_LN     : Op<(call "vfmlsl_low", $p0, $p1,
                            (dup_typed $p1, (call "vget_lane", $p2, $p3)))>;
 def OP_FMLAL_LN_Hi  : Op<(call "vfmlal_high", $p0, $p1,
                            (dup_typed $p1, (call "vget_lane", $p2, $p3)))>;
 def OP_FMLSL_LN_Hi  : Op<(call "vfmlsl_high", $p0, $p1,
let ArchGuard = "defined(__ARM_FEATURE_COMPLEX)" in {
   def VCADD_ROT270  : SInst<"vcadd_rot270", "...", "f">;
   def VCADDQ_ROT90  : SInst<"vcaddq_rot90", "QQQ", "f">;
   def VCADDQ_ROT270 : SInst<"vcaddq_rot270", "QQQ", "f">;
 }
 let ArchGuard = "defined(__ARM_FEATURE_COMPLEX) && defined(__aarch64__)" in {
   def VCADDQ_ROT90_FP64  : SInst<"vcaddq_rot90", "QQQ", "d">;
   def VCADDQ_ROT270_FP64 : SInst<"vcaddq_rot270", "QQQ", "d">;
 }
 No newline at end of file

clang/include/clang/Basic/arm_neon_incl.td

 //          - A typedef string - A NEON or stdint.h type that is then parsed.
 //                               for example: (cast "uint32x4_t", $p0).
 //          - "U" - Make the type unsigned.
 //          - "S" - Make the type signed.
 //          - "H" - Halve the number of lanes in the type.
 //          - "D" - Double the number of lanes in the type.
 //          - "8" - Convert type to an equivalent vector of 8-bit signed
 //                  integers.
+//          - "32" - Convert type to an equivalent vector of 32-bit integers.
 // example: (cast "R", "U", $p0) -> "(uint32x4_t)__p0" (assuming the return
 //           value is of type "int32x4_t".
 //          (cast $p0, "D", "8", $p1) -> "(int8x16_t)__p1" (assuming __p0
 //           has type float64x1_t or any other vector type of 64 bits).
 //          (cast "int32_t", $p2) -> "(int32_t)__p2"
 def cast;
 // bitcast - Same as "cast", except a reinterpret-cast is produced:
 //             (bitcast "T", $p0) -> "*(T*)&__p0".

clang/utils/TableGen/NeonEmitter.cpp

void makeScalar() {
     NumVectors = 0;
   }
 
   void makeOneVector() {
     assert(isVector());
     NumVectors = 1;
   }
 
+  void make32BitElement() {
+    assert_with_loc(Bitwidth > 32, "Not enough bits to make it 32!");
+    ElementBitwidth = 32;
+  }
+
   void doubleLanes() {
     assert_with_loc(Bitwidth != 128, "Can't get bigger than 128!");
     Bitwidth = 128;
   }
 
   void halveLanes() {
     assert_with_loc(Bitwidth != 64, "Can't get smaller than 64!");
     Bitwidth = 64;
if (!DI->getArgNameStr(ArgIdx).empty()) {
       } else if (SI->getAsUnquotedString() == "S") {
         castToType.makeSigned();
       } else if (SI->getAsUnquotedString() == "H") {
         castToType.halveLanes();
       } else if (SI->getAsUnquotedString() == "D") {
         castToType.doubleLanes();
       } else if (SI->getAsUnquotedString() == "8") {
         castToType.makeInteger(8, true);
+      } else if (SI->getAsUnquotedString() == "32") {
+        castToType.make32BitElement();
       } else {
         castToType = Type::fromTypedefName(SI->getAsUnquotedString());
         assert_with_loc(!castToType.isVoid(), "Unknown typedef");
       }
     }
   }
 
   std::string S;