[clang][AArch64][SVE] Add unary +/- operators for SVE types

[DavidTruby]

Summary

This patch enables the unary promotion and negation operators on
SVE types.

[c-rhodes]

LGTM, just one minor comment

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

1654

should we add FP tests as well?

clang/lib/Sema/SemaExpr.cpp

case UO_Minus:
     if (resultType->isArithmeticType()) // C99 6.5.3.3p1
       break;
     else if (resultType->isVectorType() &&
              // The z vector extensions don't allow + or - with bool vectors.
              (!Context.getLangOpts().ZVector ||
               resultType->castAs<VectorType>()->getVectorKind() !=
               VectorType::AltiVecBool))
       break;
+    else if (resultType->isVLSTBuiltinType()) // SVE vectors allow + and -
+      break;
     else if (getLangOpts().CPlusPlus && // C++ [expr.unary.op]p6
              Opc == UO_Plus &&
              resultType->isPointerType())
       break;
 
     return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr)
       << resultType << Input.get()->getSourceRange());
 

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

 // 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;
 }
+
+// UNARY PROMOTION
+
+// CHECK-LABEL: @prom_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[A:%.*]]
+//
+svint8_t prom_i8(svint8_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[A:%.*]]
+//
+svint16_t prom_i16(svint16_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[A:%.*]]
+//
+svint32_t prom_i32(svint32_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[A:%.*]]
+//
+svint64_t prom_i64(svint64_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[A:%.*]]
+//
+svuint8_t prom_u8(svuint8_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[A:%.*]]
+//
+svuint16_t prom_u16(svuint16_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[A:%.*]]
+//
+svuint32_t prom_u32(svuint32_t a) {
+  return +a;
+}
+
+// CHECK-LABEL: @prom_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[A:%.*]]
+//
+svuint64_t prom_u64(svuint64_t a) {
+  return +a;
+}
+
+// UNARY NEGATION
+
+// CHECK-LABEL: @neg_i8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 16 x i8> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[SUB]]
+//
+svint8_t neg_i8(svint8_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_i16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i16> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[SUB]]
+//
+svint16_t neg_i16(svint16_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_i32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i32> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[SUB]]
+//
+svint32_t neg_i32(svint32_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_i64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i64> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[SUB]]
+//
+svint64_t neg_i64(svint64_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_u8(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 16 x i8> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 16 x i8> [[SUB]]
+//
+svuint8_t neg_u8(svuint8_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_u16(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 8 x i16> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 8 x i16> [[SUB]]
+//
+svuint16_t neg_u16(svuint16_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_u32(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 4 x i32> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 4 x i32> [[SUB]]
+//
+svuint32_t neg_u32(svuint32_t a) {
+  return -a;
+}
+
+// CHECK-LABEL: @neg_u64(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[SUB:%.*]] = sub <vscale x 2 x i64> zeroinitializer, [[A:%.*]]
+// CHECK-NEXT:    ret <vscale x 2 x i64> [[SUB]]
+//
+svuint64_t neg_u64(svuint64_t a) {
+  return -a;
+}

clang/test/Sema/sizeless-1.c

void func(int sel) {
   ++global_int8_ptr;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   --global_int8_ptr;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr + 1;               // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr - 1;               // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr += 1;              // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr -= 1;              // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}
 
-  +init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   ++init_int8;      // expected-error {{cannot increment value of type 'svint8_t'}}
   init_int8++;      // expected-error {{cannot increment value of type 'svint8_t'}}
-  -init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   --init_int8;      // expected-error {{cannot decrement value of type 'svint8_t'}}
   init_int8--;      // expected-error {{cannot decrement value of type 'svint8_t'}}
   !init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   *init_int8;       // expected-error {{indirection requires pointer operand}}
   __real init_int8; // expected-error {{invalid type 'svint8_t'}}
   __imag init_int8; // expected-error {{invalid type 'svint8_t'}}
 
   local_int8 &&init_int8;  // expected-error {{invalid operands to binary expression}}

clang/test/SemaCXX/sizeless-1.cpp

#endif
   ++global_int8_ptr;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   --global_int8_ptr;                 // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr + 1;               // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr - 1;               // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr += 1;              // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr -= 1;              // expected-error {{arithmetic on a pointer to sizeless type}}
   global_int8_ptr - global_int8_ptr; // expected-error {{arithmetic on a pointer to sizeless type}}
 
-  +init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   ++init_int8;      // expected-error {{cannot increment value of type 'svint8_t'}}
   init_int8++;      // expected-error {{cannot increment value of type 'svint8_t'}}
-  -init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   --init_int8;      // expected-error {{cannot decrement value of type 'svint8_t'}}
   init_int8--;      // expected-error {{cannot decrement value of type 'svint8_t'}}
   !init_int8;       // expected-error {{invalid argument type 'svint8_t'}}
   *init_int8;       // expected-error {{indirection requires pointer operand}}
   __real init_int8; // expected-error {{invalid type 'svint8_t'}}
   __imag init_int8; // expected-error {{invalid type 'svint8_t'}}
 
   local_int8 &&init_int8;  // expected-error {{invalid operands to binary expression}} expected-error {{not contextually convertible}}