[clang][RISCV] Support operators for RVV sizeless vector types

[jacquesguan]

Summary

This patch supports arithmetic, bitwise logical, compare, shift and subscript operators for RVV sizeless vector types.

[craig.topper]

clang/lib/Sema/SemaChecking.cpp

14915

Why do we need this, but SVE doesn't?

clang/lib/Sema/SemaExpr.cpp

12293

This code looks identical to the code above it.

16314

Update "SVE" to mention "RVV" too?

[jacquesguan]

Address comment

[jacquesguan]

fix if statement

[jacquesguan]

clang/lib/Sema/SemaChecking.cpp

14915

Merged with the former sve function.

clang/lib/Sema/SemaExpr.cpp

12293

Removed.

16314

Done.

[jacquesguan]

fix test cases

[Jim]

clang/test/CodeGen/riscv-rvv-vla-arith-ops.c

3

zve64d has implied f and d.

90

Do we support operation for vfloat16 here?

[Jim]

clang/test/CodeGen/riscv-rvv-vla-arith-ops.c

3

I misunderstand it. Please ignore the comment.

[jacquesguan]

add fp16 cases.

[jacquesguan]

clang/test/CodeGen/riscv-rvv-vla-arith-ops.c

90

Thanks to point it. I added fp16 vector cases.

[jacquesguan]

ping.

[craig.topper]

Need to update the table here https://clang.llvm.org/docs/LanguageExtensions.html#vector-operations to include RVV

[jacquesguan]

Update doc

clang/include/clang/AST/Type.h

public:
   /// RVV vector or mask.
   bool isRVVVLSBuiltinType() const;
 
   /// Returns the representative type for the element of an RVV builtin type.
   /// This is used to represent fixed-length RVV vectors created with the
   /// 'riscv_rvv_vector_bits' type attribute as VectorType.
   QualType getRVVEltType(const ASTContext &Ctx) const;
 
+  /// Determines if this is a sizeless type supported by the VLST defined
+  /// attribute.
+  bool isVLSBuiltinType() const;
+
+  /// Returns the representative type for the element of an SVE builtin type.
+  /// This is used to represent fixed-length SVE vectors created with the
+  /// 'arm_sve_vector_bits' type attribute as VectorType.
+  QualType getVLSEltType(const ASTContext &Ctx) const;
+
   /// Types are partitioned into 3 broad categories (C99 6.2.5p1):
   /// object types, function types, and incomplete types.
 
   /// Return true if this is an incomplete type.
   /// A type that can describe objects, but which lacks information needed to
   /// determine its size (e.g. void, or a fwd declared struct). Clients of this
   /// routine will need to determine if the size is actually required.
   ///

clang/lib/AST/ExprConstant.cpp

bool LValueExprEvaluator::VisitMemberExpr(const MemberExpr *E) {
 
   // Handle non-static data members.
   return LValueExprEvaluatorBaseTy::VisitMemberExpr(E);
 }
 
 bool LValueExprEvaluator::VisitArraySubscriptExpr(const ArraySubscriptExpr *E) {
   // FIXME: Deal with vectors as array subscript bases.
   if (E->getBase()->getType()->isVectorType() ||
-      E->getBase()->getType()->isSveVLSBuiltinType())
+      E->getBase()->getType()->isVLSBuiltinType())
     return Error(E);
 
   APSInt Index;
   bool Success = true;
 
   // C++17's rules require us to evaluate the LHS first, regardless of which
   // side is the base.
   for (const Expr *SubExpr : {E->getLHS(), E->getRHS()}) {

clang/lib/AST/Type.cpp

 
 QualType Type::getRVVEltType(const ASTContext &Ctx) const {
   assert(isRVVVLSBuiltinType() && "unsupported type!");
 
   const BuiltinType *BTy = castAs<BuiltinType>();
   return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
 }
 
+bool Type::isVLSBuiltinType() const {
+  return isSveVLSBuiltinType() || isRVVVLSBuiltinType();
+}
+
+QualType Type::getVLSEltType(const ASTContext &Ctx) const {
+  assert(isVLSBuiltinType() && "unsupported type!");
+
+  const BuiltinType *BTy = castAs<BuiltinType>();
+  return Ctx.getBuiltinVectorTypeInfo(BTy).ElementType;
+}
+
 bool QualType::isPODType(const ASTContext &Context) const {
   // C++11 has a more relaxed definition of POD.
   if (Context.getLangOpts().CPlusPlus11)
     return isCXX11PODType(Context);
 
   return isCXX98PODType(Context);
 }
 

clang/lib/CodeGen/CGExprScalar.cpp

 Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
   TestAndClearIgnoreResultAssign();
 
   // Emit subscript expressions in rvalue context's.  For most cases, this just
   // loads the lvalue formed by the subscript expr.  However, we have to be
   // careful, because the base of a vector subscript is occasionally an rvalue,
   // so we can't get it as an lvalue.
   if (!E->getBase()->getType()->isVectorType() &&
-      !E->getBase()->getType()->isSveVLSBuiltinType())
+      !E->getBase()->getType()->isVLSBuiltinType())
     return EmitLoadOfLValue(E);
 
   // Handle the vector case.  The base must be a vector, the index must be an
   // integer value.
   Value *Base = Visit(E->getBase());
   Value *Idx  = Visit(E->getIdx());
   QualType IdxTy = E->getIdx()->getType();
 
