[clang][AArch64][SVE] Implicit conversions for vector-scalar operations

[DavidTruby]

Summary

This patch allows the same implicit conversions for vector-scalar
operations in SVE that are allowed for NEON.

[peterwaller-arm]

Looking pretty good. A couple of test cases to consider:

#include <arm_neon.h>
#include <arm_sve.h>
svint8_t svi8(svint8_t a) {
          return a + 256;
}
int8x16_t nei8(int8x16_t a) {
        return a + 256;
}
svint8_t svi8_128(svint8_t a) {
          return a + 128;
}
int8x16_t nei8_128(int8x16_t a) {
        return a + 128;
}

inp.c:4:13: error: invalid operands to binary expression ('svint8_t' (aka '__SVInt8_t') and 'int')
          return a + 256;
                 ~ ^ ~~~
inp.c:7:11: error: cannot convert between scalar type 'int' and vector type 'int8x16_t' (vector of 16 'int8_t' values) as implicit conversion would cause truncation
        return a + 256;
                 ^
inp.c:13:13: warning: implicit conversion from 'int' to 'int8x16_t' (vector of 16 'int8_t' values) changes value from 128 to -128 [-Wconstant-conversion]
        return a + 128;
                 ~ ^~~

Note that for NEON we get a warning about the implicit conversion, and a clear error message about truncation, but for SVE there is no warning and simply an 'invalid operands to binary expression', which could be confusing since the implicit conversions exist for the same operand type with differing value.

[DavidTruby]

Improved diagnostics

[peterwaller-arm]

clang/lib/Sema/SemaExpr.cpp

10588

!Ptr && [Deref Ptr] looks suspicious. Also, if I insert an abort in this path and run check-clang I don't see any failing tests?

It might help to name LHSBuiltinTy && LHSBuiltinTy->isVLSTBuiltinType() IsLHSVector (likewise for RHS) or similar.

[DavidTruby]

Fix assertion failures

[DavidTruby]

I think this needs more tests to ensure every diagnostic is being triggered correctly so I will be adding those in another patch, but I wanted to put up the fix for the original issue as soon as possible!

[DavidTruby]

Add additional tests and fix bugs associated with new tests

[c-rhodes]

can the diagnostics improvements be broke out into separate patches? I think it would make this easier to review

[DavidTruby]

In D124860#3533878, @c-rhodes wrote:

can the diagnostics improvements be broke out into separate patches? I think it would make this easier to review

I've split the diagnostic changes from this out as D126377 and will repost this patch soon based on that one. Thanks!

[DavidTruby]

I've resubmitted this split from the diagnostic changes as D126380

clang/lib/Sema/SemaChecking.cpp

if (isa<ComplexType>(Source)) {
 
     Source = cast<ComplexType>(Source)->getElementType().getTypePtr();
     Target = cast<ComplexType>(Target)->getElementType().getTypePtr();
   }
 
   const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source);
   const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target);
 
