[clang][SVE] Add support for bitwise operators on SVE types

[DavidTruby]

Summary

This patch implements support for the &, |, ^, and ~ operators on sizeless SVE
types.

[peterwaller-arm]

Looking reasonable to me, one comment.

clang/lib/Sema/SemaExpr.cpp

10452

There is a saying that booleans are often inferior to enums in arguments. I think this might be one of those cases, could you use the enum ArithConvKind instead?

As a side effect call sites will be clear without the need for a comment string:

CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);

... and it will be extensible to other kinds, which I presume are likely to creep in here as more operators are added.

[DavidTruby]

Use ArithConvKind enum instead of boolean

[peterwaller-arm]

LGTM, modulo that the require lines look like they need fixing.

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

8

Needs a requires line?

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

3–4

[DavidTruby]

Auto-generate tests

clang/include/clang/Sema/Sema.h

public:
   QualType CheckVectorCompareOperands(ExprResult &LHS, ExprResult &RHS,
                                       SourceLocation Loc,
                                       BinaryOperatorKind Opc);
   QualType CheckVectorLogicalOperands(ExprResult &LHS, ExprResult &RHS,
                                       SourceLocation Loc);
 
   // type checking for sizeless vector binary operators.
   QualType CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS,
-                                       SourceLocation Loc);
+                                       SourceLocation Loc,
+                                       ArithConvKind OperationKind);
 
   /// Type checking for matrix binary operators.
   QualType CheckMatrixElementwiseOperands(ExprResult &LHS, ExprResult &RHS,
                                           SourceLocation Loc,
                                           bool IsCompAssign);
   QualType CheckMatrixMultiplyOperands(ExprResult &LHS, ExprResult &RHS,
                                        SourceLocation Loc, bool IsCompAssign);
 

clang/lib/AST/Type.cpp

 bool Type::hasAutoForTrailingReturnType() const {
   return isa_and_nonnull<FunctionType>(
       GetContainedDeducedTypeVisitor(true).Visit(this));
 }
 
 bool Type::hasIntegerRepresentation() const {
   if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isIntegerType();
-  else
-    return isIntegerType();
+  if (CanonicalType->isVLSTBuiltinType()) {
+    const auto *VT = cast<BuiltinType>(CanonicalType);
+    return VT->getKind() == BuiltinType::SveBool ||
+           (VT->getKind() >= BuiltinType::SveInt8 &&
+            VT->getKind() <= BuiltinType::SveUint64);
+  }
+
 }
 
 /// Determine whether this type is an integral type.
 ///
 /// This routine determines whether the given type is an integral type per
 /// C++ [basic.fundamental]p7. Although the C standard does not define the
 /// term "integral type", it has a similar term "integer type", and in C++
 /// the two terms are equivalent. However, C's "integer type" includes

clang/lib/Sema/SemaExpr.cpp

QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
   // Otherwise, use the generic diagnostic.
   Diag(Loc, DiagID)
     << LHSType << RHSType
     << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
   return QualType();
 }
 
 QualType Sema::CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS,
-                                           SourceLocation Loc) {
+                                           SourceLocation Loc,
+                                           ArithConvKind OperationKind) {
   QualType LHSType = LHS.get()->getType().getUnqualifiedType();
   QualType RHSType = RHS.get()->getType().getUnqualifiedType();
 
   const BuiltinType *LHSVecType = LHSType->getAs<BuiltinType>();
   const BuiltinType *RHSVecType = RHSType->getAs<BuiltinType>();
 
   unsigned DiagID = diag::err_typecheck_invalid_operands;
-  if (LHSVecType->isSVEBool() || RHSVecType->isSVEBool()) {
+  if ((OperationKind == ACK_Arithmetic) &&
+      (LHSVecType->isSVEBool() || RHSVecType->isSVEBool())) {
     Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                       << RHS.get()->getSourceRange();
     return QualType();
   }
 
   if (Context.hasSameType(LHSType, RHSType))
     return LHSType;
 
QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
 
   QualType LHSTy = LHS.get()->getType();
   QualType RHSTy = RHS.get()->getType();
   if (LHSTy->isVectorType() || RHSTy->isVectorType())
     return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                /*AllowBothBool*/ getLangOpts().AltiVec,
                                /*AllowBoolConversions*/ false);
   if (LHSTy->isVLSTBuiltinType() || RHSTy->isVLSTBuiltinType())
-    return CheckSizelessVectorOperands(LHS, RHS, Loc);
+    return CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
   if (!IsDiv &&
       (LHSTy->isConstantMatrixType() || RHSTy->isConstantMatrixType()))
     return CheckMatrixMultiplyOperands(LHS, RHS, Loc, IsCompAssign);
   // For division, only matrix-by-scalar is supported. Other combinations with
   // matrix types are invalid.
   if (IsDiv && LHSTy->isConstantMatrixType() && RHSTy->isArithmeticType())
     return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);
 