if ((CGF.getLangOpts().OpenCL && condExpr->getType()->isVectorType()) ||
     llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
     if (wasCast)
       tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
 
     return tmp5;
   }
 
   if (condExpr->getType()->isVectorType() ||
-      condExpr->getType()->isSveVLSBuiltinType()) {
+      condExpr->getType()->isVLSBuiltinType()) {
     CGF.incrementProfileCounter(E);
 
     llvm::Value *CondV = CGF.EmitScalarExpr(condExpr);
     llvm::Value *LHS = Visit(lhsExpr);
     llvm::Value *RHS = Visit(rhsExpr);
 
     llvm::Type *CondType = ConvertType(condExpr->getType());
     auto *VecTy = cast<llvm::VectorType>(CondType);

clang/lib/Sema/SemaChecking.cpp

if (isa<ComplexType>(Source)) {
 
     Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
     Target = cast<ComplexType>(Target)->getElementType().getTypePtr();
   }
 
   const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
   const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
 
-  // Strip SVE vector types
-  if (SourceBT && SourceBT->isSveVLSBuiltinType()) {
+  // Strip SVE/RVV vector types
+  if (SourceBT && SourceBT->isVLSBuiltinType()) {
     // Need the original target type for vector type checks
     const Type *OriginalTarget = S.Context.getCanonicalType(T).getTypePtr();
     // Handle conversion from scalable to fixed when msve-vector-bits is
     // specified
-    if (S.Context.areCompatibleSveTypes(QualType(OriginalTarget, 0),
+    if (SourceBT->isSveVLSBuiltinType() &&
+        (S.Context.areCompatibleSveTypes(QualType(OriginalTarget, 0),
                                          QualType(Source, 0)) ||
          S.Context.areLaxCompatibleSveTypes(QualType(OriginalTarget, 0),
-                                           QualType(Source, 0)))
+                                            QualType(Source, 0))))
+      return;
+    // Handle conversion from scalable to fixed when mrvv-vector-bits is
+    // specified
+    if (SourceBT->isRVVVLSBuiltinType() &&
+        (S.Context.areCompatibleRVVTypes(QualType(OriginalTarget, 0),
+                                         QualType(Source, 0)) ||
+         S.Context.areLaxCompatibleRVVTypes(QualType(OriginalTarget, 0),
+                                            QualType(Source, 0))))
       return;
 
     // If the vector cast is cast between two vectors of the same size, it is
     // a bitcast, not a conversion.
     if (S.Context.getTypeSize(Source) == S.Context.getTypeSize(Target))
       return;
 
     Source = SourceBT->getSveEltType(S.Context).getTypePtr();
   }
 
-  if (TargetBT && TargetBT->isSveVLSBuiltinType())
-    Target = TargetBT->getSveEltType(S.Context).getTypePtr();
+  if (TargetBT && TargetBT->isVLSBuiltinType())
+    Target = TargetBT->getVLSEltType(S.Context).getTypePtr();
 
   // If the source is floating point...
   if (SourceBT && SourceBT->isFloatingPoint()) {
     // ...and the target is floating point...
     if (TargetBT && TargetBT->isFloatingPoint()) {
       // ...then warn if we're dropping FP rank.
 
       int Order = S.getASTContext().getFloatingTypeSemanticOrder(
           QualType(SourceBT, 0), QualType(TargetBT, 0));
       if (Order > 0) {
         // Don't warn about float constants that are precisely
         // representable in the target type.
         Expr::EvalResult result;

clang/lib/Sema/SemaExpr.cpp

if (LHSTy->isDependentType() || RHSTy->isDependentType()) {
     ResultType = VTy->getElementType();
     QualType BaseType = BaseExpr->getType();
     Qualifiers BaseQuals = BaseType.getQualifiers();
     Qualifiers MemberQuals = ResultType.getQualifiers();
     Qualifiers Combined = BaseQuals + MemberQuals;
     if (Combined != MemberQuals)
       ResultType = Context.getQualifiedType(ResultType, Combined);
   } else if (LHSTy->isBuiltinType() &&
-             LHSTy->getAs<BuiltinType>()->isSveVLSBuiltinType()) {
+             LHSTy->getAs<BuiltinType>()->isVLSBuiltinType()) {
     const BuiltinType *BTy = LHSTy->getAs<BuiltinType>();
     if (BTy->isSVEBool())
       return ExprError(Diag(LLoc, diag::err_subscript_svbool_t)
                        << LHSExp->getSourceRange() << RHSExp->getSourceRange());
 
     BaseExpr = LHSExp;
     IndexExpr = RHSExp;
     if (getLangOpts().CPlusPlus11 && LHSExp->isPRValue()) {
       ExprResult Materialized = TemporaryMaterializationConversion(LHSExp);
       if (Materialized.isInvalid())
         return ExprError();
       LHSExp = Materialized.get();
     }
     VK = LHSExp->getValueKind();
     if (VK != VK_PRValue)
       OK = OK_VectorComponent;
 
-    ResultType = BTy->getSveEltType(Context);
+    ResultType = BTy->getVLSEltType(Context);
 
     QualType BaseType = BaseExpr->getType();
     Qualifiers BaseQuals = BaseType.getQualifiers();
     Qualifiers MemberQuals = ResultType.getQualifiers();
     Qualifiers Combined = BaseQuals + MemberQuals;
     if (Combined != MemberQuals)
       ResultType = Context.getQualifiedType(ResultType, Combined);
   } else if (LHSTy->isArrayType()) {
static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar,
 
   if (const auto *VT = VectorTy->getAs<VectorType>()) {
     assert(!isa<ExtVectorType>(VT) &&
            "ExtVectorTypes should not be handled here!");
     VectorEltTy = VT->getElementType();
   } else if (VectorTy->isSveVLSBuiltinType()) {
     VectorEltTy =
         VectorTy->castAs<BuiltinType>()->getSveEltType(S.getASTContext());
+  } else if (VectorTy->isRVVVLSBuiltinType()) {
+    VectorEltTy =
+        VectorTy->castAs<BuiltinType>()->getRVVEltType(S.getASTContext());
   } else {
     llvm_unreachable("Only Fixed-Length and SVE Vector types are handled here");
   }
 
   // Reject cases where the vector element type or the scalar element type are
   // not integral or floating point types.
   if (!VectorEltTy->isArithmeticType() || !ScalarTy->isArithmeticType())
     return true;
if ((OperationKind == ACK_Arithmetic) &&
     Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                       << RHS.get()->getSourceRange();
     return QualType();
   }
 
   if (Context.hasSameType(LHSType, RHSType))
     return LHSType;
 
-  if (LHSType->isSveVLSBuiltinType() && !RHSType->isSveVLSBuiltinType()) {
+  if (LHSType->isVLSBuiltinType() && !RHSType->isVLSBuiltinType()) {
     if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
       return LHSType;
   }
-  if (RHSType->isSveVLSBuiltinType() && !LHSType->isSveVLSBuiltinType()) {
+  if (RHSType->isVLSBuiltinType() && !LHSType->isVLSBuiltinType()) {
     if (LHS.get()->isLValue() ||
         !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
       return RHSType;
   }
 
-  if ((!LHSType->isSveVLSBuiltinType() && !LHSType->isRealType()) ||
-      (!RHSType->isSveVLSBuiltinType() && !RHSType->isRealType())) {
+  if ((!LHSType->isVLSBuiltinType() && !LHSType->isRealType()) ||
+      (!RHSType->isVLSBuiltinType() && !RHSType->isRealType())) {
     Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
         << LHSType << RHSType << LHS.get()->getSourceRange()
         << RHS.get()->getSourceRange();
     return QualType();
   }
 
-  if (LHSType->isSveVLSBuiltinType() && RHSType->isSveVLSBuiltinType() &&
+  if (LHSType->isVLSBuiltinType() && RHSType->isVLSBuiltinType() &&
       Context.getBuiltinVectorTypeInfo(LHSBuiltinTy).EC !=
           Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC) {
     Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
         << LHSType << RHSType << LHS.get()->getSourceRange()
         << RHS.get()->getSourceRange();
     return QualType();
   }
 
-  if (LHSType->isSveVLSBuiltinType() || RHSType->isSveVLSBuiltinType()) {
-    QualType Scalar = LHSType->isSveVLSBuiltinType() ? RHSType : LHSType;
-    QualType Vector = LHSType->isSveVLSBuiltinType() ? LHSType : RHSType;
+  if (LHSType->isVLSBuiltinType() || RHSType->isVLSBuiltinType()) {
+    QualType Scalar = LHSType->isVLSBuiltinType() ? RHSType : LHSType;
+    QualType Vector = LHSType->isVLSBuiltinType() ? LHSType : RHSType;
     bool ScalarOrVector =
-        LHSType->isSveVLSBuiltinType() && RHSType->isSveVLSBuiltinType();
+        LHSType->isVLSBuiltinType() && RHSType->isVLSBuiltinType();
 
     Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
         << ScalarOrVector << Scalar << Vector;
 
     return QualType();
   }
 
   Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
   QualType LHSTy = LHS.get()->getType();
   QualType RHSTy = RHS.get()->getType();
   if (LHSTy->isVectorType() || RHSTy->isVectorType())
     return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                /*AllowBothBool*/ getLangOpts().AltiVec,
                                /*AllowBoolConversions*/ false,
                                /*AllowBooleanOperation*/ false,
                                /*ReportInvalid*/ true);
-  if (LHSTy->isSveVLSBuiltinType() || RHSTy->isSveVLSBuiltinType())
+  if (LHSTy->isVLSBuiltinType() || RHSTy->isVLSBuiltinType())
     return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                        ACK_Arithmetic);
   if (!IsDiv &&
       (LHSTy->isConstantMatrixType() || RHSTy->isConstantMatrixType()))
     return CheckMatrixMultiplyOperands(LHS, RHS, Loc, IsCompAssign);
   // For division, only matrix-by-scalar is supported. Other combinations with
   // matrix types are invalid.
   if (IsDiv && LHSTy->isConstantMatrixType() && RHSTy->isArithmeticType())
if (LHS.get()->getType()->hasIntegerRepresentation() &&
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                  /*AllowBothBool*/ getLangOpts().AltiVec,
                                  /*AllowBoolConversions*/ false,
                                  /*AllowBooleanOperation*/ false,
                                  /*ReportInvalid*/ true);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType()) {
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType()) {
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                          ACK_Arithmetic);
 
     return InvalidOperands(Loc, LHS, RHS);
   }
 
QualType compType =
                             /*AllowBothBool*/ getLangOpts().AltiVec,
                             /*AllowBoolConversions*/ getLangOpts().ZVector,
                             /*AllowBooleanOperation*/ false,
                             /*ReportInvalid*/ true);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType()) {
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType()) {
     QualType compType =
         CheckSizelessVectorOperands(LHS, RHS, Loc, CompLHSTy, ACK_Arithmetic);
     if (CompLHSTy)
       *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
QualType compType =
                             /*AllowBothBool*/ getLangOpts().AltiVec,
                             /*AllowBoolConversions*/ getLangOpts().ZVector,
                             /*AllowBooleanOperation*/ false,
                             /*ReportInvalid*/ true);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType()) {
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType()) {
     QualType compType =
         CheckSizelessVectorOperands(LHS, RHS, Loc, CompLHSTy, ACK_Arithmetic);
     if (CompLHSTy)
       *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
static QualType checkSizelessVectorShift(Sema &S, ExprResult &LHS,
   }
 
   RHS = S.UsualUnaryConversions(RHS.get());
   if (RHS.isInvalid())
     return QualType();
 
   QualType LHSType = LHS.get()->getType();
   const BuiltinType *LHSBuiltinTy = LHSType->castAs<BuiltinType>();
-  QualType LHSEleType = LHSType->isSveVLSBuiltinType()
-                            ? LHSBuiltinTy->getSveEltType(S.getASTContext())
+  QualType LHSEleType = LHSType->isVLSBuiltinType()
+                            ? LHSBuiltinTy->getVLSEltType(S.getASTContext())
                             : LHSType;
 
   // Note that RHS might not be a vector
   QualType RHSType = RHS.get()->getType();
   const BuiltinType *RHSBuiltinTy = RHSType->castAs<BuiltinType>();
-  QualType RHSEleType = RHSType->isSveVLSBuiltinType()
-                            ? RHSBuiltinTy->getSveEltType(S.getASTContext())
+  QualType RHSEleType = RHSType->isVLSBuiltinType()
+                            ? RHSBuiltinTy->getVLSEltType(S.getASTContext())
                             : RHSType;
 
   if ((LHSBuiltinTy && LHSBuiltinTy->isSVEBool()) ||
       (RHSBuiltinTy && RHSBuiltinTy->isSVEBool())) {
     S.Diag(Loc, diag::err_typecheck_invalid_operands)
         << LHSType << RHSType << LHS.get()->getSourceRange();
     return QualType();
   }
 
   if (!LHSEleType->isIntegerType()) {
     S.Diag(Loc, diag::err_typecheck_expect_int)
         << LHS.get()->getType() << LHS.get()->getSourceRange();
     return QualType();
   }
 
   if (!RHSEleType->isIntegerType()) {
     S.Diag(Loc, diag::err_typecheck_expect_int)
         << RHS.get()->getType() << RHS.get()->getSourceRange();
     return QualType();
   }
 
-  if (LHSType->isSveVLSBuiltinType() && RHSType->isSveVLSBuiltinType() &&
+  if (LHSType->isVLSBuiltinType() && RHSType->isVLSBuiltinType() &&
       (S.Context.getBuiltinVectorTypeInfo(LHSBuiltinTy).EC !=
        S.Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC)) {
     S.Diag(Loc, diag::err_typecheck_invalid_operands)
         << LHSType << RHSType << LHS.get()->getSourceRange()
         << RHS.get()->getSourceRange();
     return QualType();
   }
 
-  if (!LHSType->isSveVLSBuiltinType()) {
-    assert(RHSType->isSveVLSBuiltinType());
+  if (!LHSType->isVLSBuiltinType()) {
+    assert(RHSType->isVLSBuiltinType());
     if (IsCompAssign)
       return RHSType;
     if (LHSEleType != RHSEleType) {
       LHS = S.ImpCastExprToType(LHS.get(), RHSEleType, clang::CK_IntegralCast);
       LHSEleType = RHSEleType;
     }
     const llvm::ElementCount VecSize =
         S.Context.getBuiltinVectorTypeInfo(RHSBuiltinTy).EC;
     QualType VecTy =
         S.Context.getScalableVectorType(LHSEleType, VecSize.getKnownMinValue());
     LHS = S.ImpCastExprToType(LHS.get(), VecTy, clang::CK_VectorSplat);
     LHSType = VecTy;
-  } else if (RHSBuiltinTy && RHSBuiltinTy->isSveVLSBuiltinType()) {
+  } else if (RHSBuiltinTy && RHSBuiltinTy->isVLSBuiltinType()) {
     if (S.Context.getTypeSize(RHSBuiltinTy) !=
         S.Context.getTypeSize(LHSBuiltinTy)) {
       S.Diag(Loc, diag::err_typecheck_vector_lengths_not_equal)
           << LHSType << RHSType << LHS.get()->getSourceRange()
           << RHS.get()->getSourceRange();
       return QualType();
     }
   } else {
if (LangOpts.ZVector) {
           return InvalidOperands(Loc, LHS, RHS);
       if (auto RHSVecType = RHS.get()->getType()->getAs<VectorType>())
         if (RHSVecType->getVectorKind() == VectorType::AltiVecBool)
           return InvalidOperands(Loc, LHS, RHS);
     }
     return checkVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
   }
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType())
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType())
     return checkSizelessVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
 
   // Shifts don't perform usual arithmetic conversions, they just do integer
   // promotions on each operand. C99 6.5.7p3
 
   // For the LHS, do usual unary conversions, but then reset them away
   // if this is a compound assignment.
   ExprResult OldLHS = LHS;
if (!getLangOpts().CPlusPlus && BinaryOperator::isEqualityOp(Opc)) {
     CheckPtrComparisonWithNullChar(RHS, LHS);
   }
 
   // Handle vector comparisons separately.
   if (LHS.get()->getType()->isVectorType() ||
       RHS.get()->getType()->isVectorType())
     return CheckVectorCompareOperands(LHS, RHS, Loc, Opc);
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType())
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType())
     return CheckSizelessVectorCompareOperands(LHS, RHS, Loc, Opc);
 
   diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
   diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);
 
   QualType LHSType = LHS.get()->getType();
   QualType RHSType = RHS.get()->getType();
   if ((LHSType->isArithmeticType() || LHSType->isEnumeralType()) &&
QualType Sema::GetSignedVectorType(QualType V) {
   return Context.getVectorType(Context.CharTy, VTy->getNumElements(),
                                VectorType::GenericVector);
 }
 
 QualType Sema::GetSignedSizelessVectorType(QualType V) {
   const BuiltinType *VTy = V->castAs<BuiltinType>();
   assert(VTy->isSizelessBuiltinType() && "expected sizeless type");
 
-  const QualType ETy = V->getSveEltType(Context);
+  const QualType ETy = V->getVLSEltType(Context);
   const auto TypeSize = Context.getTypeSize(ETy);
 
   const QualType IntTy = Context.getIntTypeForBitwidth(TypeSize, true);
   const llvm::ElementCount VecSize = Context.getBuiltinVectorTypeInfo(VTy).EC;
   return Context.getScalableVectorType(IntTy, VecSize.getKnownMinValue());
 }
 
 /// CheckVectorCompareOperands - vector comparisons are a clang extension that
if (LHS.get()->getType()->hasIntegerRepresentation() &&
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                  /*AllowBothBool*/ true,
                                  /*AllowBoolConversions*/ getLangOpts().ZVector,
                                  /*AllowBooleanOperation*/ LegalBoolVecOperator,
                                  /*ReportInvalid*/ true);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType()) {
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType()) {
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                          ACK_BitwiseOp);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
-  if (LHS.get()->getType()->isSveVLSBuiltinType() ||
-      RHS.get()->getType()->isSveVLSBuiltinType()) {
+  if (LHS.get()->getType()->isVLSBuiltinType() ||
+      RHS.get()->getType()->isVLSBuiltinType()) {
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                          ACK_BitwiseOp);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
   if (Opc == BO_And)
case UO_Minus:
     if (resultType->isArithmeticType()) // C99 6.5.3.3p1
       break;
     else if (resultType->isVectorType() &&
              // The z vector extensions don't allow + or - with bool vectors.
              (!Context.getLangOpts().ZVector ||
               resultType->castAs<VectorType>()->getVectorKind() !=
               VectorType::AltiVecBool))
       break;
-    else if (resultType->isSveVLSBuiltinType()) // SVE vectors allow + and -
+    else if (resultType->isVLSBuiltinType()) // SVE/RVV vectors allow + and -
       break;
     else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
              Opc == UO_Plus &&
              resultType->isPointerType())
       break;
 
     return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
       << resultType << Input.get()->getSourceRange());

clang/lib/Sema/SemaExprCXX.cpp

static bool isValidVectorForConditionalCondition(ASTContext &Ctx,
   const QualType EltTy =
       cast<VectorType>(CondTy.getCanonicalType())->getElementType();
   assert(!EltTy->isEnumeralType() && "Vectors cant be enum types");
   return EltTy->isIntegralType(Ctx);
 }
 
 static bool isValidSizelessVectorForConditionalCondition(ASTContext &Ctx,
                                                          QualType CondTy) {
-  if (!CondTy->isSveVLSBuiltinType())
+  if (!CondTy->isVLSBuiltinType())
     return false;
   const QualType EltTy =
-      cast<BuiltinType>(CondTy.getCanonicalType())->getSveEltType(Ctx);
+      cast<BuiltinType>(CondTy.getCanonicalType())->getVLSEltType(Ctx);
   assert(!EltTy->isEnumeralType() && "Vectors cant be enum types");
   return EltTy->isIntegralType(Ctx);
 }
 
 QualType Sema::CheckVectorConditionalTypes(ExprResult &Cond, ExprResult &LHS,
                                            ExprResult &RHS,
                                            SourceLocation QuestionLoc) {
   LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
QualType Sema::CheckSizelessVectorConditionalTypes(ExprResult &Cond,
                                                    ExprResult &LHS,
                                                    ExprResult &RHS,
                                                    SourceLocation QuestionLoc) {
   LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
   RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
 
   QualType CondType = Cond.get()->getType();
   const auto *CondBT = CondType->castAs<BuiltinType>();
-  QualType CondElementTy = CondBT->getSveEltType(Context);
+  QualType CondElementTy = CondBT->getVLSEltType(Context);
   llvm::ElementCount CondElementCount =
       Context.getBuiltinVectorTypeInfo(CondBT).EC;
 
   QualType LHSType = LHS.get()->getType();
   const auto *LHSBT =
-      LHSType->isSveVLSBuiltinType() ? LHSType->getAs<BuiltinType>() : nullptr;
+      LHSType->isVLSBuiltinType() ? LHSType->getAs<BuiltinType>() : nullptr;
   QualType RHSType = RHS.get()->getType();
   const auto *RHSBT =
-      RHSType->isSveVLSBuiltinType() ? RHSType->getAs<BuiltinType>() : nullptr;
+      RHSType->isVLSBuiltinType() ? RHSType->getAs<BuiltinType>() : nullptr;
 
   QualType ResultType;
 
   if (LHSBT && RHSBT) {
     // If both are sizeless vector types, they must be the same type.
     if (!Context.hasSameType(LHSType, RHSType)) {
       Diag(QuestionLoc, diag::err_conditional_vector_mismatched)
           << LHSType << RHSType;
if (LHSBT && RHSBT) {
 
     ResultType = Context.getScalableVectorType(
         ResultElementTy, CondElementCount.getKnownMinValue());
 
     LHS = ImpCastExprToType(LHS.get(), ResultType, CK_VectorSplat);
     RHS = ImpCastExprToType(RHS.get(), ResultType, CK_VectorSplat);
   }
 
-  assert(!ResultType.isNull() && ResultType->isSveVLSBuiltinType() &&
+  assert(!ResultType.isNull() && ResultType->isVLSBuiltinType() &&
          "Result should have been a vector type");
   auto *ResultBuiltinTy = ResultType->castAs<BuiltinType>();
-  QualType ResultElementTy = ResultBuiltinTy->getSveEltType(Context);
+  QualType ResultElementTy = ResultBuiltinTy->getVLSEltType(Context);
   llvm::ElementCount ResultElementCount =
       Context.getBuiltinVectorTypeInfo(ResultBuiltinTy).EC;
 
   if (ResultElementCount != CondElementCount) {
     Diag(QuestionLoc, diag::err_conditional_vector_size)
         << CondType << ResultType;
     return QualType();
   }

clang/test/CodeGen/riscv-rvv-vla-arith-ops.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +zve64d \
+// RUN: -target-feature +f -target-feature +d -disable-O0-optnone \
+// RUN: -mvscale-min=4 -mvscale-max=4 -emit-llvm -o - %s | \
+// RUN: opt -S -passes=sroa | FileCheck %s
+
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+// ADDITION
+
+// CHECK-LABEL: @add_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[ADD]]
+//
+vint8m1_t add_i8(vint8m1_t a, vint8m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[ADD]]
+//
+vint16m1_t add_i16(vint16m1_t a, vint16m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[ADD]]
+//
+vint32m1_t add_i32(vint32m1_t a, vint32m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[ADD]]
+//
+vint64m1_t add_i64(vint64m1_t a, vint64m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[ADD]]
+//
+vuint8m1_t add_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[ADD]]
+//
+vuint16m1_t add_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[ADD]]
+//
+vuint32m1_t add_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[ADD]]
+//
+vuint64m1_t add_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[ADD]]
+//
+vfloat32m1_t add_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[ADD]]
+//
+vfloat64m1_t add_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_inplace_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[ADD]]
+//
+vint8m1_t add_inplace_i8(vint8m1_t a, vint8m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[ADD]]
+//
+vint16m1_t add_inplace_i16(vint16m1_t a, vint16m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[ADD]]
+//
+vint32m1_t add_inplace_i32(vint32m1_t a, vint32m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[ADD]]
+//
+vint64m1_t add_inplace_i64(vint64m1_t a, vint64m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[ADD]]
+//
+vuint8m1_t add_inplace_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[ADD]]
+//
+vuint16m1_t add_inplace_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[ADD]]
+//
+vuint32m1_t add_inplace_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[ADD]]
+//
+vuint64m1_t add_inplace_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[ADD]]
+//
+vfloat32m1_t add_inplace_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_inplace_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[ADD]]
+//
+vfloat64m1_t add_inplace_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a += b;
+}
+
+// CHECK-LABEL: @add_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[ADD]]
+//
+vint8m1_t add_scalar_i8(vint8m1_t a, int8_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[ADD]]
+//
+vint16m1_t add_scalar_i16(vint16m1_t a, int16_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[ADD]]
+//
+vint32m1_t add_scalar_i32(vint32m1_t a, int32_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[ADD]]
+//
+vint64m1_t add_scalar_i64(vint64m1_t a, int64_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[ADD]]
+//
+vuint8m1_t add_scalar_u8(vuint8m1_t a, uint8_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[ADD]]
+//
+vuint16m1_t add_scalar_u16(vuint16m1_t a, uint16_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[ADD]]
+//
+vuint32m1_t add_scalar_u32(vuint32m1_t a, uint32_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[ADD]]
+//
+vuint64m1_t add_scalar_u64(vuint64m1_t a, uint64_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x float> poison, float [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x float> [[SPLAT_SPLATINSERT]], <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[ADD]]
+//
+vfloat32m1_t add_scalar_f32(vfloat32m1_t a, float b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x double> poison, double [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x double> [[SPLAT_SPLATINSERT]], <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 1 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[ADD]]
+//
+vfloat64m1_t add_scalar_f64(vfloat64m1_t a, double b) {
+  return a + b;
+}
+
+// SUBTRACTION
+
+// CHECK-LABEL: @sub_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SUB]]
+//
+vint8m1_t sub_i8(vint8m1_t a, vint8m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SUB]]
+//
+vint16m1_t sub_i16(vint16m1_t a, vint16m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SUB]]
+//
+vint32m1_t sub_i32(vint32m1_t a, vint32m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SUB]]
+//
+vint64m1_t sub_i64(vint64m1_t a, vint64m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SUB]]
+//
+vuint8m1_t sub_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SUB]]
+//
+vuint16m1_t sub_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SUB]]
+//
+vuint32m1_t sub_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SUB]]
+//
+vuint64m1_t sub_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[SUB]]
+//
+vfloat32m1_t sub_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[SUB]]
+//
+vfloat64m1_t sub_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SUB]]
+//
+vint8m1_t sub_inplace_i8(vint8m1_t a, vint8m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SUB]]
+//
+vint16m1_t sub_inplace_i16(vint16m1_t a, vint16m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SUB]]
+//
+vint32m1_t sub_inplace_i32(vint32m1_t a, vint32m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SUB]]
+//
+vint64m1_t sub_inplace_i64(vint64m1_t a, vint64m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SUB]]
+//
+vuint8m1_t sub_inplace_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SUB]]
+//
+vuint16m1_t sub_inplace_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SUB]]
+//
+vuint32m1_t sub_inplace_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SUB]]
+//
+vuint64m1_t sub_inplace_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[SUB]]
+//
+vfloat32m1_t sub_inplace_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_inplace_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[SUB]]
+//
+vfloat64m1_t sub_inplace_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SUB]]
+//
+vint8m1_t sub_scalar_i8(vint8m1_t a, int8_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SUB]]
+//
+vint16m1_t sub_scalar_i16(vint16m1_t a, int16_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SUB]]
+//
+vint32m1_t sub_scalar_i32(vint32m1_t a, int32_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SUB]]
+//
+vint64m1_t sub_scalar_i64(vint64m1_t a, int64_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SUB]]
+//
+vuint8m1_t sub_scalar_u8(vuint8m1_t a, uint8_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SUB]]
+//
+vuint16m1_t sub_scalar_u16(vuint16m1_t a, uint16_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SUB]]
+//
+vuint32m1_t sub_scalar_u32(vuint32m1_t a, uint32_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SUB]]
+//
+vuint64m1_t sub_scalar_u64(vuint64m1_t a, uint64_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x float> poison, float [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x float> [[SPLAT_SPLATINSERT]], <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 2 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[SUB]]
+//
+vfloat32m1_t sub_scalar_f32(vfloat32m1_t a, float b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x double> poison, double [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x double> [[SPLAT_SPLATINSERT]], <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 1 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[SUB]]
+//
+vfloat64m1_t sub_scalar_f64(vfloat64m1_t a, double b) {
+  return a - b;
+}
+
+// MULTIPLICATION
+
+// CHECK-LABEL: @mul_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[MUL]]
+//
+vint8m1_t mul_i8(vint8m1_t a, vint8m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[MUL]]
+//
+vint16m1_t mul_i16(vint16m1_t a, vint16m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[MUL]]
+//
+vint32m1_t mul_i32(vint32m1_t a, vint32m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[MUL]]
+//
+vint64m1_t mul_i64(vint64m1_t a, vint64m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[MUL]]
+//
+vuint8m1_t mul_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[MUL]]
+//
+vuint16m1_t mul_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[MUL]]
+//
+vuint32m1_t mul_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[MUL]]
+//
+vuint64m1_t mul_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[MUL]]
+//
+vfloat32m1_t mul_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[MUL]]
+//
+vfloat64m1_t mul_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[MUL]]
+//
+vint8m1_t mul_inplace_i8(vint8m1_t a, vint8m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[MUL]]
+//
+vint16m1_t mul_inplace_i16(vint16m1_t a, vint16m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[MUL]]
+//
+vint32m1_t mul_inplace_i32(vint32m1_t a, vint32m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[MUL]]
+//
+vint64m1_t mul_inplace_i64(vint64m1_t a, vint64m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[MUL]]
+//
+vuint8m1_t mul_inplace_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[MUL]]
+//
+vuint16m1_t mul_inplace_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[MUL]]
+//
+vuint32m1_t mul_inplace_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[MUL]]
+//
+vuint64m1_t mul_inplace_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[MUL]]
+//
+vfloat32m1_t mul_inplace_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_inplace_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[MUL]]
+//
+vfloat64m1_t mul_inplace_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[MUL]]
+//
+vint8m1_t mul_scalar_i8(vint8m1_t a, int8_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[MUL]]
+//
+vint16m1_t mul_scalar_i16(vint16m1_t a, int16_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[MUL]]
+//
+vint32m1_t mul_scalar_i32(vint32m1_t a, int32_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[MUL]]
+//
+vint64m1_t mul_scalar_i64(vint64m1_t a, int64_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[MUL]]
+//
+vuint8m1_t mul_scalar_u8(vuint8m1_t a, uint8_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[MUL]]
+//
+vuint16m1_t mul_scalar_u16(vuint16m1_t a, uint16_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[MUL]]
+//
+vuint32m1_t mul_scalar_u32(vuint32m1_t a, uint32_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[MUL]]
+//
+vuint64m1_t mul_scalar_u64(vuint64m1_t a, uint64_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x float> poison, float [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x float> [[SPLAT_SPLATINSERT]], <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 2 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[MUL]]
+//
+vfloat32m1_t mul_scalar_f32(vfloat32m1_t a, float b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x double> poison, double [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x double> [[SPLAT_SPLATINSERT]], <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 1 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[MUL]]
+//
+vfloat64m1_t mul_scalar_f64(vfloat64m1_t a, double b) {
+  return a * b;
+}
+
+// DIVISION
+
+// CHECK-LABEL: @div_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[DIV]]
+//
+vint8m1_t div_i8(vint8m1_t a, vint8m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[DIV]]
+//
+vint16m1_t div_i16(vint16m1_t a, vint16m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[DIV]]
+//
+vint32m1_t div_i32(vint32m1_t a, vint32m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[DIV]]
+//
+vint64m1_t div_i64(vint64m1_t a, vint64m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[DIV]]
+//
+vuint8m1_t div_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[DIV]]
+//
+vuint16m1_t div_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[DIV]]
+//
+vuint32m1_t div_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[DIV]]
+//
+vuint64m1_t div_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[DIV]]
+//
+vfloat32m1_t div_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[DIV]]
+//
+vfloat64m1_t div_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[DIV]]
+//
+vint8m1_t div_inplace_i8(vint8m1_t a, vint8m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[DIV]]
+//
+vint16m1_t div_inplace_i16(vint16m1_t a, vint16m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[DIV]]
+//
+vint32m1_t div_inplace_i32(vint32m1_t a, vint32m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[DIV]]
+//
+vint64m1_t div_inplace_i64(vint64m1_t a, vint64m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[DIV]]
+//
+vuint8m1_t div_inplace_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[DIV]]
+//
+vuint16m1_t div_inplace_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[DIV]]
+//
+vuint32m1_t div_inplace_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[DIV]]
+//
+vuint64m1_t div_inplace_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[DIV]]
+//
+vfloat32m1_t div_inplace_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_inplace_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[DIV]]
+//
+vfloat64m1_t div_inplace_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[DIV]]
+//
+vint8m1_t div_scalar_i8(vint8m1_t a, int8_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[DIV]]
+//
+vint16m1_t div_scalar_i16(vint16m1_t a, int16_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[DIV]]
+//
+vint32m1_t div_scalar_i32(vint32m1_t a, int32_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[DIV]]
+//
+vint64m1_t div_scalar_i64(vint64m1_t a, int64_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[DIV]]
+//
+vuint8m1_t div_scalar_u8(vuint8m1_t a, uint8_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[DIV]]
+//
+vuint16m1_t div_scalar_u16(vuint16m1_t a, uint16_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[DIV]]
+//
+vuint32m1_t div_scalar_u32(vuint32m1_t a, uint32_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[DIV]]
+//
+vuint64m1_t div_scalar_u64(vuint64m1_t a, uint64_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x float> poison, float [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x float> [[SPLAT_SPLATINSERT]], <vscale x 2 x float> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 2 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x float> [[DIV]]
+//
+vfloat32m1_t div_scalar_f32(vfloat32m1_t a, float b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x double> poison, double [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x double> [[SPLAT_SPLATINSERT]], <vscale x 1 x double> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 1 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x double> [[DIV]]
+//
+vfloat64m1_t div_scalar_f64(vfloat64m1_t a, double b) {
+  return a / b;
+}
+
+// REMAINDER
+
+// CHECK-LABEL: @rem_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[REM]]
+//
+vint8m1_t rem_i8(vint8m1_t a, vint8m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[REM]]
+//
+vint16m1_t rem_i16(vint16m1_t a, vint16m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[REM]]
+//
+vint32m1_t rem_i32(vint32m1_t a, vint32m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[REM]]
+//
+vint64m1_t rem_i64(vint64m1_t a, vint64m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[REM]]
+//
+vuint8m1_t rem_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[REM]]
+//
+vuint16m1_t rem_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[REM]]
+//
+vuint32m1_t rem_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[REM]]
+//
+vuint64m1_t rem_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[REM]]
+//
+vint8m1_t rem_inplace_i8(vint8m1_t a, vint8m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[REM]]
+//
+vint16m1_t rem_inplace_i16(vint16m1_t a, vint16m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[REM]]
+//
+vint32m1_t rem_inplace_i32(vint32m1_t a, vint32m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[REM]]
+//
+vint64m1_t rem_inplace_i64(vint64m1_t a, vint64m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[REM]]
+//
+vuint8m1_t rem_inplace_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[REM]]
+//
+vuint16m1_t rem_inplace_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[REM]]
+//
+vuint32m1_t rem_inplace_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_inplace_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[REM]]
+//
+vuint64m1_t rem_inplace_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[REM]]
+//
+vint8m1_t rem_scalar_i8(vint8m1_t a, int8_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[REM]]
+//
+vint16m1_t rem_scalar_i16(vint16m1_t a, int16_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[REM]]
+//
+vint32m1_t rem_scalar_i32(vint32m1_t a, int32_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[REM]]
+//
+vint64m1_t rem_scalar_i64(vint64m1_t a, int64_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[REM]]
+//
+vuint8m1_t rem_scalar_u8(vuint8m1_t a, uint8_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[REM]]
+//
+vuint16m1_t rem_scalar_u16(vuint16m1_t a, uint16_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[REM]]
+//
+vuint32m1_t rem_scalar_u32(vuint32m1_t a, uint32_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[REM]]
+//
+vuint64m1_t rem_scalar_u64(vuint64m1_t a, uint64_t b) {
+  return a % b;
+}

