[ARM] Fixing range checks for Neon's vqdmulhq_lane and vqrdmulhq_lane intrinsics

[pratlucas]

Summary

The range checks performed for the vqrdmulh_lane and vqrdmulh_lane Neon
intrinsics were incorrectly using their return type as the base type for
the range check performed on their 'lane' argument.

This patch updates those intrisics to use the type of the proper reference
argument to perform the range checks.

[dnsampaio]

clang/test/CodeGen/arm-neon-range-checks.c

284–285

As the previous one, could we have it testing the actual ranges?

[pratlucas]

Adding check for valid range on tests.

[pratlucas]

Clang-format.

[dnsampaio]

LGTM

clang/include/clang/Basic/arm_neon.td

 def VQDMULH_N     : SOpInst<"vqdmulh_n", "..1", "siQsQi", OP_QDMULH_N>;
 def VQRDMULH_N    : SOpInst<"vqrdmulh_n", "..1", "siQsQi", OP_QRDMULH_N>;
 
 let ArchGuard = "!defined(__aarch64__)" in {
 def VQDMULH_LANE  : SOpInst<"vqdmulh_lane", "..qI", "siQsQi", OP_QDMULH_LN>;
 def VQRDMULH_LANE : SOpInst<"vqrdmulh_lane", "..qI", "siQsQi", OP_QRDMULH_LN>;
 }
 let ArchGuard = "defined(__aarch64__)" in {
-def A64_VQDMULH_LANE  : SInst<"vqdmulh_lane", "..qI", "siQsQi">;
-def A64_VQRDMULH_LANE : SInst<"vqrdmulh_lane", "..qI", "siQsQi">;
+def A64_VQDMULH_LANE  : SInst<"vqdmulh_lane", "..(!q)I", "siQsQi">;
+def A64_VQRDMULH_LANE : SInst<"vqrdmulh_lane", "..(!q)I", "siQsQi">;
 }
 
 let ArchGuard = "defined(__ARM_FEATURE_QRDMX)" in {
 def VQRDMLAH_LANE : SOpInst<"vqrdmlah_lane", "...qI", "siQsQi", OP_QRDMLAH_LN>;
 def VQRDMLSH_LANE : SOpInst<"vqrdmlsh_lane", "...qI", "siQsQi", OP_QRDMLSH_LN>;
 }
 
 def VMLA_N        : IOpInst<"vmla_n", "...1", "siUsUifQsQiQUsQUiQf", OP_MLA_N>;
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/lib/CodeGen/CGBuiltin.cpp

Ops[1] =
         EmitNeonCall(CGM.getIntrinsic(LLVMIntrinsic, Ty), MulOps, "vqdmlal");
     Ops.resize(2);
     return EmitNeonCall(CGM.getIntrinsic(AltLLVMIntrinsic, Ty), Ops, NameHint);
   }
   case NEON::BI__builtin_neon_vqdmulhq_lane_v:
   case NEON::BI__builtin_neon_vqdmulh_lane_v:
   case NEON::BI__builtin_neon_vqrdmulhq_lane_v:
   case NEON::BI__builtin_neon_vqrdmulh_lane_v: {
+    llvm::Type* RTy = Ty;
+    if (BuiltinID == NEON::BI__builtin_neon_vqdmulhq_lane_v ||
+        BuiltinID == NEON::BI__builtin_neon_vqrdmulhq_lane_v)
+      RTy = llvm::VectorType::get(Ty->getVectorElementType(), Ty->getVectorNumElements() * 2);
     llvm::Type *Tys[2] = {
-        Ty, GetNeonType(this, NeonTypeFlags(Type.getEltType(), false,
+        RTy, GetNeonType(this, NeonTypeFlags(Type.getEltType(), false,
                                             /*isQuad*/ false))};
     return EmitNeonCall(CGM.getIntrinsic(Int, Tys), Ops, NameHint);
   }
   case NEON::BI__builtin_neon_vqdmulhq_laneq_v:
   case NEON::BI__builtin_neon_vqdmulh_laneq_v:
   case NEON::BI__builtin_neon_vqrdmulhq_laneq_v:
   case NEON::BI__builtin_neon_vqrdmulh_laneq_v: {
     llvm::Type *Tys[2] = {

clang/test/CodeGen/arm-neon-range-checks.c

 
 void test_vqdmulh_lane(int32x2_t a, int32x2_t b) {
   vqdmulh_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range}}
   vqdmulh_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range}}
   vqdmulh_lane_s32(a, b, 0);
   vqdmulh_lane_s32(a, b, 1);
 }
 
+void test_vqdmulhq_lane(int32x4_t a, int32x2_t b) {
+  vqdmulhq_lane_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range}}
+  vqdmulhq_lane_s32(a, b, 2); // expected-error {{argument value 2 is outside the valid range}}
+  vqdmulhq_lane_s32(a, b, 0);
+  vqdmulhq_lane_s32(a, b, 1);
+}
+
 #if defined(__aarch64__)
 void test_vqdmulh_laneq(int32x2_t a, int32x4_t b) {
   vqdmulh_laneq_s32(a, b, -1); // expected-error {{argument value -1 is outside the valid range}}
   vqdmulh_laneq_s32(a, b, 4); // expected-error {{argument value 4 is outside the valid range}}
   vqdmulh_laneq_s32(a, b, 0);
   vqdmulh_laneq_s32(a, b, 3);
 }
 

 
 void test_vqrdmulh_lane(int32x2_t a, int32x2_t v) {
   vqrdmulh_lane_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range}}
   vqrdmulh_lane_s32(a, v,  2); // expected-error {{argument value 2 is outside the valid range}}
   vqrdmulh_lane_s32(a, v,  0);
   vqrdmulh_lane_s32(a, v,  1);
 }
 
+void test_vqrdmulhq_lane(int32x4_t a, int32x2_t v) {
+  vqrdmulhq_lane_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range}}
+  vqrdmulhq_lane_s32(a, v,  2); // expected-error {{argument value 2 is outside the valid range}}
+  vqrdmulhq_lane_s32(a, v,  0);
+  vqrdmulhq_lane_s32(a, v,  1);
+}
+
 #if defined(__aarch64__)
 void test_vqrdmulh_laneq(int32x2_t a, int32x4_t v) {
   vqrdmulh_laneq_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range}}
   vqrdmulh_laneq_s32(a, v,  4); // expected-error {{argument value 4 is outside the valid range}}
   vqrdmulh_laneq_s32(a, v,  0);
   vqrdmulh_laneq_s32(a, v,  3);
 }
 
 void test_vqrdmulhq_laneq(int32x4_t a, int32x4_t v) {
   vqrdmulhq_laneq_s32(a, v,  -1); // expected-error {{argument value -1 is outside the valid range}}
   vqrdmulhq_laneq_s32(a, v,  4); // expected-error {{argument value 4 is outside the valid range}}
   vqrdmulhq_laneq_s32(a, v,  0);
   vqrdmulhq_laneq_s32(a, v,  3);
 }
 #endif