[clang][AArch64][SVE] Improve diagnostics for SVE operators

[DavidTruby]

Summary

This patch corrects some diagnostics for the SVE sizeless vector
operators, including correctly diagnosing when the vectors are
different sizes.

[DavidTruby]

Bug fix

[c-rhodes]

clang/lib/Sema/SemaExpr.cpp

10613–10618

why is this removed?

10618

missing a test for this?

clang/test/Sema/aarch64-sve-vector-arith-ops.c

23

I think these vector + imm tests should be removed in D126380 but fine to keep here if it's easier

[DavidTruby]

clang/lib/Sema/SemaExpr.cpp

10613–10618

This is sort of an artefact of splitting this and D126380; essentially that patch was motivated by the fact that this code here doesn't really do anything meaningful for scalable vectors. I added it for symmetry with non-scalable vectors but the triggers for conversions here don't really fire in meaningful code.
Doing this properly is resolved in D126380 so I could remove it there instead but this code didn't really work and doesn't have tests anyway.

10618

I wrote this test but seem to have forgotten to add it... Will do that!

clang/test/Sema/aarch64-sve-vector-arith-ops.c

23

Ah yes I missed this, you're correct but I will be pushing the two patches at the same time so I guess it doesn't matter much except for correct history? Happy to change it though.

[c-rhodes]

clang/test/Sema/aarch64-sve-vector-arith-ops.c

23

Ah yes I missed this, you're correct but I will be pushing the two patches at the same time so I guess it doesn't matter much except for correct history? Happy to change it though.

Yeah no worries keep them in here, thanks for clarifying

[DavidTruby]

add tests for vector non-scalar diagnostic

[c-rhodes]

LGTM

clang/lib/Sema/SemaExpr.cpp

QualType Sema::CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS,
   }
   RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
   if (RHS.isInvalid())
     return QualType();
 
   QualType LHSType = LHS.get()->getType().getUnqualifiedType();
   QualType RHSType = RHS.get()->getType().getUnqualifiedType();
 
+  const BuiltinType *LHSBuiltinTy = LHSType->getAs<BuiltinType>();
+  const BuiltinType *RHSBuiltinTy = RHSType->getAs<BuiltinType>();
+
   unsigned DiagID = diag::err_typecheck_invalid_operands;
   if ((OperationKind == ACK_Arithmetic) &&
-      (LHSType->castAs<BuiltinType>()->isSVEBool() ||
-       RHSType->castAs<BuiltinType>()->isSVEBool())) {
+      ((LHSBuiltinTy && LHSBuiltinTy->isSVEBool()) ||
+       (RHSBuiltinTy && RHSBuiltinTy->isSVEBool()))) {
     Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                       << RHS.get()->getSourceRange();
     return QualType();
   }
 
   if (Context.hasSameType(LHSType, RHSType))
     return LHSType;
 
QualType Sema::CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS,
 
   if (LHSType->isVLSTBuiltinType() && !RHSType->isVLSTBuiltinType()) {
     auto DestType = tryScalableVectorConvert(&RHS, RHSType, LHSType);
     if (DestType == QualType())
       return InvalidOperands(Loc, LHS, RHS);
     return DestType;
   }
 
-  if (RHSType->isVLSTBuiltinType() && !LHSType->isVLSTBuiltinType()) {
-    auto DestType = tryScalableVectorConvert((IsCompAssign ? nullptr : &LHS),
-                                             LHSType, RHSType);
-    if (DestType == QualType())
-      return InvalidOperands(Loc, LHS, RHS);
-    return DestType;
+  if ((!LHSType->isVLSTBuiltinType() && !LHSType->isRealType()) ||
+      (!RHSType->isVLSTBuiltinType() && !RHSType->isRealType())) {
+    Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
+        << LHSType << RHSType << LHS.get()->getSourceRange()
+        << RHS.get()->getSourceRange();
+    return QualType();
+  }
+
+  if (LHSType->isVLSTBuiltinType() && RHSType->isVLSTBuiltinType() &&
+      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->isVLSTBuiltinType() || RHSType->isVLSTBuiltinType()) {
+    QualType Scalar = LHSType->isVLSTBuiltinType() ? RHSType : LHSType;
+    QualType Vector = LHSType->isVLSTBuiltinType() ? LHSType : RHSType;
+    bool ScalarOrVector =
+        LHSType->isVLSTBuiltinType() && RHSType->isVLSTBuiltinType();
+
+    Diag(Loc, diag::err_typecheck_vector_not_convertable_implict_truncation)
+        << ScalarOrVector << Scalar << Vector;
+
+    return QualType();
   }
 
   Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                     << RHS.get()->getSourceRange();
   return QualType();
 }
 
 // checkArithmeticNull - Detect when a NULL constant is used improperly in an