clang/test/CodeGen/riscv-rvv-vla-bitwise-ops.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +zve64d \
+// RUN: -target-feature +f -target-feature +d -disable-O0-optnone \
+// RUN: -mvscale-min=4 -mvscale-max=4 -emit-llvm -o - %s | \
+// RUN: opt -S -passes=sroa | FileCheck %s
+
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+// AND
+
+// CHECK-LABEL: @and_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[AND]]
+//
+vint8m1_t and_i8(vint8m1_t a, vint8m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[AND]]
+//
+vint16m1_t and_i16(vint16m1_t a, vint16m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[AND]]
+//
+vint32m1_t and_i32(vint32m1_t a, vint32m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[AND]]
+//
+vint64m1_t and_i64(vint64m1_t a, vint64m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[AND]]
+//
+vuint8m1_t and_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[AND]]
+//
+vuint16m1_t and_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[AND]]
+//
+vuint32m1_t and_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[AND]]
+//
+vuint64m1_t and_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a & b;
+}
+
+// OR
+
+// CHECK-LABEL: @or_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[OR]]
+//
+vint8m1_t or_i8(vint8m1_t a, vint8m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[OR]]
+//
+vint16m1_t or_i16(vint16m1_t a, vint16m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[OR]]
+//
+vint32m1_t or_i32(vint32m1_t a, vint32m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[OR]]
+//
+vint64m1_t or_i64(vint64m1_t a, vint64m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[OR]]
+//
+vuint8m1_t or_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[OR]]
+//
+vuint16m1_t or_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[OR]]
+//
+vuint32m1_t or_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[OR]]
+//
+vuint64m1_t or_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a | b;
+}
+
+// XOR
+
+// CHECK-LABEL: @xor_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[XOR]]
+//
+vint8m1_t xor_i8(vint8m1_t a, vint8m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[XOR]]
+//
+vint16m1_t xor_i16(vint16m1_t a, vint16m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[XOR]]
+//
+vint32m1_t xor_i32(vint32m1_t a, vint32m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[XOR]]
+//
+vint64m1_t xor_i64(vint64m1_t a, vint64m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[XOR]]
+//
+vuint8m1_t xor_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[XOR]]
+//
+vuint16m1_t xor_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[XOR]]
+//
+vuint32m1_t xor_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[XOR]]
+//
+vuint64m1_t xor_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a ^ b;
+}
+
+// NEG
+
+// CHECK-LABEL: @not_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 8 x i8> [[A:%.*]], shufflevector (<vscale x 8 x i8> insertelement (<vscale x 8 x i8> poison, i8 -1, i64 0), <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[NOT]]
+//
+vint8m1_t not_i8(vint8m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 4 x i16> [[A:%.*]], shufflevector (<vscale x 4 x i16> insertelement (<vscale x 4 x i16> poison, i16 -1, i64 0), <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[NOT]]
+//
+vint16m1_t not_i16(vint16m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 2 x i32> [[A:%.*]], shufflevector (<vscale x 2 x i32> insertelement (<vscale x 2 x i32> poison, i32 -1, i64 0), <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[NOT]]
+//
+vint32m1_t not_i32(vint32m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 1 x i64> [[A:%.*]], shufflevector (<vscale x 1 x i64> insertelement (<vscale x 1 x i64> poison, i64 -1, i64 0), <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[NOT]]
+//
+vint64m1_t not_i64(vint64m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 8 x i8> [[A:%.*]], shufflevector (<vscale x 8 x i8> insertelement (<vscale x 8 x i8> poison, i8 -1, i64 0), <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[NOT]]
+//
+vuint8m1_t not_u8(vuint8m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 4 x i16> [[A:%.*]], shufflevector (<vscale x 4 x i16> insertelement (<vscale x 4 x i16> poison, i16 -1, i64 0), <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[NOT]]
+//
+vuint16m1_t not_u16(vuint16m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 2 x i32> [[A:%.*]], shufflevector (<vscale x 2 x i32> insertelement (<vscale x 2 x i32> poison, i32 -1, i64 0), <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[NOT]]
+//
+vuint32m1_t not_u32(vuint32m1_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @not_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NOT:%.*]] = xor <vscale x 1 x i64> [[A:%.*]], shufflevector (<vscale x 1 x i64> insertelement (<vscale x 1 x i64> poison, i64 -1, i64 0), <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[NOT]]
+//
+vuint64m1_t not_u64(vuint64m1_t a) {
+  return ~a;
+}

clang/test/CodeGen/riscv-rvv-vla-compare-ops.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +zve64d \
+// RUN: -target-feature +f -target-feature +d -disable-O0-optnone \
+// RUN: -mvscale-min=4 -mvscale-max=4 -emit-llvm -o - %s | \
+// RUN: opt -S -passes=sroa | FileCheck %s
+
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+// EQ
+
+// CHECK-LABEL: @eq_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t eq_i8(vint8m1_t a, vint8m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t eq_i16(vint16m1_t a, vint16m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t eq_i32(vint32m1_t a, vint32m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t eq_i64(vint64m1_t a, vint64m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t eq_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t eq_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t eq_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp eq <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t eq_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t eq_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a == b;
+}
+
+// CHECK-LABEL: @eq_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp oeq <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t eq_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a == b;
+}
+
+// NEQ
+
+// CHECK-LABEL: @neq_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t neq_i8(vint8m1_t a, vint8m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t neq_i16(vint16m1_t a, vint16m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t neq_i32(vint32m1_t a, vint32m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t neq_i64(vint64m1_t a, vint64m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t neq_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t neq_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t neq_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ne <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t neq_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp une <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t neq_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a != b;
+}
+
+// CHECK-LABEL: @neq_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp une <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t neq_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a != b;
+}
+
+// LT
+
+// CHECK-LABEL: @lt_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t lt_i8(vint8m1_t a, vint8m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t lt_i16(vint16m1_t a, vint16m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t lt_i32(vint32m1_t a, vint32m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t lt_i64(vint64m1_t a, vint64m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t lt_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t lt_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t lt_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ult <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t lt_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp olt <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t lt_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a < b;
+}
+
+// CHECK-LABEL: @lt_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp olt <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t lt_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a < b;
+}
+
+// LEQ
+
+// CHECK-LABEL: @leq_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t leq_i8(vint8m1_t a, vint8m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t leq_i16(vint16m1_t a, vint16m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t leq_i32(vint32m1_t a, vint32m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t leq_i64(vint64m1_t a, vint64m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t leq_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t leq_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t leq_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ule <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t leq_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp ole <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t leq_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a <= b;
+}
+
+// CHECK-LABEL: @leq_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp ole <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t leq_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a <= b;
+}
+
+// GT
+
+// CHECK-LABEL: @gt_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t gt_i8(vint8m1_t a, vint8m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t gt_i16(vint16m1_t a, vint16m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t gt_i32(vint32m1_t a, vint32m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t gt_i64(vint64m1_t a, vint64m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t gt_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t gt_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t gt_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp ugt <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t gt_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t gt_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a > b;
+}
+
+// CHECK-LABEL: @gt_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp ogt <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t gt_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a > b;
+}
+
+// GEQ
+
+// CHECK-LABEL: @geq_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t geq_i8(vint8m1_t a, vint8m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t geq_i16(vint16m1_t a, vint16m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t geq_i32(vint32m1_t a, vint32m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t geq_i64(vint64m1_t a, vint64m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 8 x i1> [[CMP]] to <vscale x 8 x i8>
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[CONV]]
+//
+vint8m1_t geq_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 4 x i1> [[CMP]] to <vscale x 4 x i16>
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[CONV]]
+//
+vint16m1_t geq_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t geq_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = icmp uge <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t geq_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp oge <vscale x 2 x float> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 2 x i1> [[CMP]] to <vscale x 2 x i32>
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[CONV]]
+//
+vint32m1_t geq_f32(vfloat32m1_t a, vfloat32m1_t b) {
+  return a >= b;
+}
+
+// CHECK-LABEL: @geq_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[CMP:%.*]] = fcmp oge <vscale x 1 x double> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    [[CONV:%.*]] = zext <vscale x 1 x i1> [[CMP]] to <vscale x 1 x i64>
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[CONV]]
+//
+vint64m1_t geq_f64(vfloat64m1_t a, vfloat64m1_t b) {
+  return a >= b;
+}