if (LHS.get()->getType()->isVLSTBuiltinType() &&
     if (LHS.get()
             ->getType()
             ->getSveEltType(Context)
             ->hasIntegerRepresentation() &&
         RHS.get()
             ->getType()
             ->getSveEltType(Context)
             ->hasIntegerRepresentation())
-      return CheckSizelessVectorOperands(LHS, RHS, Loc);
+      return CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
 
     return InvalidOperands(Loc, LHS, RHS);
   }
 
   QualType compType = UsualArithmeticConversions(
       LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
QualType compType = CheckVectorOperands(
         /*AllowBothBool*/getLangOpts().AltiVec,
         /*AllowBoolConversions*/getLangOpts().ZVector);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isVLSTBuiltinType() ||
       RHS.get()->getType()->isVLSTBuiltinType()) {
-    QualType compType = CheckSizelessVectorOperands(LHS, RHS, Loc);
+    QualType compType =
+        CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
     if (CompLHSTy)
       *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
       RHS.get()->getType()->isConstantMatrixType()) {
     QualType compType =
QualType compType = CheckVectorOperands(
         /*AllowBothBool*/getLangOpts().AltiVec,
         /*AllowBoolConversions*/getLangOpts().ZVector);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isVLSTBuiltinType() ||
       RHS.get()->getType()->isVLSTBuiltinType()) {
-    QualType compType = CheckSizelessVectorOperands(LHS, RHS, Loc);
+    QualType compType =
+        CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
     if (CompLHSTy)
       *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
       RHS.get()->getType()->isConstantMatrixType()) {
     QualType compType =
if (LangOpts.ZVector) {
           return InvalidOperands(Loc, LHS, RHS);
       if (auto RHSVecType = RHS.get()->getType()->getAs<VectorType>())
         if (RHSVecType->getVectorKind() == VectorType::AltiVecBool)
           return InvalidOperands(Loc, LHS, RHS);
     }
     return checkVectorShift(*this, LHS, RHS, Loc, IsCompAssign);
   }
 
+  if (LHS.get()->getType()->isVLSTBuiltinType() ||
+      RHS.get()->getType()->isVLSTBuiltinType())
+    return InvalidOperands(Loc, LHS, RHS);
+
   // Shifts don't perform usual arithmetic conversions, they just do integer
   // promotions on each operand. C99 6.5.7p3
 
   // For the LHS, do usual unary conversions, but then reset them away
   // if this is a compound assignment.
   ExprResult OldLHS = LHS;
   LHS = UsualUnaryConversions(LHS.get());
   if (LHS.isInvalid())
if (LHS.get()->getType()->isVectorType() ||
     if (LHS.get()->getType()->hasIntegerRepresentation() &&
         RHS.get()->getType()->hasIntegerRepresentation())
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                         /*AllowBothBool*/true,
                         /*AllowBoolConversions*/getLangOpts().ZVector);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
