[clang][AArc64][SVE] Implement vector-scalar operators

[DavidTruby]

Summary

This patch extends the support for C/C++ operators for SVE
types to allow one of the arguments to be a scalar, in which
case a vector splat is performed.

Depends on D121119

[DavidTruby]

Fix mistake in unsigned tests

[paulwalker-arm]

It looks like the issue you fixed for the integer tests also need fixing for the floating point variants.

[DavidTruby]

In D121829#3386736, @paulwalker-arm wrote:

It looks like the issue you fixed for the integer tests also need fixing for the floating point variants.

Yeah, this is what you get when you think you're being really smart with sed... Will upload a fix!

[DavidTruby]

When updating the float tests it seems this is causing some issues with fp16 support, which I am investigating.

[DavidTruby]

Fix non-valid operation diagnostics
Add correct float tests
Add negative tests for invalid types

[DavidTruby]

Rebase

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, bool IsCompAssign,
                                        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/CodeGen/CGExprScalar.cpp

 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/CodeGenOptions.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APFixedPoint.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/FixedPointBuilder.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IntrinsicsPowerPC.h"
 #include "llvm/IR/MatrixBuilder.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/TypeSize.h"
 #include <cstdarg>
 
 using namespace clang;
 using namespace CodeGen;
 using llvm::Value;
 
 //===----------------------------------------------------------------------===//
 //                         Scalar Expression Emitter
case CK_ToVoid: {
     return nullptr;
   }
   case CK_MatrixCast: {
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                                 CE->getExprLoc());
   }
   case CK_VectorSplat: {
     llvm::Type *DstTy = ConvertType(DestTy);
-    Value *Elt = Visit(const_cast<Expr*>(E));
+    Value *Elt = Visit(const_cast<Expr *>(E));
     // Splat the element across to all elements
-    unsigned NumElements = cast<llvm::FixedVectorType>(DstTy)->getNumElements();
+    llvm::ElementCount NumElements =
+        cast<llvm::VectorType>(DstTy)->getElementCount();
     return Builder.CreateVectorSplat(NumElements, Elt, "splat");
   }
 
   case CK_FixedPointCast:
     return EmitScalarConversion(Visit(E), E->getType(), DestTy,
                                 CE->getExprLoc());
 
   case CK_FixedPointToBoolean:

clang/lib/Sema/SemaExpr.cpp

QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
   Diag(Loc, DiagID)
     << LHSType << RHSType
     << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
   return QualType();
 }
 
 QualType Sema::CheckSizelessVectorOperands(ExprResult &LHS, ExprResult &RHS,
                                            SourceLocation Loc,
+                                           bool IsCompAssign,
                                            ArithConvKind OperationKind) {
+  if (!IsCompAssign) {
+    LHS = DefaultFunctionArrayLvalueConversion(LHS.get());
+    if (LHS.isInvalid())
+      return QualType();
+  }
+  RHS = DefaultFunctionArrayLvalueConversion(RHS.get());
+  if (RHS.isInvalid())
+    return QualType();
+
   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 ((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;
 
+  auto tryScalableVectorConvert = [this](ExprResult *Src, QualType SrcType,
+                                         QualType DestType) {
+    const QualType DestBaseType = DestType->getSveEltType(Context);
+    if (DestBaseType->getUnqualifiedDesugaredType() ==
+        SrcType->getUnqualifiedDesugaredType()) {
+      unsigned DiagID = diag::err_typecheck_invalid_operands;
+      if (!tryVectorConvertAndSplat(*this, Src, SrcType, DestBaseType, DestType,
+                                    DiagID))
+        return DestType;
+    }
+    return QualType();
+  };
+
+  if (LHSType->isVLSTBuiltinType() && !RHSType->isVLSTBuiltinType()) {
+    auto DestType = tryScalableVectorConvert(&RHS, RHSType, LHSType);
+    if (DestType == QualType())
+      return InvalidOperands(Loc, LHS, RHS);
+    return DestType;
+  }
+
+  if (RHSType->isVLSTBuiltinType() && !LHSType->isVLSTBuiltinType()) {
+    auto DestType = tryScalableVectorConvert((IsCompAssign ? nullptr : &LHS),
+                                             LHSType, RHSType);
+    if (DestType == QualType())
+      return InvalidOperands(Loc, LHS, RHS);
+    return DestType;
+  }
+
   Diag(Loc, DiagID) << LHSType << RHSType << LHS.get()->getSourceRange()
                     << RHS.get()->getSourceRange();
   return QualType();
 }
 
 // checkArithmeticNull - Detect when a NULL constant is used improperly in an
 // expression.  These are mainly cases where the null pointer is used as an
 // integer instead of a pointer.
QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
   QualType RHSTy = RHS.get()->getType();
   if (LHSTy->isVectorType() || RHSTy->isVectorType())
     return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                /*AllowBothBool*/ getLangOpts().AltiVec,
                                /*AllowBoolConversions*/ false,
                                /*AllowBooleanOperation*/ false,
                                /*ReportInvalid*/ true);
   if (LHSTy->isVLSTBuiltinType() || RHSTy->isVLSTBuiltinType())
-    return CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
+    return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
+                                       ACK_Arithmetic);
   if (!IsDiv &&
       (LHSTy->isConstantMatrixType() || RHSTy->isConstantMatrixType()))
     return CheckMatrixMultiplyOperands(LHS, RHS, Loc, IsCompAssign);
   // For division, only matrix-by-scalar is supported. Other combinations with
   // matrix types are invalid.
   if (IsDiv && LHSTy->isConstantMatrixType() && RHSTy->isArithmeticType())
     return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);
 
if (LHS.get()->getType()->hasIntegerRepresentation() &&
       return CheckVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                  /*AllowBothBool*/ getLangOpts().AltiVec,
                                  /*AllowBoolConversions*/ false,
                                  /*AllowBooleanOperation*/ false,
                                  /*ReportInvalid*/ true);
     return InvalidOperands(Loc, LHS, RHS);
   }
 
-  if (LHS.get()->getType()->isVLSTBuiltinType() &&
+  if (LHS.get()->getType()->isVLSTBuiltinType() ||
       RHS.get()->getType()->isVLSTBuiltinType()) {
-    if (LHS.get()
-            ->getType()
-            ->getSveEltType(Context)
-            ->hasIntegerRepresentation() &&
-        RHS.get()
-            ->getType()
-            ->getSveEltType(Context)
-            ->hasIntegerRepresentation())
-      return CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
+    if (LHS.get()->getType()->hasIntegerRepresentation() &&
+        RHS.get()->getType()->hasIntegerRepresentation())
+      return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
+                                         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 =
                             /*ReportInvalid*/ true);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isVLSTBuiltinType() ||
       RHS.get()->getType()->isVLSTBuiltinType()) {
     QualType compType =
-        CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
+        CheckSizelessVectorOperands(LHS, RHS, Loc, CompLHSTy, ACK_Arithmetic);
     if (CompLHSTy)
       *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
       RHS.get()->getType()->isConstantMatrixType()) {
     QualType compType =
QualType compType =
                             /*ReportInvalid*/ true);
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isVLSTBuiltinType() ||
       RHS.get()->getType()->isVLSTBuiltinType()) {
     QualType compType =
-        CheckSizelessVectorOperands(LHS, RHS, Loc, ACK_Arithmetic);
+        CheckSizelessVectorOperands(LHS, RHS, Loc, CompLHSTy, ACK_Arithmetic);
     if (CompLHSTy)
       *CompLHSTy = compType;
     return compType;
   }
 
   if (LHS.get()->getType()->isConstantMatrixType() ||
       RHS.get()->getType()->isConstantMatrixType()) {
     QualType compType =
if (LHS.get()->getType()->hasIntegerRepresentation() &&
                                  /*ReportInvalid*/ true);
     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 CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
+                                         ACK_BitwiseOp);
+    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, IsCompAssign,
+                                         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())

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

 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
 //
 svfloat64_t add_inplace_f64(svfloat64_t a, svfloat64_t b) {
   return a += b;
 }
 