clang/test/Sema/aarch64-sve-vector-arith-ops.c

 // RUN: %clang_cc1 -verify -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only %s
 
 // REQUIRES: aarch64-registered-target
 
 #include <arm_sve.h>
 
+struct S {
+  int x;
+};
+
 void add(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
-         svbool_t b) {
+         svbool_t b, struct S s) {
   (void)(b + b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 + b); // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i8 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i8 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 + i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 + i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 + u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 + u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 + u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 + f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 + f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 + f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u8 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u8 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u8 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 + i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 + i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 + u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 + u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 + u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 + f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 + f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 + f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i16 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i16 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i16 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 + i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 + i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 + u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 + u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 + u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 + f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u16 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u16 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u16 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 + i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 + i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 + u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 + u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 + u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 + f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i32 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i32 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 + i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 + i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 + i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 + u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 + u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 + u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 + f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u32 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u32 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u32 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u32 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 + i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 + i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 + i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 + u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 + u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 + u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 + f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i64 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i64 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i64 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i64 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 + i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 + i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 + i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 + u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 + u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 + u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 + f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 + f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
 
   (void)(u64 + b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u64 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u64 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u64 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 + i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 + i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 + i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 + u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 + u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 + u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 + f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 + f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
 
   (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)(f16 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f16 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 + 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 + i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 + u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 + u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 + u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 + f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 + f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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)(f32 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f32 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f32 + 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 + i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 + i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 + u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 + u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 + u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 + f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 + f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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 + 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f64 + 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 + 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 + 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f64 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 + i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 + i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 + i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 + u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 + u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 + f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 + f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_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(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
-         svbool_t b) {
+         svbool_t b, struct S s) {
   (void)(b - b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i8 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i8 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 - i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 - i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 - u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 - u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 - u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 - f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 - f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 - f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u8 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u8 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u8 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 - i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 - i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 - u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 - u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 - u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 - f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 - f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 - f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i16 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i16 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i16 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 - i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 - i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 - u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 - u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 - u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 - f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u16 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u16 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u16 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 - i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 - i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 - u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 - u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 - u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 - f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i32 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i32 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 - i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 - i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 - i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 - u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 - u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 - u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 - f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u32 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u32 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u32 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u32 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 - i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 - i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 - i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 - u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 - u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 - u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 - f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i64 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i64 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i64 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i64 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 - i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 - i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 - i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 - u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 - u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 - u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 - f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 - f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
 
   (void)(u64 - b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u64 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u64 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u64 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 - i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 - i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 - i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 - u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 - u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 - u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 - f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 - f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
 
   (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)(f16 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f16 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 - 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 - i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 - u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 - u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 - u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 - f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 - f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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)(f32 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f32 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f32 - 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 - i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 - i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 - u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 - u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 - u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 - f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 - f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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 - 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f64 - 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 - 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 - 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f64 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 - i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 - i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 - i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 - u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 - u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 - f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 - f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_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(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
-         svbool_t b) {
+         svbool_t b, struct S s) {
   (void)(b * b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i8 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i8 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 * i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 * i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 * u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 * u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 * u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 * f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 * f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 * f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u8 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u8 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u8 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 * i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 * i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 * u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 * u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 * u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 * f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 * f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 * f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i16 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i16 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i16 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 * i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 * i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 * u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 * u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 * u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 * f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u16 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u16 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u16 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 * i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 * i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 * u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 * u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 * u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 * f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i32 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i32 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 * i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 * i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 * i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 * u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 * u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 * u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 * f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u32 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u32 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u32 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u32 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 * i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 * i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 * i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 * u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 * u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 * u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 * f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i64 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i64 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i64 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i64 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 * i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 * i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 * i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 * u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 * u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 * u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 * f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 * f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
 
   (void)(u64 * b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u64 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u64 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u64 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 * i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 * i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 * i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 * u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 * u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 * u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 * f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 * f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
 
   (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)(f16 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f16 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 * 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 * i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 * u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 * u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 * u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 * f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 * f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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)(f32 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f32 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f32 * 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 * i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 * i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 * u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 * u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 * u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 * f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 * f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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 * 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f64 * 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 * 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 * 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f64 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 * i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 * i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 * i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 * u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 * u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 * f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 * f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_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(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
-         svbool_t b) {
+         svbool_t b, struct S s) {
   (void)(b / b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i8 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i8 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 / i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 / i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 / u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 / u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 / u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 / f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 / f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 / f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u8 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u8 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u8 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 / i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 / i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 / u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 / u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 / u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 / f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 / f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 / f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i16 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i16 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i16 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 / i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 / i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 / u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 / u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 / u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 / f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u16 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u16 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u16 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 / i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 / i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 / u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 / u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 / u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 / f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i32 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i32 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 / i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 / i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 / i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 / u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 / u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 / u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 / f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(u32 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u32 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u32 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u32 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 / i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 / i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 / i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 / u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 / u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 / u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 / f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (void)(i64 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(i64 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i64 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i64 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 / i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 / i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 / i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 / u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 / u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 / u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 / f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 / f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
 
   (void)(u64 / b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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)(u64 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u64 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u64 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 / i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 / i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 / i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 / u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 / u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 / u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 / f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 / f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
 
   (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)(f16 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f16 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 / 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 / i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 / u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 / u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 / u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 / f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 / f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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)(f32 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f32 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f32 / 0.);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 / i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 / i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 / u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 / u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 / u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 / f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 / f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
 
   (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 / 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f64 / 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 / 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 / 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f64 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 / i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 / i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 / i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 / u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 / u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 / f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 / f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_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(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
-         svbool_t b) {
+         svbool_t b, struct S s) {
   (void)(b % b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 % i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 % i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 % u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 % u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 % u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_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)(i8 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i8 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i8 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i8 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u8 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 % i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 % i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 % u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 % u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 % u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_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)(u8 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u8 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u8 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u8 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i16 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 % i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 % i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 % u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 % u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 % u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_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)(i16 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i16 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i16 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i16 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u16 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 % i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 % i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 % u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 % u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 % u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_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)(u16 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u16 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u16 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u16 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i32 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 % i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 % i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 % u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 % u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 % u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_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)(i32 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i32 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i32 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u32 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 % i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 % i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 % u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 % u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 % u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_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)(u32 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u32 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u32 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u32 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i64 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 % i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 % i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 % u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 % u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 % u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_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)(i64 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(i64 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(i64 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(i64 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u64 % b);   // expected-error{{invalid operands to binary expression}}
-  (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 % i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 % i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 % i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 % u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 % u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 % u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_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)(u64 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(u64 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(u64 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(u64 % 0.);  // 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)(f16 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f16 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f16 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f16 % 0.);  // 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)(f32 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f32 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f32 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f32 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f32 % 0.);  // 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 % 0);   // expected-error{{invalid operands to binary expression}}
-  (void)(f64 % 0l);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 % 0u);  // expected-error{{invalid operands to binary expression}}
-  (void)(f64 % 0ul); // expected-error{{invalid operands to binary expression}}
-  (void)(f64 % 0.f); // expected-error{{invalid operands to binary expression}}
-  (void)(f64 % 0.);  // 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}}
 }

clang/test/Sema/aarch64-sve-vector-bitwise-ops.c

 // RUN: %clang_cc1 -verify -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only %s
 
 // REQUIRES: aarch64-registered-target
 
 #include <arm_sve.h>
 
 void and (svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
           svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
           svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
           svbool_t b) {
-  (void)(i8 & b);   // expected-error{{invalid operands to binary expression}}
-  (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 & b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 & i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 & i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 & i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 & u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 & u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 & u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_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{{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 & b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 & i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 & i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 & i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 & u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 & u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 & u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_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{{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 & b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 & i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 & i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 & i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 & u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 & u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 & u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_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{{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 & b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 & i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 & i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 & i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 & u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 & u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 & u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_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{{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 & b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 & i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 & i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 & i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 & u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 & u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 & u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_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{{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 & b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 & i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 & i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 & i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 & u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 & u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 & u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_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{{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 & b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 & i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 & i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 & i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 & u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 & u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 & u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_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{{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 & b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 & i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 & i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 & i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 & u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 & u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 & u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_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 and (svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
   (void)(f64 & f32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 & f64); // expected-error{{invalid operands to binary expression}}
 }
 
 void or (svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
-  (void)(i8 | b);   // expected-error{{invalid operands to binary expression}}
-  (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 | b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 | i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 | i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 | i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 | u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 | u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 | u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_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{{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 | b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 | i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 | i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 | i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 | u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 | u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 | u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_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{{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 | b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 | i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 | i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 | i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 | u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 | u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 | u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_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{{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 | b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 | i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 | i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 | i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 | u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 | u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 | u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_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{{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 | b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 | i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 | i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 | i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 | u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 | u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 | u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_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{{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 | b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 | i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 | i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 | i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 | u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 | u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 | u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_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{{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 | b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 | i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 | i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 | i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 | u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 | u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 | u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_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{{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 | b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 | i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 | i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 | i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 | u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 | u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 | u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_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 or (svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
   (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 (svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64, svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64, svfloat16_t f16, svfloat32_t f32, svfloat64_t f64, svbool_t b) {
-  (void)(i8 ^ b);   // expected-error{{invalid operands to binary expression}}
-  (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 ^ b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 ^ i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 ^ i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 ^ i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 ^ u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 ^ u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 ^ u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_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{{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 ^ b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 ^ i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 ^ i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 ^ i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 ^ u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 ^ u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 ^ u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_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{{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 ^ b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 ^ i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 ^ i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 ^ u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 ^ u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_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{{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 ^ b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 ^ i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 ^ i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 ^ u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 ^ u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_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{{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 ^ b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 ^ i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 ^ i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 ^ u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 ^ u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_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{{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 ^ b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 ^ i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 ^ i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 ^ u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 ^ u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_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{{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 ^ b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 ^ i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 ^ i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 ^ u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 ^ u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_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{{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 ^ b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 ^ i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 ^ i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 ^ i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 ^ u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 ^ u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 ^ u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_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}}

clang/test/Sema/aarch64-sve-vector-compare-ops.c

 // RUN: %clang_cc1 -verify -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only %s
 
 // REQUIRES: aarch64-registered-target
 
 #include <arm_sve.h>
 
 void eq(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
         svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
         svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
         svbool_t b) {
-  (void)(i8 == b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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)(i8 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 == i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 == i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 == u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 == u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 == u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 == f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 == f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 == f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u8 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 == i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 == i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 == u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 == u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 == u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 == f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 == f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 == f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i16 == b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 == i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 == i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 == i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 == u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 == u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 == u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 == f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u16 == b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 == i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 == i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 == i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 == u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 == u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 == u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 == f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i32 == b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 == i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 == i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 == i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 == u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 == u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 == u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 == f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u32 == b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 == i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 == i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 == i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 == u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 == u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 == u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 == f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i64 == b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 == i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 == i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 == i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 == u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 == u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 == u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 == f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 == f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 == b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 == i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 == i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 == i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 == u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 == u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 == u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 == f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 == f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 == b);   // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f16 == i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 == i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 == u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 == u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 == u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 == f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 == f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f32 == b);   // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f32 == i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 == i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 == u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 == u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 == u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 == f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 == f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f64 == b);   // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f64 == i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 == i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 == i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 == u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 == u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 == f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 == f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
 }
 
 void neq(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
-  (void)(i8 != b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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)(i8 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 != i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 != i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 != u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 != u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 != u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 != f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 != f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 != f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u8 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 != i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 != i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 != u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 != u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 != u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 != f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 != f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 != f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i16 != b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 != i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 != i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 != i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 != u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 != u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 != u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 != f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u16 != b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 != i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 != i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 != i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 != u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 != u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 != u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 != f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i32 != b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 != i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 != i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 != i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 != u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 != u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 != u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 != f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u32 != b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 != i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 != i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 != i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 != u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 != u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 != u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 != f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i64 != b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 != i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 != i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 != i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 != u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 != u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 != u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 != f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 != f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 != b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 != i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 != i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 != i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 != u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 != u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 != u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 != f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 != f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 != b);   // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f16 != i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 != i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 != u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 != u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 != u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 != f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 != f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f32 != b);   // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f32 != i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 != i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 != u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 != u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 != u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 != f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 != f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f64 != b);   // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f64 != i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 != i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 != i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 != u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 != u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 != f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 != f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
 }
 
 void lt(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
         svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
         svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
         svbool_t b) {
-  (void)(i8 < b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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)(i8 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 < i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 < i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 < u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 < u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 < u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 < f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 < f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 < f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u8 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 < i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 < i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 < u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 < u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 < u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 < f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 < f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 < f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i16 < b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 < i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 < i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 < i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 < u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 < u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 < u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 < f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u16 < b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 < i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 < i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 < i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 < u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 < u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 < u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 < f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i32 < b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 < i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 < i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 < i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 < u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 < u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 < u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 < f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u32 < b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 < i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 < i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 < i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 < u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 < u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 < u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 < f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i64 < b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 < i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 < i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 < i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 < u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 < u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 < u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 < f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 < f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 < b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 < i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 < i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 < i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 < u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 < u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 < u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 < f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 < f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 < b);   // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f16 < i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 < i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 < u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 < u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 < u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 < f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 < f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f32 < b);   // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f32 < i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 < i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 < u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 < u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 < u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 < f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 < f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f64 < b);   // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f64 < i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 < i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 < i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 < u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 < u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 < f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 < f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
 }
 
 void leq(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
-  (void)(i8 <= b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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)(i8 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 <= i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 <= i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 <= u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 <= u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 <= u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 <= f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 <= f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 <= f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u8 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 <= i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 <= i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 <= u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 <= u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 <= u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 <= f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 <= f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 <= f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i16 <= b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 <= i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 <= i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 <= u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 <= u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 <= f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u16 <= b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 <= i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 <= i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 <= u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 <= u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 <= f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i32 <= b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 <= i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 <= i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 <= u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 <= u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 <= f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u32 <= b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 <= i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 <= i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 <= u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 <= u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 <= f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i64 <= b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 <= i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 <= i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 <= u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 <= u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 <= f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 <= f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 <= b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 <= i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 <= i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 <= u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 <= u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 <= f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 <= f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 <= b);   // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f16 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 <= i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 <= u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 <= u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 <= f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 <= f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f32 <= b);   // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f32 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 <= i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 <= u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 <= u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 <= f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 <= f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f64 <= b);   // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f64 <= i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 <= i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 <= i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 <= u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 <= u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 <= f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 <= f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
 }
 
 void gt(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
         svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
         svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
         svbool_t b) {
-  (void)(i8 > b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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)(i8 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 > i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 > i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 > u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 > u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 > u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 > f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 > f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 > f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u8 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 > i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 > i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 > u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 > u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 > u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 > f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 > f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 > f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i16 > b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 > i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 > i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 > i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 > u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 > u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 > u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 > f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u16 > b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 > i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 > i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 > i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 > u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 > u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 > u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 > f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i32 > b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 > i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 > i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 > i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 > u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 > u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 > u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 > f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u32 > b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 > i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 > i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 > i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 > u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 > u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 > u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 > f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i64 > b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 > i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 > i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 > i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 > u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 > u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 > u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 > f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 > f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 > b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 > i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 > i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 > i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 > u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 > u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 > u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 > f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 > f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 > b);   // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f16 > i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 > i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 > u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 > u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 > u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 > f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 > f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f32 > b);   // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f32 > i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 > i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 > u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 > u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 > u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 > f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 > f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f64 > b);   // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f64 > i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 > i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 > i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 > u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 > u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 > f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 > f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
 }
 
 void geq(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
-  (void)(i8 >= b);   // expected-error{{invalid operands to binary expression}}
-  (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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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{{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)(i8 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= i16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i8 >= i32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i8 >= i64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i8 >= u16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i8 >= u32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i8 >= u64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i8 >= f16); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i8 >= f32); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i8 >= f64); // expected-error{{vector operands do not have the same number of elements ('svint8_t' (aka '__SVInt8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u8 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= i16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u8 >= i32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u8 >= i64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u8 >= u16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u8 >= u32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u8 >= u64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u8 >= f16); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u8 >= f32); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u8 >= f64); // expected-error{{vector operands do not have the same number of elements ('svuint8_t' (aka '__SVUint8_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i16 >= b);   // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i16 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i16 >= i32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i16 >= i64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i16 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i16 >= u32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i16 >= u64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i16 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= f32); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i16 >= f64); // expected-error{{vector operands do not have the same number of elements ('svint16_t' (aka '__SVInt16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u16 >= b);   // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u16 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u16 >= i32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u16 >= i64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u16 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u16 >= u32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u16 >= u64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u16 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= f32); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u16 >= f64); // expected-error{{vector operands do not have the same number of elements ('svuint16_t' (aka '__SVUint16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i32 >= b);   // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i32 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i32 >= i16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i32 >= i64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(i32 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i32 >= u16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i32 >= u64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(i32 >= f16); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i32 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= f64); // expected-error{{vector operands do not have the same number of elements ('svint32_t' (aka '__SVInt32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(u32 >= b);   // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u32 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u32 >= i16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u32 >= i64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(u32 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u32 >= u16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u32 >= u64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(u32 >= f16); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u32 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= f64); // expected-error{{vector operands do not have the same number of elements ('svuint32_t' (aka '__SVUint32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(i64 >= b);   // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(i64 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(i64 >= i16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(i64 >= i32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(i64 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(i64 >= u16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(i64 >= u32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(i64 >= f16); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(i64 >= f32); // expected-error{{vector operands do not have the same number of elements ('svint64_t' (aka '__SVInt64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(i64 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+
+  (void)(u64 >= b);   // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(u64 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(u64 >= i16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(u64 >= i32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(u64 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(u64 >= u16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(u64 >= u32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(u64 >= f16); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(u64 >= f32); // expected-error{{vector operands do not have the same number of elements ('svuint64_t' (aka '__SVUint64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(u64 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+
+  (void)(f16 >= b);   // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f16 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f16 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= i32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f16 >= i64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f16 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f16 >= u32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f16 >= u64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f16 >= f32); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
+  (void)(f16 >= f64); // expected-error{{vector operands do not have the same number of elements ('svfloat16_t' (aka '__SVFloat16_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f32 >= b);   // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f32 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f32 >= i16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f32 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= i64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svint64_t' (aka '__SVInt64_t'))}}
+  (void)(f32 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f32 >= u16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f32 >= u64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svuint64_t' (aka '__SVUint64_t'))}}
+  (void)(f32 >= f16); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f32 >= f64); // expected-error{{vector operands do not have the same number of elements ('svfloat32_t' (aka '__SVFloat32_t') and 'svfloat64_t' (aka '__SVFloat64_t'))}}
+
+  (void)(f64 >= b);   // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svbool_t' (aka '__SVBool_t'))}}
+  (void)(f64 >= i8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  (void)(f64 >= i16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  (void)(f64 >= i32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  (void)(f64 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= u8);  // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint8_t' (aka '__SVUint8_t'))}}
+  (void)(f64 >= u16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint16_t' (aka '__SVUint16_t'))}}
+  (void)(f64 >= u32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svuint32_t' (aka '__SVUint32_t'))}}
+  (void)(f64 >= f16); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat16_t' (aka '__SVFloat16_t'))}}
+  (void)(f64 >= f32); // expected-error{{vector operands do not have the same number of elements ('svfloat64_t' (aka '__SVFloat64_t') and 'svfloat32_t' (aka '__SVFloat32_t'))}}
 }

clang/test/SemaCXX/aarch64-sve-vector-conditional-op.cpp

 // RUN: %clang_cc1 -verify -triple aarch64-none-linux-gnu -target-feature +sve -fallow-half-arguments-and-returns -fsyntax-only %s
 
 // REQUIRES: aarch64-registered-target
 
 #include <arm_sve.h>
 
 void cond(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
           svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
           svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
           svbool_t b) {
-  (void) i8 < i8 ? i16 : i16; // expected-error{{invalid operands to binary expression}}
-  (void) i8 < i8 ? i32 : i32; // expected-error{{invalid operands to binary expression}}
-  (void) i8 < i8 ? i64 : i64; // expected-error{{invalid operands to binary expression}}
+  i8 ? i16 : i16; // expected-error{{vector condition type 'svint8_t' (aka '__SVInt8_t') and result type 'svint16_t' (aka '__SVInt16_t') do not have the same number of elements}}
+  i8 ? i32 : i32; // expected-error{{vector condition type 'svint8_t' (aka '__SVInt8_t') and result type 'svint32_t' (aka '__SVInt32_t') do not have the same number of elements}}
+  i8 ? i64 : i64; // expected-error{{vector condition type 'svint8_t' (aka '__SVInt8_t') and result type 'svint64_t' (aka '__SVInt64_t') do not have the same number of elements}}
 
-  (void) i16 < i16 ? i16 : i8; // expected-error{{invalid operands to binary expression}}
-  (void) i16 < i16 ? i16 : i32; // expected-error{{invalid operands to binary expression}}
-  (void) i16 < i16 ? i16 : i64; // expected-error{{invalid operands to binary expression}}
+  i16 ? i16 : i8;  // expected-error{{vector operands to the vector conditional must be the same type ('svint16_t' (aka '__SVInt16_t') and 'svint8_t' (aka '__SVInt8_t'))}}
+  i16 ? i16 : i32; // expected-error{{vector operands to the vector conditional must be the same type ('svint16_t' (aka '__SVInt16_t') and 'svint32_t' (aka '__SVInt32_t'))}}
+  i16 ? i16 : i64; // expected-error{{vector operands to the vector conditional must be the same type ('svint16_t' (aka '__SVInt16_t') and 'svint64_t' (aka '__SVInt64_t'))}}
 
-  (void) i16 < i16 ? i8 : i16; // expected-error{{invalid operands to binary expression}}
-  (void) i16 < i16 ? i32 : i16; // expected-error{{invalid operands to binary expression}}
-  (void) i16 < i16 ? i64 : i16; // expected-error{{invalid operands to binary expression}}
+  i16 ? i8 : i16;  // expected-error{{vector operands to the vector conditional must be the same type ('svint8_t' (aka '__SVInt8_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  i16 ? i32 : i16; // expected-error{{vector operands to the vector conditional must be the same type ('svint32_t' (aka '__SVInt32_t') and 'svint16_t' (aka '__SVInt16_t'))}}
+  i16 ? i64 : i16; // expected-error{{vector operands to the vector conditional must be the same type ('svint64_t' (aka '__SVInt64_t') and 'svint16_t' (aka '__SVInt16_t'))}}
 }
 No newline at end of file