clang/test/CodeGen/riscv-rvv-vla-shift-ops.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +zve64d \
+// RUN: -target-feature +f -target-feature +d -disable-O0-optnone \
+// RUN: -mvscale-min=4 -mvscale-max=4 -emit-llvm -o - %s | \
+// RUN: opt -S -passes=sroa | FileCheck %s
+
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+// CHECK-LABEL: @lshift_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHL]]
+//
+vint8m1_t lshift_i8(vint8m1_t a, vint8m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHR]]
+//
+vint8m1_t rshift_i8(vint8m1_t a, vint8m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHL]]
+//
+vuint8m1_t lshift_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 8 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHR]]
+//
+vuint8m1_t rshift_u8(vuint8m1_t a, vuint8m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHL]]
+//
+vint16m1_t lshift_i16(vint16m1_t a, vint16m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHR]]
+//
+vint16m1_t rshift_i16(vint16m1_t a, vint16m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHL]]
+//
+vuint16m1_t lshift_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 4 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHR]]
+//
+vuint16m1_t rshift_u16(vuint16m1_t a, vuint16m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHL]]
+//
+vint32m1_t lshift_i32(vint32m1_t a, vint32m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHR]]
+//
+vint32m1_t rshift_i32(vint32m1_t a, vint32m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHL]]
+//
+vuint32m1_t lshift_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 2 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHR]]
+//
+vuint32m1_t rshift_u32(vuint32m1_t a, vuint32m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHL]]
+//
+vint64m1_t lshift_i64(vint64m1_t a, vint64m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHR]]
+//
+vint64m1_t rshift_i64(vint64m1_t a, vint64m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHL]]
+//
+vuint64m1_t lshift_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @rshift_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 1 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHR]]
+//
+vuint64m1_t rshift_u64(vuint64m1_t a, vuint64m1_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @lshift_i8_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHL]]
+//
+vint8m1_t lshift_i8_rsplat(vint8m1_t a, int8_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_i8_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 8 x i8> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHL]]
+//
+vint8m1_t lshift_i8_lsplat(vint8m1_t a, int8_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_i8_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHR]]
+//
+vint8m1_t rshift_i8_rsplat(vint8m1_t a, int8_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_i8_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 8 x i8> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHR]]
+//
+vint8m1_t rshift_i8_lsplat(vint8m1_t a, int8_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_u8_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHL]]
+//
+vuint8m1_t lshift_u8_rsplat(vuint8m1_t a, uint8_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_u8_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 8 x i8> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHL]]
+//
+vuint8m1_t lshift_u8_lsplat(vuint8m1_t a, uint8_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_u8_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 8 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHR]]
+//
+vuint8m1_t rshift_u8_rsplat(vuint8m1_t a, uint8_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_u8_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i8> poison, i8 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i8> [[SPLAT_SPLATINSERT]], <vscale x 8 x i8> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 8 x i8> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i8> [[SHR]]
+//
+vuint8m1_t rshift_u8_lsplat(vuint8m1_t a, uint8_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_i16_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHL]]
+//
+vint16m1_t lshift_i16_rsplat(vint16m1_t a, int16_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_i16_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 4 x i16> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHL]]
+//
+vint16m1_t lshift_i16_lsplat(vint16m1_t a, int16_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_i16_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHR]]
+//
+vint16m1_t rshift_i16_rsplat(vint16m1_t a, int16_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_i16_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 4 x i16> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHR]]
+//
+vint16m1_t rshift_i16_lsplat(vint16m1_t a, int16_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_u16_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHL]]
+//
+vuint16m1_t lshift_u16_rsplat(vuint16m1_t a, uint16_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_u16_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 4 x i16> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHL]]
+//
+vuint16m1_t lshift_u16_lsplat(vuint16m1_t a, uint16_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_u16_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 4 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHR]]
+//
+vuint16m1_t rshift_u16_rsplat(vuint16m1_t a, uint16_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_u16_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i16> poison, i16 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i16> [[SPLAT_SPLATINSERT]], <vscale x 4 x i16> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 4 x i16> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i16> [[SHR]]
+//
+vuint16m1_t rshift_u16_lsplat(vuint16m1_t a, uint16_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_i32_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHL]]
+//
+vint32m1_t lshift_i32_rsplat(vint32m1_t a, int32_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_i32_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 2 x i32> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHL]]
+//
+vint32m1_t lshift_i32_lsplat(vint32m1_t a, int32_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_i32_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHR]]
+//
+vint32m1_t rshift_i32_rsplat(vint32m1_t a, int32_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_i32_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 2 x i32> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHR]]
+//
+vint32m1_t rshift_i32_lsplat(vint32m1_t a, int32_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_u32_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHL]]
+//
+vuint32m1_t lshift_u32_rsplat(vuint32m1_t a, uint32_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_u32_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 2 x i32> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHL]]
+//
+vuint32m1_t lshift_u32_lsplat(vuint32m1_t a, uint32_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_u32_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 2 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHR]]
+//
+vuint32m1_t rshift_u32_rsplat(vuint32m1_t a, uint32_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_u32_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i32> poison, i32 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i32> [[SPLAT_SPLATINSERT]], <vscale x 2 x i32> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 2 x i32> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i32> [[SHR]]
+//
+vuint32m1_t rshift_u32_lsplat(vuint32m1_t a, uint32_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_i64_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHL]]
+//
+vint64m1_t lshift_i64_rsplat(vint64m1_t a, int64_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_i64_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 1 x i64> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHL]]
+//
+vint64m1_t lshift_i64_lsplat(vint64m1_t a, int64_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_i64_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHR]]
+//
+vint64m1_t rshift_i64_rsplat(vint64m1_t a, int64_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_i64_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 1 x i64> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHR]]
+//
+vint64m1_t rshift_i64_lsplat(vint64m1_t a, int64_t b) {
+  return b >> a;
+}
+
+// CHECK-LABEL: @lshift_u64_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHL]]
+//
+vuint64m1_t lshift_u64_rsplat(vuint64m1_t a, uint64_t b) {
+  return a << b;
+}
+
+// CHECK-LABEL: @lshift_u64_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHL:%.*]] = shl <vscale x 1 x i64> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHL]]
+//
+vuint64m1_t lshift_u64_lsplat(vuint64m1_t a, uint64_t b) {
+  return b << a;
+}
+
+// CHECK-LABEL: @rshift_u64_rsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 1 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHR]]
+//
+vuint64m1_t rshift_u64_rsplat(vuint64m1_t a, uint64_t b) {
+  return a >> b;
+}
+
+// CHECK-LABEL: @rshift_u64_lsplat(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 1 x i64> poison, i64 [[B:%.*]], i64 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 1 x i64> [[SPLAT_SPLATINSERT]], <vscale x 1 x i64> poison, <vscale x 1 x i32> zeroinitializer
+// CHECK-NEXT:    [[SHR:%.*]] = ashr <vscale x 1 x i64> [[SPLAT_SPLAT]], [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 1 x i64> [[SHR]]
+//
+vuint64m1_t rshift_u64_lsplat(vuint64m1_t a, uint64_t b) {
+  return b >> a;
+}