+// CHECK-LABEL: @add_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svint8_t add_scalar_i8(svint8_t a, int8_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[ADD]]
+//
+svint16_t add_scalar_i16(svint16_t a, int16_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[ADD]]
+//
+svint32_t add_scalar_i32(svint32_t a, int32_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[ADD]]
+//
+svint64_t add_scalar_i64(svint64_t a, int64_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[ADD]]
+//
+svuint8_t add_scalar_u8(svuint8_t a, uint8_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[ADD]]
+//
+svuint16_t add_scalar_u16(svuint16_t a, uint16_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[ADD]]
+//
+svuint32_t add_scalar_u32(svuint32_t a, uint32_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = add <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[ADD]]
+//
+svuint64_t add_scalar_u64(svuint64_t a, uint64_t b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_f16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x half> poison, half [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x half> [[SPLAT_SPLATINSERT]], <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 8 x half> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x half> [[ADD]]
+//
+svfloat16_t add_scalar_f16(svfloat16_t a, __fp16 b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x float> poison, float [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x float> [[SPLAT_SPLATINSERT]], <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 4 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x float> [[ADD]]
+//
+svfloat32_t add_scalar_f32(svfloat32_t a, float b) {
+  return a + b;
+}
+
+// CHECK-LABEL: @add_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x double> poison, double [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x double> [[SPLAT_SPLATINSERT]], <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <vscale x 2 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x double> [[ADD]]
+//
+svfloat64_t add_scalar_f64(svfloat64_t a, double b) {
+  return a + b;
+}
+
 // SUBTRACTION
 
 // CHECK-LABEL: @sub_i8(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 16 x i8> [[SUB]]
 //
 svint8_t sub_i8(svint8_t a, svint8_t b) {

 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 2 x double> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 2 x double> [[SUB]]
 //
 svfloat64_t sub_inplace_f64(svfloat64_t a, svfloat64_t b) {
   return a - b;
 }
 
+// CHECK-LABEL: @sub_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[SUB]]
+//
+svint8_t sub_scalar_i8(svint8_t a, int8_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[SUB]]
+//
+svint16_t sub_scalar_i16(svint16_t a, int16_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[SUB]]
+//
+svint32_t sub_scalar_i32(svint32_t a, int32_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[SUB]]
+//
+svint64_t sub_scalar_i64(svint64_t a, int64_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[SUB]]
+//
+svuint8_t sub_scalar_u8(svuint8_t a, uint8_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[SUB]]
+//
+svuint16_t sub_scalar_u16(svuint16_t a, uint16_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[SUB]]
+//
+svuint32_t sub_scalar_u32(svuint32_t a, uint32_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[SUB]]
+//
+svuint64_t sub_scalar_u64(svuint64_t a, uint64_t b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_f16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x half> poison, half [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x half> [[SPLAT_SPLATINSERT]], <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 8 x half> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x half> [[SUB]]
+//
+svfloat16_t sub_scalar_f16(svfloat16_t a, __fp16 b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x float> poison, float [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x float> [[SPLAT_SPLATINSERT]], <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 4 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x float> [[SUB]]
+//
+svfloat32_t sub_scalar_f32(svfloat32_t a, float b) {
+  return a - b;
+}
+
+// CHECK-LABEL: @sub_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x double> poison, double [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x double> [[SPLAT_SPLATINSERT]], <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <vscale x 2 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x double> [[SUB]]
+//
+svfloat64_t sub_scalar_f64(svfloat64_t a, double b) {
+  return a - b;
+}
+
 // MULTIPLICATION
 
 // CHECK-LABEL: @mul_i8(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 16 x i8> [[MUL]]
 //
 svint8_t mul_i8(svint8_t a, svint8_t b) {

 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 2 x double> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 2 x double> [[MUL]]
 //
 svfloat64_t mul_inplace_f64(svfloat64_t a, svfloat64_t b) {
   return a * b;
 }
 
+// CHECK-LABEL: @mul_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[MUL]]
+//
+svint8_t mul_scalar_i8(svint8_t a, int8_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[MUL]]
+//
+svint16_t mul_scalar_i16(svint16_t a, int16_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[MUL]]
+//
+svint32_t mul_scalar_i32(svint32_t a, int32_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[MUL]]
+//
+svint64_t mul_scalar_i64(svint64_t a, int64_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[MUL]]
+//
+svuint8_t mul_scalar_u8(svuint8_t a, uint8_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[MUL]]
+//
+svuint16_t mul_scalar_u16(svuint16_t a, uint16_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[MUL]]
+//
+svuint32_t mul_scalar_u32(svuint32_t a, uint32_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = mul <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[MUL]]
+//
+svuint64_t mul_scalar_u64(svuint64_t a, uint64_t b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_f16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x half> poison, half [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x half> [[SPLAT_SPLATINSERT]], <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 8 x half> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x half> [[MUL]]
+//
+svfloat16_t mul_scalar_f16(svfloat16_t a, __fp16 b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x float> poison, float [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x float> [[SPLAT_SPLATINSERT]], <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 4 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x float> [[MUL]]
+//
+svfloat32_t mul_scalar_f32(svfloat32_t a, float b) {
+  return a * b;
+}
+
+// CHECK-LABEL: @mul_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x double> poison, double [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x double> [[SPLAT_SPLATINSERT]], <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <vscale x 2 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x double> [[MUL]]
+//
+svfloat64_t mul_scalar_f64(svfloat64_t a, double b) {
+  return a * b;
+}
+
 // DIVISION
 
 // CHECK-LABEL: @div_i8(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 16 x i8> [[DIV]]
 //
 svint8_t div_i8(svint8_t a, svint8_t b) {

 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 2 x double> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 2 x double> [[DIV]]
 //
 svfloat64_t div_inplace_f64(svfloat64_t a, svfloat64_t b) {
   return a / b;
 }
 
+// CHECK-LABEL: @div_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[DIV]]
+//
+svint8_t div_scalar_i8(svint8_t a, int8_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[DIV]]
+//
+svint16_t div_scalar_i16(svint16_t a, int16_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[DIV]]
+//
+svint32_t div_scalar_i32(svint32_t a, int32_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = sdiv <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[DIV]]
+//
+svint64_t div_scalar_i64(svint64_t a, int64_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = udiv <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[DIV]]
+//
+svuint8_t div_scalar_u8(svuint8_t a, uint8_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = udiv <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[DIV]]
+//
+svuint16_t div_scalar_u16(svuint16_t a, uint16_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = udiv <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[DIV]]
+//
+svuint32_t div_scalar_u32(svuint32_t a, uint32_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = udiv <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[DIV]]
+//
+svuint64_t div_scalar_u64(svuint64_t a, uint64_t b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_f16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x half> poison, half [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x half> [[SPLAT_SPLATINSERT]], <vscale x 8 x half> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 8 x half> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x half> [[DIV]]
+//
+svfloat16_t div_scalar_f16(svfloat16_t a, __fp16 b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_f32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x float> poison, float [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x float> [[SPLAT_SPLATINSERT]], <vscale x 4 x float> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 4 x float> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x float> [[DIV]]
+//
+svfloat32_t div_scalar_f32(svfloat32_t a, float b) {
+  return a / b;
+}
+
+// CHECK-LABEL: @div_scalar_f64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x double> poison, double [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x double> [[SPLAT_SPLATINSERT]], <vscale x 2 x double> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <vscale x 2 x double> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x double> [[DIV]]
+//
+svfloat64_t div_scalar_f64(svfloat64_t a, double b) {
+  return a / b;
+}
+
 // REMAINDER
 
 // CHECK-LABEL: @rem_i8(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 16 x i8> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 16 x i8> [[REM]]
 //
 svint8_t rem_i8(svint8_t a, svint8_t b) {

 // CHECK-LABEL: @rem_inplace_u64(
 // CHECK-NEXT:  entry:
 // CHECK-NEXT:    [[REM:%.*]] = urem <vscale x 2 x i64> [[A:%.*]], [[B:%.*]]
 // CHECK-NEXT:    ret <vscale x 2 x i64> [[REM]]
 //
 svuint64_t rem_inplace_u64(svuint64_t a, svuint64_t b) {
   return a % b;
 }
+
+// CHECK-LABEL: @rem_scalar_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[REM]]
+//
+svint8_t rem_scalar_i8(svint8_t a, int8_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[REM]]
+//
+svint16_t rem_scalar_i16(svint16_t a, int16_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[REM]]
+//
+svint32_t rem_scalar_i32(svint32_t a, int32_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = srem <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[REM]]
+//
+svint64_t rem_scalar_i64(svint64_t a, int64_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 16 x i8> poison, i8 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 16 x i8> [[SPLAT_SPLATINSERT]], <vscale x 16 x i8> poison, <vscale x 16 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = urem <vscale x 16 x i8> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[REM]]
+//
+svuint8_t rem_scalar_u8(svuint8_t a, uint8_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 8 x i16> poison, i16 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 8 x i16> [[SPLAT_SPLATINSERT]], <vscale x 8 x i16> poison, <vscale x 8 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = urem <vscale x 8 x i16> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[REM]]
+//
+svuint16_t rem_scalar_u16(svuint16_t a, uint16_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 4 x i32> poison, i32 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 4 x i32> [[SPLAT_SPLATINSERT]], <vscale x 4 x i32> poison, <vscale x 4 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = urem <vscale x 4 x i32> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[REM]]
+//
+svuint32_t rem_scalar_u32(svuint32_t a, uint32_t b) {
+  return a % b;
+}
+
+// CHECK-LABEL: @rem_scalar_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SPLAT_SPLATINSERT:%.*]] = insertelement <vscale x 2 x i64> poison, i64 [[B:%.*]], i32 0
+// CHECK-NEXT:    [[SPLAT_SPLAT:%.*]] = shufflevector <vscale x 2 x i64> [[SPLAT_SPLATINSERT]], <vscale x 2 x i64> poison, <vscale x 2 x i32> zeroinitializer
+// CHECK-NEXT:    [[REM:%.*]] = urem <vscale x 2 x i64> [[A:%.*]], [[SPLAT_SPLAT]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[REM]]
+//
+svuint64_t rem_scalar_u64(svuint64_t a, uint64_t b) {
+  return a % b;
+}

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

void add(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
   (void)(i8 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u8 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(u8 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i16 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(i16 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(i16 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u16 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(u16 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(u16 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i32 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(i32 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(i32 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u32 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(u32 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(u32 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i64 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(i64 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u64 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(u64 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f16 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(f16 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(f16 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 + f32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f32 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(f32 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(f32 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 + u64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 + f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 + 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f64 + b);   // expected-error{{invalid operands to binary expression}}
   (void)(f64 + i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 + i16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 + i32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 + i64); // expected-error{{invalid operands to binary expression}}
   (void)(f64 + u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 + u16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 + u32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 + f16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 + f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 + 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 + 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 + 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 + 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 + 0.f); // expected-error{{invalid operands to binary expression}}
 }
 
 void sub(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
   (void)(b - b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(i8 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u8 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(u8 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i16 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(i16 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(i16 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u16 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(u16 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(u16 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i32 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(i32 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(i32 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u32 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(u32 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(u32 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i64 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(i64 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u64 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(u64 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f16 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(f16 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(f16 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 - f32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f32 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(f32 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(f32 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 - u64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 - f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 - 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f64 - b);   // expected-error{{invalid operands to binary expression}}
   (void)(f64 - i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 - i16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 - i32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 - i64); // expected-error{{invalid operands to binary expression}}
   (void)(f64 - u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 - u16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 - u32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 - f16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 - f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 - 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 - 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 - 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 - 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 - 0.f); // expected-error{{invalid operands to binary expression}}
 }
 
 void mul(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
   (void)(b * b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(i8 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u8 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(u8 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i16 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(i16 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(i16 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u16 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(u16 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(u16 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i32 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(i32 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(i32 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u32 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(u32 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(u32 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i64 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(i64 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u64 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(u64 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f16 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(f16 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(f16 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 * f32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f32 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(f32 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(f32 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 * u64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 * f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 * 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f64 * b);   // expected-error{{invalid operands to binary expression}}
   (void)(f64 * i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 * i16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 * i32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 * i64); // expected-error{{invalid operands to binary expression}}
   (void)(f64 * u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 * u16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 * u32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 * f16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 * f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 * 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 * 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 * 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 * 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 * 0.f); // expected-error{{invalid operands to binary expression}}
 }
 
 void div(svint8_t i8, svint16_t i16, svint32_t i32, svint64_t i64,
          svuint8_t u8, svuint16_t u16, svuint32_t u32, svuint64_t u64,
          svfloat16_t f16, svfloat32_t f32, svfloat64_t f64,
          svbool_t b) {
   (void)(b / b); // expected-error{{invalid operands to binary expression}}
 
   (void)(i8 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(i8 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(i8 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u8 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(u8 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i16 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(i16 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(i16 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u16 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(u16 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(u16 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i32 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(i32 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(i32 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u32 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(u32 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(u32 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i64 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(i64 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u64 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(u64 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f16 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(f16 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(f16 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 / f32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f32 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(f32 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(f32 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 / u64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 / f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 / 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f64 / b);   // expected-error{{invalid operands to binary expression}}
   (void)(f64 / i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 / i16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 / i32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 / i64); // expected-error{{invalid operands to binary expression}}
   (void)(f64 / u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 / u16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 / u32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 / f16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 / f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 / 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 / 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 / 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 / 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 / 0.f); // expected-error{{invalid operands to binary expression}}
 }
 
 void 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)(i8 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i8 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u8 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(u8 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(u8 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u8 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i16 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(i16 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i16 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(i16 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(i16 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(i16 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i16 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u16 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(u16 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u16 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(u16 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(u16 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(u16 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u16 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i32 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(i32 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i32 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(i32 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(i32 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(i32 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i32 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u32 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(u32 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u32 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(u32 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(u32 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(u32 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u32 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(i64 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(i64 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(i64 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(i64 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(i64 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(i64 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(u64 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(u64 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(u64 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(u64 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(u64 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(u64 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f16 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(f16 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(f16 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f16 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(f16 % f32); // expected-error{{invalid operands to binary expression}}
   (void)(f16 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f16 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f32 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(f32 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(f32 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f32 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 % u64); // expected-error{{invalid operands to binary expression}}
   (void)(f32 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(f32 % f64); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f32 % 0.);  // expected-error{{invalid operands to binary expression}}
 
   (void)(f64 % b);   // expected-error{{invalid operands to binary expression}}
   (void)(f64 % i8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 % i16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 % i32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 % i64); // expected-error{{invalid operands to binary expression}}
   (void)(f64 % u8);  // expected-error{{invalid operands to binary expression}}
   (void)(f64 % u16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 % u32); // expected-error{{invalid operands to binary expression}}
   (void)(f64 % f16); // expected-error{{invalid operands to binary expression}}
   (void)(f64 % f32); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % 0);   // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % 0l);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % 0u);  // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % 0ul); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % 0.f); // expected-error{{invalid operands to binary expression}}
+  (void)(f64 % 0.);  // expected-error{{invalid operands to binary expression}}
 }