+  if (LHS.get()->getType()->isVLSTBuiltinType() ||
+      RHS.get()->getType()->isVLSTBuiltinType()) {
+    if (LHS.get()->getType()->hasIntegerRepresentation() &&
+        RHS.get()->getType()->hasIntegerRepresentation())
+      return CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_BitwiseOp);
+    return InvalidOperands(Loc, LHS, RHS);
+  }
+
   if (Opc == BO_And)
     diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
 
   if (LHS.get()->getType()->hasFloatingRepresentation() ||
       RHS.get()->getType()->hasFloatingRepresentation())
     return InvalidOperands(Loc, LHS, RHS);
 
   ExprResult LHSResult = LHS, RHSResult = RHS;

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

 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \
 // RUN: -fallow-half-arguments-and-returns \
 // RUN:  -O1 -emit-llvm -o - %s 2>&1 | FileCheck %s
 
 // REQUIRES: aarch64-registered-target
 
 #include <arm_sve.h>
 
 // ADDITION
 
 svint8_t add_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: add_i8
   // CHECK: %add = add <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %add
   return a + b;
 }
 
 svint16_t add_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: add_i16
   // CHECK: %add = add <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %add
   return a + b;
 }
 
 svint32_t add_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: add_i32
   // CHECK: %add = add <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %add
   return a + b;
 }
 
 svint64_t add_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: add_i64
   // CHECK: %add = add <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %add
   return a + b;
 }
 
 svuint8_t add_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: add_u8
   // CHECK: %add = add <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %add
   return a + b;
 }
 
 svuint16_t add_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: add_u16
   // CHECK: %add = add <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %add
   return a + b;
 }
 
 svuint32_t add_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: add_u32
   // CHECK: %add = add <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %add
   return a + b;
 }
 
 svuint64_t add_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: add_u64
   // CHECK: %add = add <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %add
   return a + b;
 }
 
 svfloat16_t add_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: add_f16
   // CHECK: %add = fadd <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %add
   return a + b;
 }
 
 svfloat32_t add_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: add_f32
   // CHECK: %add = fadd <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %add
   return a + b;
 }
 
 svfloat64_t add_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: add_f64
   // CHECK: %add = fadd <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %add
   return a + b;
 }
 
 svint8_t add_inplace_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: add_inplace_i8
   // CHECK: %add = add <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %add
   return a += b;
 }
 
 svint16_t add_inplace_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: add_inplace_i16
   // CHECK: %add = add <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %add
   return a += b;
 }
 
 svint32_t add_inplace_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: add_inplace_i32
   // CHECK: %add = add <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %add
   return a += b;
 }
 
 svint64_t add_inplace_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: add_inplace_i64
   // CHECK: %add = add <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %add
   return a += b;
 }
 
 svuint8_t add_inplace_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: add_inplace_u8
   // CHECK: %add = add <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %add
   return a += b;
 }
 
 svuint16_t add_inplace_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: add_inplace_u16
   // CHECK: %add = add <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %add
   return a += b;
 }
 
 svuint32_t add_inplace_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: add_inplace_u32
   // CHECK: %add = add <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %add
   return a += b;
 }
 
 svuint64_t add_inplace_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: add_inplace_u64
   // CHECK: %add = add <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %add
   return a += b;
 }
 
 svfloat16_t add_inplace_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: add_inplace_f16
   // CHECK: %add = fadd <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %add
   return a += b;
 }
 
 svfloat32_t add_inplace_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: add_inplace_f32
   // CHECK: %add = fadd <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %add
   return a += b;
 }
 
 svfloat64_t add_inplace_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: add_inplace_f64
   // CHECK: %add = fadd <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %add
   return a += b;
 }
 
 // SUBTRACTION
 
 svint8_t sub_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: sub_i8
   // CHECK: %sub = sub <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %sub
   return a - b;
 }
 
 svint16_t sub_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: sub_i16
   // CHECK: %sub = sub <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %sub
   return a - b;
 }
 
 svint32_t sub_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: sub_i32
   // CHECK: %sub = sub <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %sub
   return a - b;
 }
 
 svint64_t sub_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: sub_i64
   // CHECK: %sub = sub <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %sub
   return a - b;
 }
 
 svuint8_t sub_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: sub_u8
   // CHECK: %sub = sub <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %sub
   return a - b;
 }
 
 svuint16_t sub_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: sub_u16
   // CHECK: %sub = sub <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %sub
   return a - b;
 }
 
 svuint32_t sub_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: sub_u32
   // CHECK: %sub = sub <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %sub
   return a - b;
 }
 
 svuint64_t sub_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: sub_u64
   // CHECK: %sub = sub <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %sub
   return a - b;
 }
 
 svfloat16_t sub_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: sub_f16
   // CHECK: %sub = fsub <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %sub
   return a - b;
 }
 
 svfloat32_t sub_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: sub_f32
   // CHECK: %sub = fsub <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %sub
   return a - b;
 }
 
 svfloat64_t sub_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: sub_f64
   // CHECK: %sub = fsub <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %sub
   return a - b;
 }
 
 svint8_t sub_inplace_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: sub_inplace_i8
   // CHECK: %sub = sub <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %sub
   return a - b;
 }
 
 svint16_t sub_inplace_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: sub_inplace_i16
   // CHECK: %sub = sub <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %sub
   return a - b;
 }
 
 svint32_t sub_inplace_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: sub_inplace_i32
   // CHECK: %sub = sub <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %sub
   return a - b;
 }
 
 svint64_t sub_inplace_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: sub_inplace_i64
   // CHECK: %sub = sub <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %sub
   return a - b;
 }
 
 svuint8_t sub_inplace_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: sub_inplace_u8
   // CHECK: %sub = sub <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %sub
   return a - b;
 }
 
 svuint16_t sub_inplace_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: sub_inplace_u16
   // CHECK: %sub = sub <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %sub
   return a - b;
 }
 
 svuint32_t sub_inplace_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: sub_inplace_u32
   // CHECK: %sub = sub <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %sub
   return a - b;
 }
 
 svuint64_t sub_inplace_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: sub_inplace_u64
   // CHECK: %sub = sub <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %sub
   return a - b;
 }
 
 svfloat16_t sub_inplace_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: sub_inplace_f16
   // CHECK: %sub = fsub <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %sub
   return a - b;
 }
 
 svfloat32_t sub_inplace_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: sub_inplace_f32
   // CHECK: %sub = fsub <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %sub
   return a - b;
 }
 
 svfloat64_t sub_inplace_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: sub_inplace_f64
   // CHECK: %sub = fsub <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %sub
   return a - b;
 }
 
 // MULTIPLICATION
 
 svint8_t mul_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: mul_i8
   // CHECK: %mul = mul <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %mul
   return a * b;
 }
 
 svint16_t mul_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: mul_i16
   // CHECK: %mul = mul <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %mul
   return a * b;
 }
 
 svint32_t mul_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: mul_i32
   // CHECK: %mul = mul <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %mul
   return a * b;
 }
 
 svint64_t mul_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: mul_i64
   // CHECK: %mul = mul <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %mul
   return a * b;
 }
 
 svuint8_t mul_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: mul_u8
   // CHECK: %mul = mul <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %mul
   return a * b;
 }
 
 svuint16_t mul_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: mul_u16
   // CHECK: %mul = mul <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %mul
   return a * b;
 }
 
 svuint32_t mul_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: mul_u32
   // CHECK: %mul = mul <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %mul
   return a * b;
 }
 
 svuint64_t mul_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: mul_u64
   // CHECK: %mul = mul <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %mul
   return a * b;
 }
 
 svfloat16_t mul_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: mul_f16
   // CHECK: %mul = fmul <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %mul
   return a * b;
 }
 
 svfloat32_t mul_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: mul_f32
   // CHECK: %mul = fmul <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %mul
   return a * b;
 }
 
 svfloat64_t mul_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: mul_f64
   // CHECK: %mul = fmul <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %mul
   return a * b;
 }
 
 svint8_t mul_inplace_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: mul_inplace_i8
   // CHECK: %mul = mul <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %mul
   return a * b;
 }
 
 svint16_t mul_inplace_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: mul_inplace_i16
   // CHECK: %mul = mul <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %mul
   return a * b;
 }
 
 svint32_t mul_inplace_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: mul_inplace_i32
   // CHECK: %mul = mul <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %mul
   return a * b;
 }
 
 svint64_t mul_inplace_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: mul_inplace_i64
   // CHECK: %mul = mul <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %mul
   return a * b;
 }
 
 svuint8_t mul_inplace_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: mul_inplace_u8
   // CHECK: %mul = mul <vscale x 16 x i8> %b, %a
   // CHECK-NEXT: ret <vscale x 16 x i8> %mul
   return a * b;
 }
 
 svuint16_t mul_inplace_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: mul_inplace_u16
   // CHECK: %mul = mul <vscale x 8 x i16> %b, %a
   // CHECK-NEXT: ret <vscale x 8 x i16> %mul
   return a * b;
 }
 
 svuint32_t mul_inplace_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: mul_inplace_u32
   // CHECK: %mul = mul <vscale x 4 x i32> %b, %a
   // CHECK-NEXT: ret <vscale x 4 x i32> %mul
   return a * b;
 }
 
 svuint64_t mul_inplace_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: mul_inplace_u64
   // CHECK: %mul = mul <vscale x 2 x i64> %b, %a
   // CHECK-NEXT: ret <vscale x 2 x i64> %mul
   return a * b;
 }
 
 svfloat16_t mul_inplace_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: mul_inplace_f16
   // CHECK: %mul = fmul <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %mul
   return a * b;
 }
 
 svfloat32_t mul_inplace_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: mul_inplace_f32
   // CHECK: %mul = fmul <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %mul
   return a * b;
 }
 
 svfloat64_t mul_inplace_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: mul_inplace_f64
   // CHECK: %mul = fmul <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %mul
   return a * b;
 }
 
 // DIVISION
 
 svint8_t div_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: div_i8
   // CHECK: %div = sdiv <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %div
   return a / b;
 }
 
 svint16_t div_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: div_i16
   // CHECK: %div = sdiv <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %div
   return a / b;
 }
 
 svint32_t div_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: div_i32
   // CHECK: %div = sdiv <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %div
   return a / b;
 }
 
 svint64_t div_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: div_i64
   // CHECK: %div = sdiv <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %div
   return a / b;
 }
 
 svuint8_t div_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: div_u8
   // CHECK: %div = udiv <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %div
   return a / b;
 }
 
 svuint16_t div_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: div_u16
   // CHECK: %div = udiv <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %div
   return a / b;
 }
 
 svuint32_t div_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: div_u32
   // CHECK: %div = udiv <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %div
   return a / b;
 }
 
 svuint64_t div_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: div_u64
   // CHECK: %div = udiv <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %div
   return a / b;
 }
 
 svfloat16_t div_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: div_f16
   // CHECK: %div = fdiv <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %div
   return a / b;
 }
 
 svfloat32_t div_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: div_f32
   // CHECK: %div = fdiv <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %div
   return a / b;
 }
 
 svfloat64_t div_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: div_f64
   // CHECK: %div = fdiv <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %div
   return a / b;
 }
 
 svint8_t div_inplace_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: div_inplace_i8
   // CHECK: %div = sdiv <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %div
   return a / b;
 }
 
 svint16_t div_inplace_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: div_inplace_i16
   // CHECK: %div = sdiv <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %div
   return a / b;
 }
 
 svint32_t div_inplace_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: div_inplace_i32
   // CHECK: %div = sdiv <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %div
   return a / b;
 }
 
 svint64_t div_inplace_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: div_inplace_i64
   // CHECK: %div = sdiv <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %div
   return a / b;
 }
 
 svuint8_t div_inplace_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: div_inplace_u8
   // CHECK: %div = udiv <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %div
   return a / b;
 }
 
 svuint16_t div_inplace_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: div_inplace_u16
   // CHECK: %div = udiv <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %div
   return a / b;
 }
 
 svuint32_t div_inplace_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: div_inplace_u32
   // CHECK: %div = udiv <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %div
   return a / b;
 }
 
 svuint64_t div_inplace_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: div_inplace_u64
   // CHECK: %div = udiv <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %div
   return a / b;
 }
 
 svfloat16_t div_inplace_f16(svfloat16_t a, svfloat16_t b) {
   // CHECK-LABEL: div_inplace_f16
   // CHECK: %div = fdiv <vscale x 8 x half> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x half> %div
   return a / b;
 }
 
 svfloat32_t div_inplace_f32(svfloat32_t a, svfloat32_t b) {
   // CHECK-LABEL: div_inplace_f32
   // CHECK: %div = fdiv <vscale x 4 x float> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x float> %div
   return a / b;
 }
 
 svfloat64_t div_inplace_f64(svfloat64_t a, svfloat64_t b) {
   // CHECK-LABEL: div_inplace_f64
   // CHECK: %div = fdiv <vscale x 2 x double> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x double> %div
   return a / b;
 }
 
 // REMAINDER
 
 svint8_t rem_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: rem_i8
   // CHECK: %rem = srem <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %rem
   return a % b;
 }
 
 svint16_t rem_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: rem_i16
   // CHECK: %rem = srem <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %rem
   return a % b;
 }
 
 svint32_t rem_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: rem_i32
   // CHECK: %rem = srem <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %rem
   return a % b;
 }
 
 svint64_t rem_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: rem_i64
   // CHECK: %rem = srem <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %rem
   return a % b;
 }
 
 svuint8_t rem_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: rem_u8
   // CHECK: %rem = urem <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %rem
   return a % b;
 }
 
 svuint16_t rem_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: rem_u16
   // CHECK: %rem = urem <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %rem
   return a % b;
 }
 
 svuint32_t rem_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: rem_u32
   // CHECK: %rem = urem <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %rem
   return a % b;
 }
 
 svuint64_t rem_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: rem_u64
   // CHECK: %rem = urem <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %rem
   return a % b;
 }
 
 svint8_t rem_inplace_i8(svint8_t a, svint8_t b) {
   // CHECK-LABEL: rem_inplace_i8
   // CHECK: %rem = srem <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %rem
   return a % b;
 }
 
 svint16_t rem_inplace_i16(svint16_t a, svint16_t b) {
   // CHECK-LABEL: rem_inplace_i16
   // CHECK: %rem = srem <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %rem
   return a % b;
 }
 
 svint32_t rem_inplace_i32(svint32_t a, svint32_t b) {
   // CHECK-LABEL: rem_inplace_i32
   // CHECK: %rem = srem <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %rem
   return a % b;
 }
 
 svint64_t rem_inplace_i64(svint64_t a, svint64_t b) {
   // CHECK-LABEL: rem_inplace_i64
   // CHECK: %rem = srem <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %rem
   return a % b;
 }
 
 svuint8_t rem_inplace_u8(svuint8_t a, svuint8_t b) {
   // CHECK-LABEL: rem_inplace_u8
   // CHECK: %rem = urem <vscale x 16 x i8> %a, %b
   // CHECK-NEXT: ret <vscale x 16 x i8> %rem
   return a % b;
 }
 
 svuint16_t rem_inplace_u16(svuint16_t a, svuint16_t b) {
   // CHECK-LABEL: rem_inplace_u16
   // CHECK: %rem = urem <vscale x 8 x i16> %a, %b
   // CHECK-NEXT: ret <vscale x 8 x i16> %rem
   return a % b;
 }
 
 svuint32_t rem_inplace_u32(svuint32_t a, svuint32_t b) {
   // CHECK-LABEL: rem_inplace_u32
   // CHECK: %rem = urem <vscale x 4 x i32> %a, %b
   // CHECK-NEXT: ret <vscale x 4 x i32> %rem
   return a % b;
 }
 
 svuint64_t rem_inplace_u64(svuint64_t a, svuint64_t b) {
   // CHECK-LABEL: rem_inplace_u64
   // CHECK: %rem = urem <vscale x 2 x i64> %a, %b
   // CHECK-NEXT: ret <vscale x 2 x i64> %rem
   return a % b;
 }

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

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \
+// RUN: -fallow-half-arguments-and-returns -disable-O0-optnone \
+// RUN:  -emit-llvm -o - %s | opt -S -sroa | FileCheck %s
+
+// REQUIRES: aarch64-registered-target
+
+#include <arm_sve.h>
+
+// AND
+
+// CHECK-LABEL: @and_bool(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 16 x i1> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i1> [[AND]]
+//
+svbool_t and_bool(svbool_t a, svbool_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[AND]]
+//
+svint8_t and_i8(svint8_t a, svint8_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 8 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[AND]]
+//
+svint16_t and_i16(svint16_t a, svint16_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[AND]]
+//
+svint32_t and_i32(svint32_t a, svint32_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[AND]]
+//
+svint64_t and_i64(svint64_t a, svint64_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[AND]]
+//
+svuint8_t and_u8(svuint8_t a, svuint8_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 8 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[AND]]
+//
+svuint16_t and_u16(svuint16_t a, svuint16_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[AND]]
+//
+svuint32_t and_u32(svuint32_t a, svuint32_t b) {
+  return a & b;
+}
+
+// CHECK-LABEL: @and_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[AND:%.*]] = and <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[AND]]
+//
+svuint64_t and_u64(svuint64_t a, svuint64_t b) {
+  return a & b;
+}
+
+// OR
+
+// CHECK-LABEL: @or_bool(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 16 x i1> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i1> [[OR]]
+//
+svbool_t or_bool(svbool_t a, svbool_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[OR]]
+//
+svint8_t or_i8(svint8_t a, svint8_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 8 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[OR]]
+//
+svint16_t or_i16(svint16_t a, svint16_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[OR]]
+//
+svint32_t or_i32(svint32_t a, svint32_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[OR]]
+//
+svint64_t or_i64(svint64_t a, svint64_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[OR]]
+//
+svuint8_t or_u8(svuint8_t a, svuint8_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 8 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[OR]]
+//
+svuint16_t or_u16(svuint16_t a, svuint16_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[OR]]
+//
+svuint32_t or_u32(svuint32_t a, svuint32_t b) {
+  return a | b;
+}
+
+// CHECK-LABEL: @or_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[OR:%.*]] = or <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[OR]]
+//
+svuint64_t or_u64(svuint64_t a, svuint64_t b) {
+  return a | b;
+}
+
+// XOR
+
+// CHECK-LABEL: @xor_bool(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 16 x i1> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i1> [[XOR]]
+//
+svbool_t xor_bool(svbool_t a, svbool_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[XOR]]
+//
+svint8_t xor_i8(svint8_t a, svint8_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 8 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[XOR]]
+//
+svint16_t xor_i16(svint16_t a, svint16_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[XOR]]
+//
+svint32_t xor_i32(svint32_t a, svint32_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[XOR]]
+//
+svint64_t xor_i64(svint64_t a, svint64_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[XOR]]
+//
+svuint8_t xor_u8(svuint8_t a, svuint8_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 8 x i16> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[XOR]]
+//
+svuint16_t xor_u16(svuint16_t a, svuint16_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 4 x i32> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[XOR]]
+//
+svuint32_t xor_u32(svuint32_t a, svuint32_t b) {
+  return a ^ b;
+}
+
+// CHECK-LABEL: @xor_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[XOR:%.*]] = xor <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[XOR]]
+//
+svuint64_t xor_u64(svuint64_t a, svuint64_t b) {
+  return a ^ b;
+}
+
+// NEG
+
+// CHECK-LABEL: @neg_bool(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 16 x i1> [[A:%.*]], shufflevector (<vscale x 16 x i1> insertelement (<vscale x 16 x i1> poison, i1 true, i32 0), <vscale x 16 x i1> poison, <vscale x 16 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 16 x i1> [[NEG]]
+//
+svbool_t neg_bool(svbool_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 16 x i8> [[A:%.*]], shufflevector (<vscale x 16 x i8> insertelement (<vscale x 16 x i8> poison, i8 -1, i32 0), <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[NEG]]
+//
+svint8_t neg_i8(svint8_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 8 x i16> [[A:%.*]], shufflevector (<vscale x 8 x i16> insertelement (<vscale x 8 x i16> poison, i16 -1, i32 0), <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[NEG]]
+//
+svint16_t neg_i16(svint16_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 4 x i32> [[A:%.*]], shufflevector (<vscale x 4 x i32> insertelement (<vscale x 4 x i32> poison, i32 -1, i32 0), <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[NEG]]
+//
+svint32_t neg_i32(svint32_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 2 x i64> [[A:%.*]], shufflevector (<vscale x 2 x i64> insertelement (<vscale x 2 x i64> poison, i64 -1, i32 0), <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[NEG]]
+//
+svint64_t neg_i64(svint64_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 16 x i8> [[A:%.*]], shufflevector (<vscale x 16 x i8> insertelement (<vscale x 16 x i8> poison, i8 -1, i32 0), <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[NEG]]
+//
+svuint8_t neg_u8(svuint8_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 8 x i16> [[A:%.*]], shufflevector (<vscale x 8 x i16> insertelement (<vscale x 8 x i16> poison, i16 -1, i32 0), <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[NEG]]
+//
+svuint16_t neg_u16(svuint16_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 4 x i32> [[A:%.*]], shufflevector (<vscale x 4 x i32> insertelement (<vscale x 4 x i32> poison, i32 -1, i32 0), <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[NEG]]
+//
+svuint32_t neg_u32(svuint32_t a) {
+  return ~a;
+}
+
+// CHECK-LABEL: @neg_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[NEG:%.*]] = xor <vscale x 2 x i64> [[A:%.*]], shufflevector (<vscale x 2 x i64> insertelement (<vscale x 2 x i64> poison, i64 -1, i32 0), <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer)
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[NEG]]
+//
+svuint64_t neg_u64(svuint64_t a) {
+  return ~a;
+}

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)(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 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)(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 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)(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 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)(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 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 % 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}}
 }

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 & 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 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 & f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 & b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 & f64); // expected-error{{invalid operands to binary expression}}
+}
+
+void or (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 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f32 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 | f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 | b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 | f64); // expected-error{{invalid operands to binary expression}}
+}
+
+void xor (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 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f32 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ u64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 ^ f64); // expected-error{{invalid operands to binary expression}}
+
+  (void)(f64 ^ b);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ i64); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ u8);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ u16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ u32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ f16); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 ^ f64); // expected-error{{invalid operands to binary expression}}
+}
+
+    void not(svfloat16_t f16, svfloat32_t f32, svfloat32_t f64) {
+  (void)(~f16); // expected-error{{invalid argument type}}
+  (void)(~f32); // expected-error{{invalid argument type}}
+  (void)(~f64); // expected-error{{invalid argument type}}
+}