+  // Strip SVE vector types
+  if (SourceBT && SourceBT->isVLSTBuiltinType()) {
+    // Need the original target type for vector type checks
+    const Type *OriginalTarget = S.Context.getCanonicalType(T).getTypePtr();
+    // Handle conversion from scalable to fixed when msve-vector-bits is
+    // specified
+    if (S.Context.areCompatibleSveTypes(QualType(OriginalTarget, 0),
+                                        QualType(Source, 0)) ||
+        S.Context.areLaxCompatibleSveTypes(QualType(OriginalTarget, 0),
+                                           QualType(Source, 0)))
+      return;
+
+    if (!Target->isVLSTBuiltinType() && !isa<VectorType>(OriginalTarget)) {
+      if (S.SourceMgr.isInSystemMacro(CC))
+        return;
+      return DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_vector_scalar);
+    }
+
+    // If the vector cast is cast between two vectors of the same size, it is
+    // a bitcast, not a conversion.
+    if (S.Context.getTypeSize(Source) == S.Context.getTypeSize(Target))
+      return;
+
+    Source = SourceBT->getSveEltType(S.Context).getTypePtr();
+  }
+
+  if (TargetBT && TargetBT->isVLSTBuiltinType())
+    Target = TargetBT->getSveEltType(S.Context).getTypePtr();
+
   // If the source is floating point...
   if (SourceBT && SourceBT->isFloatingPoint()) {
     // ...and the target is floating point...
     if (TargetBT && TargetBT->isFloatingPoint()) {
       // ...then warn if we're dropping FP rank.
 
       int Order = S.getASTContext().getFloatingTypeSemanticOrder(
           QualType(SourceBT, 0), QualType(TargetBT, 0));

clang/lib/Sema/SemaExpr.cpp

 /// Attempt to convert and splat Scalar into a vector whose types matches
 /// Vector following GCC conversion rules. The rule is that implicit
 /// conversion can occur when Scalar can be casted to match Vector's element
 /// type without causing truncation of Scalar.
 static bool tryGCCVectorConvertAndSplat(Sema &S, ExprResult *Scalar,
                                         ExprResult *Vector) {
   QualType ScalarTy = Scalar->get()->getType().getUnqualifiedType();
   QualType VectorTy = Vector->get()->getType().getUnqualifiedType();
-  const auto *VT = VectorTy->castAs<VectorType>();
+  const auto *VT = VectorTy->getAs<VectorType>();
 
-  assert(!isa<ExtVectorType>(VT) &&
+  assert(!VT || !isa<ExtVectorType>(VT) &&
                     "ExtVectorTypes should not be handled here!");
 
-  QualType VectorEltTy = VT->getElementType();
+  QualType VectorEltTy;
+
+  if (VT) {
+    VectorEltTy = VT->getElementType();
+  } else if (VectorTy->isVLSTBuiltinType()) {
+    const auto *BuiltinTy = VectorTy->castAs<BuiltinType>();
+    VectorEltTy = BuiltinTy->getSveEltType(S.getASTContext());
+  } else {
+    llvm_unreachable("Only Fixed-Length and SVE Vector types are handled here");
+  }
 
   // Reject cases where the vector element type or the scalar element type are
   // not integral or floating point types.
   if (!VectorEltTy->isArithmeticType() || !ScalarTy->isArithmeticType())
     return true;
 
   // The conversion to apply to the scalar before splatting it,
   // if necessary.
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;
 
-  auto tryScalableVectorConvert = [this](ExprResult *Src, QualType SrcType,
-                                         QualType DestType) {
-    const QualType DestBaseType = DestType->getSveEltType(Context);
-    if (DestBaseType->getUnqualifiedDesugaredType() ==
-        SrcType->getUnqualifiedDesugaredType()) {
-      unsigned DiagID = diag::err_typecheck_invalid_operands;
-      if (!tryVectorConvertAndSplat(*this, Src, SrcType, DestBaseType, DestType,
-                                    DiagID))
-        return DestType;
-    }
-    return QualType();
-  };
+  if (LHSType->isVLSTBuiltinType() && !RHSType->isVLSTBuiltinType()) {
+    if (!tryGCCVectorConvertAndSplat(*this, &RHS, &LHS))
+      return LHSType;
+  }
+  if (RHSType->isVLSTBuiltinType() && !LHSType->isVLSTBuiltinType()) {
+    if (LHS.get()->isLValue() ||
+        !tryGCCVectorConvertAndSplat(*this, &LHS, &RHS))
+      return RHSType;
 
-  if (LHSType->isVLSTBuiltinType() && !RHSType->isVLSTBuiltinType()) {
-    auto DestType = tryScalableVectorConvert(&RHS, RHSType, LHSType);
-    if (DestType == QualType())
-      return InvalidOperands(Loc, LHS, RHS);
-    return DestType;
+  const bool IsLHSVector = LHSBuiltinTy && LHSBuiltinTy->isVLSTBuiltinType();
+  const bool IsRHSVector = RHSBuiltinTy && RHSBuiltinTy->isVLSTBuiltinType();
+
+  if ((!IsLHSVector && !LHSType->isRealType()) ||
+      (!IsRHSVector && !RHSType->isRealType())) {
+    Diag(Loc, diag::err_typecheck_vector_not_convertable_non_scalar)
+        << LHSType << RHSType << LHS.get()->getSourceRange()
+        << RHS.get()->getSourceRange();
+    return QualType();
   }
 
-  if (RHSType->isVLSTBuiltinType() && !LHSType->isVLSTBuiltinType()) {
-    auto DestType = tryScalableVectorConvert((IsCompAssign ? nullptr : &LHS),
-                                             LHSType, RHSType);
-    if (DestType == QualType())
-      return InvalidOperands(Loc, LHS, RHS);
-    return DestType;
+  if (IsLHSVector || IsRHSVector) {
+    QualType Scalar =
+        LHSBuiltinTy && LHSBuiltinTy->isVLSTBuiltinType() ? RHSType : LHSType;
+    QualType Vector =
+        LHSBuiltinTy && LHSBuiltinTy->isVLSTBuiltinType() ? LHSType : RHSType;
+    bool ScalarOrVector = IsLHSVector && IsRHSVector;
+
+    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/CodeGen/aarch64-sve-vector-arith-ops.c

 // CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x double> [[SPLAT_SPLATINSERT]], <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
 // CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], [[SPLAT_SPLAT]]
 // CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
 //
 svfloat64_t add_scalar_f64(svfloat64_t a, double b) {
   return a + b;
 }
 
+// CHECK-LABEL: @add_i8_ilit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ilit(svint8_t a) {
+  return a + 0;
+}
+
+// CHECK-LABEL: @add_i8_illit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_illit(svint8_t a) {
+  return a + 0l;
+}
+
+// CHECK-LABEL: @add_i8_illlit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_illlit(svint8_t a) {
+  return a + 0ll;
+}
+
+// CHECK-LABEL: @add_i8_ulit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ulit(svint8_t a) {
+  return a + 0u;
+}
+
+// CHECK-LABEL: @add_i8_ullit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ullit(svint8_t a) {
+  return a + 0ul;
+}
+
+// CHECK-LABEL: @add_i8_ulllit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_i8_ulllit(svint8_t a) {
+  return a + 0ull;
+}
+
+// CHECK-LABEL: @add_f64_ilit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ilit(svfloat64_t a) {
+  return a + 0;
+}
+
+// CHECK-LABEL: @add_f64_illit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_illit(svfloat64_t a) {
+  return a + 0l;
+}
+
+// CHECK-LABEL: @add_f64_illlit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_illlit(svfloat64_t a) {
+  return a + 0ll;
+}
+
+// CHECK-LABEL: @add_f64_ulit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ulit(svfloat64_t a) {
+  return a + 0u;
+}
+
+// CHECK-LABEL: @add_f64_ullit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ullit(svfloat64_t a) {
+  return a + 0ul;
+}
+
+// CHECK-LABEL: @add_f64_ulllit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_ulllit(svfloat64_t a) {
+  return a + 0ull;
+}
+
+// CHECK-LABEL: @add_f64_flit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_flit(svfloat64_t a) {
+  return a + 0.f;
+}
+
+// CHECK-LABEL: @add_f64_dlit(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], zeroinitializer
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_f64_dlit(svfloat64_t a) {
+  return a + 0.;
+}
+
 // SUBTRACTION
 
 // CHECK-LABEL: @sub_i8(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 16 x i8> [[SUB]]
 //
 svint8_t sub_i8(svint8_t a, svint8_t b) {

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>
 
 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) {
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 + f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 + f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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) {
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 - f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 - f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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) {
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 * f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 * f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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) {
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 / f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
 
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 / f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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) {
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 % i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 % i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 % u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 % u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 % u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 % i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 % i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 % u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 % u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 % u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 % i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 % i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 % u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 % u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 % u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 % i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 % i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 % u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 % u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 % u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 % i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 % i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 % u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 % u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 % u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 % i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 % i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 % u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 % u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 % u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 % i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 % i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 % u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 % u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 % u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 % i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 % i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 % u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 % u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 % u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
   (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}}
 }

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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 & i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 & i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 & u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 & u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 & u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 & i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 & i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 & u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 & u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 & u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 & i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 & i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 & i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 & u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 & u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 & u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 & i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 & i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 & i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 & u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 & u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 & u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 & i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 & i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 & i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 & u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 & u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 & u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 & i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 & i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 & i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 & u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 & u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 & u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 & i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 & i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 & i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 & u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 & u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 & u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 & i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 & i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 & i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 & u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 & u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 & u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 | i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 | i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 | u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 | u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 | u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 | i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 | i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 | u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 | u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 | u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 | i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 | i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 | i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 | u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 | u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 | u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 | i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 | i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 | i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 | u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 | u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 | u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 | i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 | i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 | i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 | u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 | u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 | u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 | i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 | i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 | i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 | u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 | u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 | u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 | i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 | i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 | i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 | u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 | u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 | u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 | i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 | i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 | i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 | u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 | u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 | u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 ^ i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 ^ i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 ^ u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 ^ u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 ^ u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 ^ i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 ^ i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 ^ u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 ^ u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 ^ u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 ^ i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 ^ i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 ^ i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 ^ u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 ^ u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 ^ u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 ^ i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 ^ i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 ^ i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 ^ u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 ^ u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 ^ u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 ^ i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 ^ i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 ^ i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 ^ u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 ^ u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 ^ u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 ^ i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 ^ i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 ^ i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 ^ u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 ^ u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 ^ u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 ^ i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 ^ i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 ^ i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 ^ u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 ^ u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 ^ u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 ^ i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 ^ i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 ^ i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 ^ u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 ^ u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 ^ u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
   (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+
+  (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+
+  (void)(i16 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+
+  (void)(u16 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+
+  (void)(i32 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+
+  (void)(u32 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+
+  (void)(i64 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+
+  (void)(f32 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 == f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+
+  (void)(f64 == b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 == f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+
+  (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+
+  (void)(i16 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+
+  (void)(u16 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+
+  (void)(i32 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+
+  (void)(u32 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+
+  (void)(i64 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+
+  (void)(f32 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 != f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+
+  (void)(f64 != b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 != f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+
+  (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+
+  (void)(i16 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+
+  (void)(u16 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+
+  (void)(i32 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+
+  (void)(u32 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+
+  (void)(i64 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+
+  (void)(f32 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 < f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+
+  (void)(f64 < b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 < f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+
+  (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+
+  (void)(i16 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+
+  (void)(u16 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+
+  (void)(i32 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+
+  (void)(u32 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+
+  (void)(i64 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+
+  (void)(f32 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 <= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+
+  (void)(f64 <= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 <= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+
+  (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+
+  (void)(i16 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+
+  (void)(u16 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+
+  (void)(i32 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+
+  (void)(u32 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+
+  (void)(i64 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+
+  (void)(f32 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 > f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+
+  (void)(f64 > b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 > f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }
 
 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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+  (void)(i8 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+
+  (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{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+  (void)(u8 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint8_t' (aka '__SVUint8_t') as implicit conversion would cause truncation}}
+
+  (void)(i16 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+  (void)(i16 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint16_t' (aka '__SVInt16_t') as implicit conversion would cause truncation}}
+
+  (void)(u16 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+  (void)(u16 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint16_t' (aka '__SVUint16_t') as implicit conversion would cause truncation}}
+
+  (void)(i32 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (void)(i32 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svint32_t' (aka '__SVInt32_t') as implicit conversion would cause truncation}}
+
+  (void)(u32 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (void)(u32 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svuint32_t' (aka '__SVUint32_t') as implicit conversion would cause truncation}}
+
+  (void)(i64 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (void)(i64 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svint64_t' (aka '__SVInt64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (void)(u64 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svuint64_t' (aka '__SVUint64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= i64); // expected-error{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+  (void)(f16 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat16_t' (aka '__SVFloat16_t') as implicit conversion would cause truncation}}
+
+  (void)(f32 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svint64_t' (aka '__SVInt64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= u8);  // expected-error{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= u64); // expected-error{{cannot convert between vector type 'svuint64_t' (aka '__SVUint64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+  (void)(f32 >= f64); // expected-error{{cannot convert between vector type 'svfloat64_t' (aka '__SVFloat64_t') and vector type 'svfloat32_t' (aka '__SVFloat32_t') as implicit conversion would cause truncation}}
+
+  (void)(f64 >= b);   // expected-error{{cannot convert between vector type 'svbool_t' (aka '__SVBool_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= i8);  // expected-error{{cannot convert between vector type 'svint8_t' (aka '__SVInt8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= i16); // expected-error{{cannot convert between vector type 'svint16_t' (aka '__SVInt16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= i32); // expected-error{{cannot convert between vector type 'svint32_t' (aka '__SVInt32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (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{{cannot convert between vector type 'svuint8_t' (aka '__SVUint8_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= u16); // expected-error{{cannot convert between vector type 'svuint16_t' (aka '__SVUint16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= u32); // expected-error{{cannot convert between vector type 'svuint32_t' (aka '__SVUint32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= f16); // expected-error{{cannot convert between vector type 'svfloat16_t' (aka '__SVFloat16_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
+  (void)(f64 >= f32); // expected-error{{cannot convert between vector type 'svfloat32_t' (aka '__SVFloat32_t') and vector type 'svfloat64_t' (aka '__SVFloat64_t') as implicit conversion would cause truncation}}
 }

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

+// RUN: %clang_cc1 -verify -triple aarch64-none-linux-gnu -target-feature +sve -target-feature +neon -fallow-half-arguments-and-returns -fsyntax-only %s
+
+// REQUIRES: aarch64-registered-target
+
+#include <arm_neon.h>
+#include <arm_sve.h>
+
+struct T {
+  int x;
+};
+
+void add_nonscalar(svint32_t i32, struct T a32, svbool_t b) {
+  (void)(i32 + a32); // expected-error{{cannot convert between vector and non-scalar values ('svint32_t' (aka '__SVInt32_t') and 'struct T')}}
+}
+
+void add_bool(svbool_t b) {
+  (void)(b + b); // expected-error{{invalid operands to binary expression ('svbool_t' (aka '__SVBool_t') and 'svbool_t')}}
+}
+
+svint8_t svi8(svint8_t a) {
+  return a + 256; // expected-error{{cannot convert between scalar type 'int' and vector type 'svint8_t' (aka '__SVInt8_t') as implicit conversion would cause truncation}}
+}
+
+svint8_t svi8_128(svint8_t a) {
+  return a + 128; // expected-warning{{implicit conversion from 'int' to 'svint8_t' (aka '__SVInt8_t') changes value from 128 to -128}}
+}

clang/test/Sema/sizeless-1.c

void func(int sel) {
   !init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   *init_int8;       // expected-error {{indirection requires pointer operand}}
   __real init_int8; // expected-error {{invalid type 'svint8_t'}}
   __imag init_int8; // expected-error {{invalid type 'svint8_t'}}
 
   local_int8 &&init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 || init_int8; // expected-error {{invalid operands to binary expression}}
 
-  local_int8 + 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 - 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 * 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 / 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 % 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 & 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 | 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 ^ 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 < 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 <= 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 == 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 != 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 >= 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 > 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 && 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 || 0; // expected-error {{invalid operands to binary expression}}
-
   if (local_int8) { // expected-error {{statement requires expression of scalar type}}
   }
   while (local_int8) { // expected-error {{statement requires expression of scalar type}}
   }
   do { // expected-error {{statement requires expression of scalar type}}
   } while (local_int8);
   switch (local_int8) { // expected-error {{statement requires expression of integer type}}
   default:;

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

clang/test/SemaCXX/sizeless-1.cpp

#endif
   !init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   *init_int8;       // expected-error {{indirection requires pointer operand}}
   __real init_int8; // expected-error {{invalid type 'svint8_t'}}
   __imag init_int8; // expected-error {{invalid type 'svint8_t'}}
 
   local_int8 &&init_int8;  // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
   local_int8 || init_int8; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
 
-  local_int8 + 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 - 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 * 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 / 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 % 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 & 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 | 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 ^ 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 < 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 <= 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 == 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 != 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 >= 0; // expected-error {{invalid operands to binary expression}}
-  local_int8 > 0;  // expected-error {{invalid operands to binary expression}}
-  local_int8 && 0; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
-  local_int8 || 0; // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}
-
   if (local_int8) { // expected-error {{not contextually convertible to 'bool'}}
   }
   while (local_int8) { // expected-error {{not contextually convertible to 'bool'}}
   }
   do {
   } while (local_int8); // expected-error {{not contextually convertible to 'bool'}}
   switch (local_int8) { // expected-error {{statement requires expression of integer type}}
   default:;