clang/test/CodeGen/riscv-rvv-vla-subscript-ops.c

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple riscv64-none-linux-gnu -target-feature +zve64d \
+// RUN: -target-feature +f -target-feature +d -disable-O0-optnone \
+// RUN: -mvscale-min=4 -mvscale-max=4 -emit-llvm -o - %s | \
+// RUN: opt -S -passes=sroa | FileCheck %s
+
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+// CHECK-LABEL: @subscript_int8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 8 x i8> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i8 [[VECEXT]]
+//
+int8_t subscript_int8(vint8m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_uint8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 8 x i8> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i8 [[VECEXT]]
+//
+uint8_t subscript_uint8(vuint8m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_int16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 4 x i16> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i16 [[VECEXT]]
+//
+int16_t subscript_int16(vint16m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_uint16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 4 x i16> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i16 [[VECEXT]]
+//
+uint16_t subscript_uint16(vuint16m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_int32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 2 x i32> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i32 [[VECEXT]]
+//
+int32_t subscript_int32(vint32m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_uint32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 2 x i32> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i32 [[VECEXT]]
+//
+uint32_t subscript_uint32(vuint32m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_int64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 1 x i64> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i64 [[VECEXT]]
+//
+int64_t subscript_int64(vint64m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_uint64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 1 x i64> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret i64 [[VECEXT]]
+//
+uint64_t subscript_uint64(vuint64m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_float32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 2 x float> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret float [[VECEXT]]
+//
+float subscript_float32(vfloat32m1_t a, size_t b) {
+  return a[b];
+}
+
+// CHECK-LABEL: @subscript_float64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[VECEXT:%.*]] = extractelement <vscale x 1 x double> [[A:%.*]], i64 [[B:%.*]]
+// CHECK-NEXT:    ret double [[VECEXT]]
+//
+double subscript_float64(vfloat64m1_t a, size_t b) {
+  return a[b];
+}

clang/test/Sema/riscv-rvv-vector-arith-ops.c

+// RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-feature +d \
+// RUN:   -target-feature +v -target-feature +zfh -target-feature +zvfh \
+// RUN:   -disable-O0-optnone -o - -fsyntax-only %s -verify 
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+struct S {
+  int x;
+};
+
+void add(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b, struct S s) {
+  (void)(i8 + b); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 + i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 + i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 + i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 + u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 + u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 + u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 + f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 + f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 + f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 + i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 + i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 + i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 + u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 + u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 + u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 + f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 + f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 + f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 + i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 + i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 + i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 + u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 + u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 + u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 + f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 + f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 + f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 + i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 + i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 + i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 + u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 + u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 + u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 + f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 + f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 + f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 + i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 + i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 + i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 + u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 + u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 + u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 + f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 + f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 + f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 + i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 + i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 + i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 + u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 + u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 + u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 + f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 + f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 + f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 + i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 + i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 + i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 + u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 + u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 + u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 + f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 + f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 + f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 + i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 + i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 + i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 + u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 + u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 + u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 + f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 + f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 + f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 + i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 + i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 + i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 + i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 + u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 + u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 + u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 + f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 + f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 + i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 + i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 + i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 + i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 + u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 + u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 + u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 + f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 + f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 + b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 + i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 + i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 + i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 + i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 + u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 + u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 + u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 + f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 + f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+
+  (void)(s + i8); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + i16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + i32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + i64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + u16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + u32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + u64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + f16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + f32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s + f64); // expected-error{{cannot convert between vector and non-scalar values}}
+}
+
+void sub(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b, struct S s) {
+  (void)(i8 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 - i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 - i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 - i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 - u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 - u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 - u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 - f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 - f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 - f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 - i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 - i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 - i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 - u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 - u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 - u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 - f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 - f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 - f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 - i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 - i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 - i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 - u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 - u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 - u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 - f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 - f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 - f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 - i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 - i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 - i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 - u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 - u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 - u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 - f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 - f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 - f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 - i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 - i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 - i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 - u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 - u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 - u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 - f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 - f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 - f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 - i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 - i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 - i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 - u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 - u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 - u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 - f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 - f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 - f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 - i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 - i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 - i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 - u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 - u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 - u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 - f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 - f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 - f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 - i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 - i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 - i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 - u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 - u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 - u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 - f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 - f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 - f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 - i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 - i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 - i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 - i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 - u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 - u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 - u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 - f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 - f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 - i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 - i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 - i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 - i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 - u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 - u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 - u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 - f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 - f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 - b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 - i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 - i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 - i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 - i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 - u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 - u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 - u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 - f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 - f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+
+  (void)(s - i8);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - i16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - i32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - i64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - u16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - u32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - u64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - f16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - f32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s - f64); // expected-error{{cannot convert between vector and non-scalar values}}
+}
+
+void mul(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b, struct S s) {
+  (void)(i8 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 * i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 * i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 * i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 * u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 * u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 * u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 * f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 * f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 * f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 * i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 * i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 * i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 * u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 * u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 * u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 * f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 * f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 * f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 * i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 * i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 * i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 * u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 * u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 * u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 * f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 * f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 * f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 * i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 * i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 * i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 * u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 * u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 * u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 * f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 * f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 * f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 * i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 * i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 * i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 * u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 * u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 * u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 * f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 * f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 * f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 * i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 * i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 * i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 * u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 * u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 * u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 * f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 * f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 * f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 * i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 * i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 * i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 * u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 * u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 * u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 * f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 * f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 * f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 * i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 * i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 * i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 * u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 * u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 * u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 * f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 * f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 * f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 * i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 * i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 * i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 * i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 * u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 * u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 * u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 * f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 * f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 * i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 * i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 * i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 * i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 * u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 * u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 * u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 * f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 * f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 * b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 * i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 * i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 * i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 * i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 * u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 * u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 * u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 * f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 * f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+
+  (void)(s * i8);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * i16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * i32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * i64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * u16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * u32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * u64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * f16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * f32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s * f64); // expected-error{{cannot convert between vector and non-scalar values}}
+}
+
+void div(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b, struct S s) {
+  (void)(i8 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 / i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 / i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 / i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 / u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 / u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 / u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 / f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 / f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 / f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 / i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 / i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 / i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 / u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 / u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 / u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 / f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 / f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 / f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 / i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 / i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 / i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 / u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 / u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 / u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 / f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 / f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 / f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 / i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 / i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 / i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 / u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 / u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 / u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 / f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 / f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 / f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 / i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 / i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 / i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 / u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 / u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 / u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 / f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 / f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 / f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 / i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 / i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 / i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 / u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 / u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 / u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 / f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 / f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 / f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 / i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 / i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 / i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 / u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 / u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 / u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 / f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 / f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 / f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 / i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 / i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 / i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 / u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 / u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 / u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 / f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 / f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 / f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 / i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 / i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 / i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 / i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 / u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 / u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 / u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 / f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 / f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 / i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 / i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 / i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 / i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 / u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 / u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 / u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 / f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 / f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 / b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 / i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 / i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 / i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 / i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 / u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 / u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 / u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 / f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 / f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+
+  (void)(s / i8);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / i16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / i32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / i64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / u16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / u32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / u64); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / f16); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / f32); // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(s / f64); // expected-error{{cannot convert between vector and non-scalar values}}
+}
+
+void mod(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b, struct S s) {
+  (void)(i8 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 % i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 % i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 % u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 % u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 % u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u8 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 % i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 % i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 % u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 % u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 % u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i16 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 % i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 % i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 % u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 % u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 % u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u16 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 % i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 % i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 % u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 % u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 % u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i32 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 % i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 % i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 % u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 % u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 % u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u32 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 % i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 % i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 % u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 % u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 % u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i64 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 % i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 % i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 % u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 % u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 % u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u64 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 % i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 % i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 % u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 % u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 % u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f16 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f32 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 % b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % f32); // expected-error{{invalid operands to binary expression}}
+
+  (void)(s % i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(s % i16); // expected-error{{invalid operands to binary expression}}
+  (void)(s % i32); // expected-error{{invalid operands to binary expression}}
+  (void)(s % i64); // expected-error{{invalid operands to binary expression}}
+  (void)(s % u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(s % u16); // expected-error{{invalid operands to binary expression}}
+  (void)(s % u32); // expected-error{{invalid operands to binary expression}}
+  (void)(s % f16); // expected-error{{invalid operands to binary expression}}
+  (void)(s % f32); // expected-error{{invalid operands to binary expression}}
+}
+
+vint8m8_t svi8(vint8m8_t a) {
+  return a + 256; // expected-error{{cannot convert between scalar type 'int' and vector type 'vint8m8_t' (aka '__rvv_int8m8_t') as implicit conversion would cause truncation}}
+}
+
+vint8m8_t svi8_128(vint8m8_t a) {
+  return a + 128; // expected-warning{{implicit conversion from 'int' to 'vint8m8_t' (aka '__rvv_int8m8_t') changes value from 128 to -128}}
+}

clang/test/Sema/riscv-rvv-vector-bitwise-ops.c

+// RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-feature +d \
+// RUN:   -target-feature +v -target-feature +zfh -target-feature +zvfh \
+// RUN:   -disable-O0-optnone -o - -fsyntax-only %s -verify 
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+void and (vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+          vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+          vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+          vbool1_t b) {
+  (void)(i8 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 & i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 & i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 & i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 & u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 & u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 & u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u8 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 & i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 & i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 & i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 & u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 & u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 & u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i16 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 & i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 & i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 & i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 & u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 & u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 & u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u16 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 & i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 & i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 & i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 & u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 & u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 & u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i32 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i32 & i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 & i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 & i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 & u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 & u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 & u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u32 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 & i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 & i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 & i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 & u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 & u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 & u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i64 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 & i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 & i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 & i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 & u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 & u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 & u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u64 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 & i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 & i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 & i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 & u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 & u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 & u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f16 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f32 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & f64); // expected-error{{invalid operands to binary expression}}
+}
+
+void or (vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b) {
+  (void)(i8 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 | i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 | i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 | i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 | u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 | u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 | u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u8 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 | i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 | i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 | i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 | u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 | u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 | u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i16 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 | i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 | i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 | i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 | u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 | u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 | u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u16 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 | i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 | i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 | i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 | u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 | u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 | u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i32 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i32 | i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 | i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 | i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 | u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 | u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 | u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u32 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 | i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 | i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 | i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 | u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 | u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 | u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i64 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 | i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 | i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 | i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 | u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 | u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 | u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u64 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 | i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 | i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 | i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 | u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 | u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 | u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f16 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f32 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | f64); // expected-error{{invalid operands to binary expression}}
+}
+
+void xor (vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64, vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64, vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64, vbool1_t b) {
+  (void)(i8 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 ^ i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 ^ i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 ^ i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 ^ u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 ^ u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 ^ u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u8 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 ^ i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 ^ i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 ^ i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 ^ u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 ^ u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 ^ u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i16 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 ^ i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 ^ i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 ^ u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 ^ u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u16 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 ^ i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 ^ i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 ^ u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 ^ u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i32 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i32 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 ^ i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 ^ i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 ^ u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 ^ u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u32 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 ^ i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 ^ i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 ^ u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 ^ u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i64 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 ^ i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 ^ i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 ^ u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 ^ u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(u64 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 ^ i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 ^ i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 ^ u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 ^ u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f16 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f32 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ f64); // expected-error{{invalid operands to binary expression}}
+}
+
+    void not(vfloat16m4_t f16, vfloat32m2_t f32, vfloat32m2_t f64) {
+  (void)(~f16); // expected-error{{invalid argument type}}
+  (void)(~f32); // expected-error{{invalid argument type}}
+  (void)(~f64); // expected-error{{invalid argument type}}
+}

clang/test/Sema/riscv-rvv-vector-compare-ops.c

+// RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-feature +d \
+// RUN:   -target-feature +v -target-feature +zfh -target-feature +zvfh \
+// RUN:   -disable-O0-optnone -o - -fsyntax-only %s -verify 
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+void eq(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+        vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+        vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+        vbool1_t b) {
+  (void)(i8 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 == i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 == i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 == i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 == u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 == u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 == u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 == f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 == f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 == f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 == i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 == i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 == i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 == u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 == u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 == u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 == f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 == f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 == f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 == i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 == i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 == i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 == u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 == u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 == u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 == f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 == f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 == f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 == i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 == i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 == i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 == u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 == u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 == u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 == f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 == f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 == f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 == i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 == i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 == i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 == u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 == u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 == u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 == f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 == f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 == f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 == i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 == i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 == i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 == u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 == u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 == u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 == f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 == f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 == f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 == i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 == i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 == i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 == u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 == u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 == u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 == f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 == f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 == f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 == i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 == i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 == i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 == u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 == u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 == u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 == f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 == f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 == f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 == i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 == i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 == i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 == i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 == u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 == u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 == u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 == f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 == f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 == i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 == i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 == i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 == i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 == u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 == u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 == u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 == f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 == f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 == b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 == i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 == i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 == i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 == i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 == u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 == u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 == u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 == f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 == f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+}
+
+void neq(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b) {
+  (void)(i8 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 != i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 != i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 != i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 != u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 != u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 != u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 != f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 != f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 != f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 != i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 != i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 != i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 != u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 != u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 != u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 != f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 != f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 != f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 != i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 != i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 != i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 != u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 != u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 != u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 != f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 != f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 != f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 != i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 != i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 != i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 != u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 != u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 != u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 != f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 != f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 != f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 != i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 != i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 != i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 != u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 != u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 != u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 != f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 != f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 != f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 != i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 != i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 != i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 != u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 != u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 != u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 != f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 != f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 != f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 != i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 != i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 != i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 != u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 != u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 != u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 != f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 != f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 != f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 != i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 != i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 != i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 != u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 != u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 != u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 != f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 != f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 != f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 != i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 != i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 != i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 != i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 != u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 != u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 != u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 != f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 != f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 != i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 != i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 != i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 != i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 != u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 != u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 != u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 != f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 != f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 != b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 != i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 != i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 != i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 != i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 != u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 != u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 != u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 != f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 != f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+}
+
+void lt(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+        vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+        vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+        vbool1_t b) {
+  (void)(i8 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 < i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 < i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 < i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 < u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 < u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 < u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 < f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 < f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 < f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 < i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 < i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 < i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 < u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 < u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 < u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 < f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 < f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 < f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 < i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 < i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 < i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 < u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 < u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 < u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 < f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 < f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 < f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 < i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 < i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 < i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 < u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 < u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 < u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 < f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 < f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 < f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 < i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 < i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 < i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 < u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 < u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 < u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 < f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 < f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 < f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 < i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 < i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 < i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 < u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 < u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 < u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 < f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 < f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 < f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 < i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 < i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 < i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 < u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 < u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 < u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 < f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 < f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 < f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 < i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 < i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 < i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 < u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 < u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 < u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 < f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 < f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 < f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 < i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 < i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 < i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 < i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 < u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 < u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 < u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 < f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 < f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 < i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 < i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 < i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 < i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 < u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 < u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 < u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 < f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 < f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 < b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 < i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 < i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 < i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 < i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 < u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 < u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 < u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 < f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 < f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+}
+
+void leq(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b) {
+  (void)(i8 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 <= i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 <= i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 <= i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 <= u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 <= u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 <= u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 <= f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 <= f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 <= f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 <= i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 <= i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 <= i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 <= u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 <= u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 <= u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 <= f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 <= f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 <= f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 <= i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 <= i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 <= u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 <= u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 <= f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 <= f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 <= i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 <= i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 <= u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 <= u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 <= f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 <= f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 <= i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 <= i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 <= u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 <= u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 <= f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 <= f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 <= i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 <= i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 <= u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 <= u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 <= f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 <= f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 <= i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 <= i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 <= u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 <= u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 <= f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 <= f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 <= f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 <= i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 <= i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 <= u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 <= u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 <= f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 <= f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 <= f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 <= i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 <= i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 <= u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 <= u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 <= f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 <= f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 <= i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 <= i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 <= u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 <= u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 <= f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 <= f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 <= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 <= i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 <= i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 <= i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 <= i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 <= u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 <= u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 <= f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 <= f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+}
+
+void gt(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+        vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+        vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+        vbool1_t b) {
+  (void)(i8 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 > i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 > i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 > i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 > u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 > u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 > u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 > f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 > f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 > f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 > i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 > i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 > i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 > u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 > u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 > u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 > f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 > f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 > f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 > i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 > i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 > i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 > u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 > u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 > u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 > f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 > f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 > f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 > i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 > i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 > i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 > u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 > u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 > u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 > f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 > f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 > f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 > i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 > i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 > i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 > u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 > u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 > u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 > f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 > f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 > f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 > i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 > i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 > i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 > u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 > u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 > u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 > f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 > f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 > f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 > i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 > i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 > i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 > u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 > u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 > u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 > f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 > f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 > f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 > i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 > i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 > i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 > u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 > u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 > u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 > f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 > f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 > f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 > i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 > i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 > i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 > i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 > u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 > u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 > u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 > f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 > f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 > i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 > i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 > i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 > i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 > u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 > u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 > u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 > f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 > f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 > b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 > i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 > i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 > i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 > i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 > u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 > u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 > u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 > f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 > f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+}
+
+void geq(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+         vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+         vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+         vbool1_t b) {
+  (void)(i8 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i8 >= i16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i8 >= i32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i8 >= i64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i8 >= u16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i8 >= u32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i8 >= u64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i8 >= f16); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i8 >= f32); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i8 >= f64); // expected-error{{vector operands do not have the same number of elements ('vint8m8_t' (aka '__rvv_int8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u8 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u8 >= i16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u8 >= i32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u8 >= i64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u8 >= u16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u8 >= u32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u8 >= u64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u8 >= f16); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u8 >= f32); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u8 >= f64); // expected-error{{vector operands do not have the same number of elements ('vuint8m8_t' (aka '__rvv_uint8m8_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i16 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i16 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i16 >= i32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i16 >= i64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i16 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i16 >= u32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i16 >= u64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i16 >= f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vint16m4_t' (aka '__rvv_int16m4_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= f32); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i16 >= f64); // expected-error{{vector operands do not have the same number of elements ('vint16m4_t' (aka '__rvv_int16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u16 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u16 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u16 >= i32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u16 >= i64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u16 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u16 >= u32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u16 >= u64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u16 >= f16); // expected-error{{cannot convert between vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') and vector type 'vuint16m4_t' (aka '__rvv_uint16m4_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= f32); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u16 >= f64); // expected-error{{vector operands do not have the same number of elements ('vuint16m4_t' (aka '__rvv_uint16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i32 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i32 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i32 >= i16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i32 >= i64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(i32 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i32 >= u16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i32 >= u64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(i32 >= f16); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i32 >= f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vint32m2_t' (aka '__rvv_int32m2_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= f64); // expected-error{{vector operands do not have the same number of elements ('vint32m2_t' (aka '__rvv_int32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(u32 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u32 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u32 >= i16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u32 >= i64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(u32 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u32 >= u16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u32 >= u64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(u32 >= f16); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u32 >= f32); // expected-error{{cannot convert between vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') and vector type 'vuint32m2_t' (aka '__rvv_uint32m2_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= f64); // expected-error{{vector operands do not have the same number of elements ('vuint32m2_t' (aka '__rvv_uint32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(i64 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(i64 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(i64 >= i16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(i64 >= i32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(i64 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(i64 >= u16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(i64 >= u32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(i64 >= f16); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(i64 >= f32); // expected-error{{vector operands do not have the same number of elements ('vint64m1_t' (aka '__rvv_int64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(i64 >= f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vint64m1_t' (aka '__rvv_int64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(u64 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(u64 >= i16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(u64 >= i32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(u64 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(u64 >= u16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(u64 >= u32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(u64 >= f16); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(u64 >= f32); // expected-error{{vector operands do not have the same number of elements ('vuint64m1_t' (aka '__rvv_uint64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(u64 >= f64); // expected-error{{cannot convert between vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') and vector type 'vuint64m1_t' (aka '__rvv_uint64m1_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f16 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f16 >= i16); // expected-error{{cannot convert between vector type 'vint16m4_t' (aka '__rvv_int16m4_t') and vector type 'vfloat16m4_t' (aka '__rvv_float16m4_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= i32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f16 >= i64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f16 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f16 >= u32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f16 >= u64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f16 >= f32); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+  (void)(f16 >= f64); // expected-error{{vector operands do not have the same number of elements ('vfloat16m4_t' (aka '__rvv_float16m4_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f32 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f32 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f32 >= i16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f32 >= i32); // expected-error{{cannot convert between vector type 'vint32m2_t' (aka '__rvv_int32m2_t') and vector type 'vfloat32m2_t' (aka '__rvv_float32m2_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= i64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vint64m1_t' (aka '__rvv_int64m1_t'))}}
+  (void)(f32 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f32 >= u16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f32 >= u64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vuint64m1_t' (aka '__rvv_uint64m1_t'))}}
+  (void)(f32 >= f16); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f32 >= f64); // expected-error{{vector operands do not have the same number of elements ('vfloat32m2_t' (aka '__rvv_float32m2_t') and 'vfloat64m1_t' (aka '__rvv_float64m1_t'))}}
+
+  (void)(f64 >= b);   // expected-error{{cannot convert between vector and non-scalar values}}
+  (void)(f64 >= i8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint8m8_t' (aka '__rvv_int8m8_t'))}}
+  (void)(f64 >= i16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint16m4_t' (aka '__rvv_int16m4_t'))}}
+  (void)(f64 >= i32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vint32m2_t' (aka '__rvv_int32m2_t'))}}
+  (void)(f64 >= i64); // expected-error{{cannot convert between vector type 'vint64m1_t' (aka '__rvv_int64m1_t') and vector type 'vfloat64m1_t' (aka '__rvv_float64m1_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= u8);  // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint8m8_t' (aka '__rvv_uint8m8_t'))}}
+  (void)(f64 >= u16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint16m4_t' (aka '__rvv_uint16m4_t'))}}
+  (void)(f64 >= u32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vuint32m2_t' (aka '__rvv_uint32m2_t'))}}
+  (void)(f64 >= f16); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat16m4_t' (aka '__rvv_float16m4_t'))}}
+  (void)(f64 >= f32); // expected-error{{vector operands do not have the same number of elements ('vfloat64m1_t' (aka '__rvv_float64m1_t') and 'vfloat32m2_t' (aka '__rvv_float32m2_t'))}}
+}

clang/test/Sema/riscv-rvv-vector-shift-ops.c

+// RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-feature +d \
+// RUN:   -target-feature +v -target-feature +zfh -target-feature +zvfh \
+// RUN:   -disable-O0-optnone -o - -fsyntax-only %s -verify 
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+void lshift(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+            vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+            vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+            vbool1_t b) {
+  (void)(b << b); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i8 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i8 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i8 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i8 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i8 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u8 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u8 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u8 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u8 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u8 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u8 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(i16 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i16 << i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i16 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i16 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i16 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i16 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u16 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u16 << i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u16 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u16 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u16 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u16 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(i32 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i32 << i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i32 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i32 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i32 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i32 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u32 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u32 << i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u32 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u32 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u32 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u32 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(i64 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i64 << i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i64 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i64 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i64 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i64 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u64 << b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u64 << i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u64 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u64 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u64 << 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u64 << 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(f16 << b);   // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << i8);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << i16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << i32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << i64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << u8);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << u32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << u64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << f32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << f64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << 0.f); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 << 0.);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+
+  (void)(f32 << b);   // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << i8);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << i16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << i32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << i64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << u8);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << u16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << u64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << f16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << f64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 << 0.);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+
+  (void)(f64 << b);   // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << i8);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << i16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << i32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << i64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << u8);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << u16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << u32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << f16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << f32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 << 0.f); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+
+  (void)(b << i8);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i16 << i8); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << i8); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << i8); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << i8); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << i8); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << i8); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << i8); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << i8); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << i8); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << i8); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << i8);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << u8);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i16 << u8); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << u8); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << u8); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << u8); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << u8); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << u8); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << u8); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << u8); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << u8); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << u8); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << u8);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << i16);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << i16);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << i16);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << i16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << i16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << i16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << i16); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << i16);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << u16);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << u16);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << u16);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << u16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << u16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << u16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << u16); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << u16);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << i32);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << i32);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << i32);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << i32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << i32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << i32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << i32); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << i32);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << u32);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << u32);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << u32);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 << u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << u32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << u32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << u32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << u32); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << u32);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << i64);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << i64);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << i64);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << i64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << i64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << i64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << i64); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << i64);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << u64);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << u64);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 << u64);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 << u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 << u64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << u64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << u64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << u64); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << u64);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << f16);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << f16);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i16 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i32 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i64 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u8 << f16);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u32 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u64 << f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << f16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 << f16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f << f16); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. << f16);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << f32);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << f32);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i16 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i32 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i64 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u8 << f32);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u16 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u64 << f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f16 << f32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f64 << f32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0. << f32);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b << f64);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 << f64);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i16 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i32 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i64 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u8 << f64);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u16 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u32 << f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f16 << f64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 << f64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(0.f << f64); // expected-error{{used type 'float' where integer is required}}
+}
+
+void rshift(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+            vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+            vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+            vbool1_t b) {
+  (void)(b >> b); // expected-error{{invalid operands to binary expression}}
+
+  (void)(i8 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i8 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i8 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i8 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i8 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u8 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u8 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u8 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u8 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u8 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u8 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(i16 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i16 >> i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i16 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i16 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i16 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i16 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u16 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u16 >> i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u16 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u16 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u16 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u16 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(i32 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i32 >> i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i32 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i32 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i32 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i32 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u32 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u32 >> i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u32 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u32 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u32 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u32 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(i64 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i64 >> i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i64 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i64 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i64 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(i64 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(u64 >> b);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(u64 >> i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u64 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u64 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u64 >> 0.f); // expected-error{{used type 'float' where integer is required}}
+  (void)(u64 >> 0.);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(f16 >> b);   // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> i8);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> i16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> i32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> i64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> u8);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> u32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> u64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> f32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> f64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> 0.f); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f16 >> 0.);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+
+  (void)(f32 >> b);   // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> i8);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> i16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> i32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> i64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> u8);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> u16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> u64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> f16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> f64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f32 >> 0.);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+
+  (void)(f64 >> b);   // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> i8);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> i16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> i32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> i64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> u8);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> u16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> u32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> f16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> f32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f64 >> 0.f); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+
+  (void)(b >> i8);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i16 >> i8); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> i8); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> i8); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> i8); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> i8); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> i8); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> i8); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> i8); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> i8); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> i8); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> i8);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> u8);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i16 >> u8); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> u8); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> u8); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> u8); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> u8); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> u8); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> u8); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> u8); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> u8); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> u8); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> u8);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> i16);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> i16);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> i16);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> i16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> i16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> i16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> i16); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> i16);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> u16);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> u16);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> u16);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> u16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> u16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> u16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> u16); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> u16);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> i32);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> i32);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> i32);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> i32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> i32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> i32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> i32); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> i32);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> u32);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> u32);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> u32);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 >> u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> u32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> u32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> u32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> u32); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> u32);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> i64);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> i64);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> i64);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> i64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> i64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> i64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> i64); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> i64);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> u64);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> u64);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 >> u64);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 >> u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 >> u64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> u64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> u64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> u64); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> u64);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> f16);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> f16);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i16 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i32 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(i64 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u8 >> f16);  // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u32 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(u64 >> f16); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> f16); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f64 >> f16); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0.f >> f16); // expected-error{{used type 'float' where integer is required}}
+  (void)(0. >> f16);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> f32);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> f32);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i16 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i32 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(i64 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u8 >> f32);  // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u16 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(u64 >> f32); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(f16 >> f32); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f64 >> f32); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(0. >> f32);  // expected-error{{used type 'double' where integer is required}}
+
+  (void)(b >> f64);   // expected-error{{used type 'vbool1_t' (aka '__rvv_bool1_t') where integer is required}}
+  (void)(i8 >> f64);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i16 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i32 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(i64 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u8 >> f64);  // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u16 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(u32 >> f64); // expected-error{{used type 'vfloat64m1_t' (aka '__rvv_float64m1_t') where integer is required}}
+  (void)(f16 >> f64); // expected-error{{used type 'vfloat16m4_t' (aka '__rvv_float16m4_t') where integer is required}}
+  (void)(f32 >> f64); // expected-error{{used type 'vfloat32m2_t' (aka '__rvv_float32m2_t') where integer is required}}
+  (void)(0.f >> f64); // expected-error{{used type 'float' where integer is required}}
+}