clang/test/Sema/attr-arm-sve-vector-bits.c

void f(int c) {
   ss8 = ss8 == gs8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
 
   fs8 = fs8 == ss8; // expected-error {{cannot combine fixed-length and sizeless SVE vectors in expression, result is ambiguous}}
   fs8 = fs8 == gs8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
 
   gs8 = gs8 == ss8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
   gs8 = gs8 == fs8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
 
-  ss8 = ss8 & fs8; // expected-error {{invalid operands to binary expression}}
-  ss8 = ss8 & gs8; // expected-error {{invalid operands to binary expression}}
+  ss8 = ss8 & fs8; // expected-error {{cannot combine fixed-length and sizeless SVE vectors in expression, result is ambiguous}}
+  ss8 = ss8 & gs8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
 
-  fs8 = fs8 & ss8; // expected-error {{invalid operands to binary expression}}
+  fs8 = fs8 & ss8; // expected-error {{cannot combine fixed-length and sizeless SVE vectors in expression, result is ambiguous}}
   fs8 = fs8 & gs8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
 
-  gs8 = gs8 & ss8; // expected-error {{invalid operands to binary expression}}
+  gs8 = gs8 & ss8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
   gs8 = gs8 & fs8; // expected-error {{cannot combine GNU and SVE vectors in expression, result is ambiguous}}
 }
 
 // --------------------------------------------------------------------------//
 // Sizeof
 
 #define VECTOR_SIZE ((N / 8))
 #define PRED_SIZE ((N / 64))

