llvm.lround: Update verifier to validate support of vector types.

llvm/docs/LangRef.rst

@@ -16606,7 +16606,8 @@ Syntax:
 """""""
 
 This is an overloaded intrinsic. You can use ``llvm.lround`` on any
-floating-point type. Not all targets support all types however.
+floating-point type or vector of floating-point type. Not all targets
+support all types however.
 
 ::
 

llvm/lib/CodeGen/MachineVerifier.cpp

@@ -2032,7 +2032,20 @@ void MachineVerifier::verifyPreISelGenericInstruction(const MachineInstr *MI) {
   }
   case TargetOpcode::G_LLROUND:
   case TargetOpcode::G_LROUND: {
-    verifyAllRegOpsScalar(*MI, *MRI);
+    LLT DstTy = MRI->getType(MI->getOperand(0).getReg());
+    LLT SrcTy = MRI->getType(MI->getOperand(1).getReg());
+    if (!DstTy.isValid() || !SrcTy.isValid())
+      break;
+    if (SrcTy.isPointer() || DstTy.isPointer()) {
+      StringRef Op = SrcTy.isPointer() ? "Source" : "Destination";
+      report(Twine(Op, " operand must not be a pointer type"), MI);
+    } else if (SrcTy.isScalar()) {
+      verifyAllRegOpsScalar(*MI, *MRI);
+      break;
+    } else if (SrcTy.isVector()) {
+      verifyVectorElementMatch(SrcTy, DstTy, MI);
+      break;
+    }
     break;
   }
   case TargetOpcode::G_IS_FPCLASS: {

llvm/lib/IR/Verifier.cpp

@@ -5963,8 +5963,22 @@ void Verifier::visitIntrinsicCall(Intrinsic::ID ID, CallBase &Call) {
   case Intrinsic::llround: {
     Type *ValTy = Call.getArgOperand(0)->getType();
     Type *ResultTy = Call.getType();
-    Check(!ValTy->isVectorTy() && !ResultTy->isVectorTy(),
-          "Intrinsic does not support vectors", &Call);
+    auto *VTy = dyn_cast<VectorType>(ValTy);
+    auto *RTy = dyn_cast<VectorType>(ResultTy);
+    Check(
+        ValTy->isFPOrFPVectorTy() && ResultTy->isIntOrIntVectorTy(),
+        "llvm.lround, llvm.llround: argument must be floating-point or vector "
+        "of floating-points, and result must be integer or vector of integers",
+        &Call);
+    Check(
+        ValTy->isVectorTy() == ResultTy->isVectorTy(),
+        "llvm.lround, llvm.llround: argument and result disagree on vector use",
+        &Call);
+    if (VTy) {
+      Check(VTy->getElementCount() == RTy->getElementCount(),
+            "llvm.lround, llvm.llround: argument must be same length as result",
+            &Call);
+    }
     break;
   }
   case Intrinsic::bswap: {

llvm/test/Assembler/lround.ll

@@ -0,0 +1,26 @@
+; Validate that vector types are accepted for llvm.lround/llvm.llround intrinsic
+; RUN: llvm-as < %s | llvm-dis |  FileCheck %s
+
+define <2 x i32> @intrinsic_lround_v2i32_v2f32(<2 x float> %arg) {
+  ;CHECK: %res = tail call <2 x i32> @llvm.lround.v2i32.v2f32(<2 x float> %arg)
+  %res = tail call <2 x i32> @llvm.lround.v2i32.v2f32(<2 x float> %arg)
+  ret <2 x i32> %res
+}
+
+define <2 x i32> @intrinsic_llround_v2i32_v2f32(<2 x float> %arg) {
+  ;CHECK: %res = tail call <2 x i32> @llvm.llround.v2i32.v2f32(<2 x float> %arg)
+  %res = tail call <2 x i32> @llvm.llround.v2i32.v2f32(<2 x float> %arg)
+  ret <2 x i32> %res
+}
+
+define <2 x i64> @intrinsic_lround_v2i64_v2f32(<2 x float> %arg) {
+  ;CHECK: %res = tail call <2 x i64> @llvm.lround.v2i64.v2f32(<2 x float> %arg)
+  %res = tail call <2 x i64> @llvm.lround.v2i64.v2f32(<2 x float> %arg)
+  ret <2 x i64> %res
+}
+
+define <2 x i64> @intrinsic_llround_v2i64_v2f32(<2 x float> %arg) {
+  ;CHECK: %res = tail call <2 x i64> @llvm.llround.v2i64.v2f32(<2 x float> %arg)
+  %res = tail call <2 x i64> @llvm.llround.v2i64.v2f32(<2 x float> %arg)
+  ret <2 x i64> %res
+}

llvm/test/MachineVerifier/test_g_llround.mir

@@ -14,10 +14,14 @@ body:             |
     %ptr:_(p0) = COPY $x0
     %vector:_(<2 x s64>) = COPY $q0
 
-    ; CHECK: Bad machine code: All register operands must have scalar types
-    ; CHECK: instruction: %no_ptrs:_(s64) = G_LROUND %ptr:_(p0)
-    %no_ptrs:_(s64) = G_LROUND %ptr:_(p0)
+    ; CHECK: Bad machine code: Source operand must not be a pointer type
+    ; CHECK: instruction: %no_ptrs:_(s32) = G_LLROUND %ptr:_(p0)
+    %no_ptrs:_(s32) = G_LLROUND %ptr:_(p0)
 
-    ; CHECK: Bad machine code: All register operands must have scalar types
-    ; CHECK: instruction: %no_vectors:_(s64) = G_LROUND %vector:_(<2 x s64>)
-    %no_vectors:_(s64) = G_LROUND %vector:_(<2 x s64>)
+    ; CHECK: Bad machine code: operand types must be all-vector or all-scalar
+    ; CHECK: instruction: %no_vectors:_(s32) = G_LLROUND %vector:_(<2 x s64>)
+    %no_vectors:_(s32) = G_LLROUND %vector:_(<2 x s64>)
+
+    ; CHECK: Bad machine code: operand types must preserve number of vector elements
+    ; CHECK: instruction: %inv_vectors:_(<3 x s32>) = G_LLROUND %vector:_(<2 x s64>)
+    %inv_vectors:_(<3 x s32>) = G_LLROUND %vector:_(<2 x s64>)

llvm/test/MachineVerifier/test_g_lround.mir

@@ -14,10 +14,14 @@ body:             |
     %ptr:_(p0) = COPY $x0
     %vector:_(<2 x s64>) = COPY $q0
 
-    ; CHECK: Bad machine code: All register operands must have scalar types
+    ; CHECK: Bad machine code: Source operand must not be a pointer type
     ; CHECK: instruction: %no_ptrs:_(s32) = G_LROUND %ptr:_(p0)
     %no_ptrs:_(s32) = G_LROUND %ptr:_(p0)
 
-    ; CHECK: Bad machine code: All register operands must have scalar types
+    ; CHECK: Bad machine code: operand types must be all-vector or all-scalar
     ; CHECK: instruction: %no_vectors:_(s32) = G_LROUND %vector:_(<2 x s64>)
     %no_vectors:_(s32) = G_LROUND %vector:_(<2 x s64>)
+
+    ; CHECK: Bad machine code: operand types must preserve number of vector elements
+    ; CHECK: instruction: %inv_vectors:_(<3 x s32>) = G_LROUND %vector:_(<2 x s64>)
+    %inv_vectors:_(<3 x s32>) = G_LROUND %vector:_(<2 x s64>)