clang/test/Sema/riscv-rvv-vector-subscript-ops.c

+// RUN: %clang_cc1 -triple riscv64 -target-feature +f -target-feature +d \
+// RUN:   -target-feature +v -target-feature +zfh -target-feature +zvfh \
+// RUN:   -disable-O0-optnone -o - -fsyntax-only %s -verify 
+// REQUIRES: riscv-registered-target
+
+#include <riscv_vector.h>
+
+void subscript(vint8m8_t i8, vint16m4_t i16, vint32m2_t i32, vint64m1_t i64,
+               vuint8m8_t u8, vuint16m4_t u16, vuint32m2_t u32, vuint64m1_t u64,
+               vfloat16m4_t f16, vfloat32m2_t f32, vfloat64m1_t f64,
+               vbool1_t b) {
+  (void)b[0];    // expected-error{{subscripted value is not an array, pointer, or vector}}
+  (void)b[0.f];  // expected-error{{subscripted value is not an array, pointer, or vector}}
+  (void)b[0.];   // expected-error{{subscripted value is not an array, pointer, or vector}}
+
+  (void)i8[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)i8[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)u8[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)u8[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)i16[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)i16[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)u16[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)u16[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)i32[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)i32[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)u32[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)u32[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)i64[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)i64[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)u64[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)u64[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)f16[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)f16[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)f32[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)f32[0.];  // expected-error{{array subscript is not an integer}}
+
+  (void)f64[0.f]; // expected-error{{array subscript is not an integer}}
+  (void)f64[0.];  // expected-error{{array subscript is not an integer}}
+}