clang/test/Sema/sizeless-1.c

void func(int sel) {
   global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}
 
   +init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   ++init_int8;      // expected-error {{cannot increment value of type 'svint8_t'}}
   init_int8++;      // expected-error {{cannot increment value of type 'svint8_t'}}
   -init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   --init_int8;      // expected-error {{cannot decrement value of type 'svint8_t'}}
   init_int8--;      // expected-error {{cannot decrement value of type 'svint8_t'}}
-  ~init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   !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 ^ init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 << init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 >> init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 < init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 <= init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 == init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 != init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 >= init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 > init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 &&init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 || init_int8; // expected-error {{invalid operands to binary expression}}
 
-  local_int8 &= init_int8;  // expected-error {{invalid operands to binary expression}}
-  local_int8 |= init_int8;  // expected-error {{invalid operands to binary expression}}
-  local_int8 ^= init_int8;  // expected-error {{invalid operands to binary expression}}
   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}}

clang/test/SemaCXX/sizeless-1.cpp

#endif
   global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}
 
   +init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   ++init_int8;      // expected-error {{cannot increment value of type 'svint8_t'}}
   init_int8++;      // expected-error {{cannot increment value of type 'svint8_t'}}
   -init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   --init_int8;      // expected-error {{cannot decrement value of type 'svint8_t'}}
   init_int8--;      // expected-error {{cannot decrement value of type 'svint8_t'}}
-  ~init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   !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 ^ init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 << init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 >> init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 < init_int8;  // expected-error {{invalid operands to binary expression}}
   local_int8 <= init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 == init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 != init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 >= init_int8; // expected-error {{invalid operands to binary expression}}
   local_int8 > init_int8;  // expected-error {{invalid operands to binary expression}}
   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 &= init_int8;  // expected-error {{invalid operands to binary expression}}
-  local_int8 |= init_int8;  // expected-error {{invalid operands to binary expression}}
-  local_int8 ^= init_int8;  // expected-error {{invalid operands to binary expression}}
   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}}