[Sema][SVE] Reject subscripts on pointers to sizeless types

[rsandifo-arm]

Summary

clang currently accepts:

__SVInt8_t &foo1(__SVInt8_t *x) { return *x; }
__SVInt8_t &foo2(__SVInt8_t *x) { return x[1]; }

The first function is valid ACLE code and generates correct LLVM IR
(and assembly code). But the second function is invalid for the
same reason that arrays of sizeless types are. Trying to code-generate
the function leads to:

llvm/include/llvm/Support/TypeSize.h:126: uint64_t llvm::TypeSize::getFixedSize() const: Assertion `!IsScalable && "Request for a fixed size on a s

calable object"' failed.

This patch reports an appropriate diagnostic instead.

[efriedma]

I'm not sure we actually want to reject this; let's discuss on the review for D76086, since subscripting is sort of a special case of arithmetic.

[rsandifo-arm]

In D76084#1920103, @efriedma wrote:

I'm not sure we actually want to reject this; let's discuss on the review for D76086, since subscripting is sort of a special case of arithmetic.

A silly corner case for this is:

template<typename T>
constexpr __SIZE_TYPE__ f(T *x) { return &x[1] - x; }
typedef int arr1[f((int *)0) - 1];
typedef int arr2[f((__SVInt8_t *)0) - 1];

which gives:

a.cpp:2:48: warning: subtraction of pointers to type '__SVInt8_t' of zero size has undefined behavior [-Wpointer-arith]
constexpr __SIZE_TYPE__ f(T *x) { return &x[1] - x; }
                                         ~~~~~ ^ ~
a.cpp:4:18: note: in instantiation of function template specialization 'f<__SVInt8_t>' requested here
typedef int arr2[f((__SVInt8_t *)0) - 1];
                 ^
a.cpp:4:13: error: variable length array declaration not allowed at file scope
typedef int arr2[f((__SVInt8_t *)0) - 1];
            ^

No real code would do anything like this of course. But I think it shows that it's going to be difficult to divide cases that measure sizeof only during CodeGen from those that measure it during Sema. With more and more things being accepted as constexprs, I think it's safer to treat any measure of sizeof as being at least potentially computable at compile time.

There's also the argument that this is what the spec says. I realise that's a fairly weak argument though, since the spec could always be changed.

[efriedma]

We already support sizeof expressions where the result can't be computed at compile-time. For example: int f(int n, int (*p)[n]) { return sizeof(*p); }. (For constant contexts specifically, see HandleSizeof() in ExprConstant.cpp.) I think any argument that it would be hard to extend that to cover sizeless types is pretty weak.

Of course, just because we can support it doesn't mean we should. As a matter of language design, we might want to discourage users from writing that sort of thing. It could be argued either way.

[efriedma]

This patch LGTM, at least for now.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def ext_subscript_non_lvalue : Extension<
   "ISO C90 does not allow subscripting non-lvalue array">;
 def err_typecheck_subscript_value : Error<
   "subscripted value is not an array, pointer, or vector">;
 def err_typecheck_subscript_not_integer : Error<
   "array subscript is not an integer">;
 def err_subscript_function_type : Error<
   "subscript of pointer to function type %0">;
-def err_subscript_incomplete_type : Error<
-  "subscript of pointer to incomplete type %0">;
+def err_subscript_incomplete_or_sizeless_type : Error<
+  "subscript of pointer to %select{incomplete|sizeless}0 type %1">;
 def err_dereference_incomplete_type : Error<
   "dereference of pointer to incomplete type %0">;
 def ext_gnu_subscript_void_type : Extension<
   "subscript of a pointer to void is a GNU extension">, InGroup<PointerArith>;
 def err_typecheck_member_reference_struct_union : Error<
   "member reference base type %0 is not a structure or union">;
 def err_typecheck_member_reference_ivar : Error<
   "%0 does not have a member named %1">;

clang/lib/Sema/SemaExpr.cpp

if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {
     // GNU extension: subscripting on pointer to void
     Diag(LLoc, diag::ext_gnu_subscript_void_type)
       << BaseExpr->getSourceRange();
 
     // C forbids expressions of unqualified void type from being l-values.
     // See IsCForbiddenLValueType.
     if (!ResultType.hasQualifiers()) VK = VK_RValue;
   } else if (!ResultType->isDependentType() &&
-      RequireCompleteType(LLoc, ResultType,
-                          diag::err_subscript_incomplete_type, BaseExpr))
+             RequireCompleteSizedType(
+                 LLoc, ResultType,
+                 diag::err_subscript_incomplete_or_sizeless_type, BaseExpr))
     return ExprError();
 
   assert(VK == VK_RValue || LangOpts.CPlusPlus ||
          !ResultType.isCForbiddenLValueType());
 
   if (LHSExp->IgnoreParenImpCasts()->getType()->isVariablyModifiedType() &&
       FunctionScopes.size() > 1) {
     if (auto *TT =

clang/test/Sema/sizeless-1.c

void func(int sel) {
   dump(&volatile_int8);
   dump(&const_volatile_int8);
 
   *&local_int8 = local_int8;
   *&const_int8 = local_int8; // expected-error {{read-only variable is not assignable}}
   *&volatile_int8 = local_int8;
   *&const_volatile_int8 = local_int8; // expected-error {{read-only variable is not assignable}}
 
+  global_int8_ptr[0] = local_int8;       // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}
+  global_int8_ptr[1] = local_int8;       // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}
+  global_int8_ptr = &global_int8_ptr[2]; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}
+
   overf(local_int8);
   overf(local_int16);
 
   overf8(local_int8);
   overf8(local_int16); // expected-error {{no matching function}}
 
   overf16(local_int8); // expected-error {{no matching function}}
   overf16(local_int16);

clang/test/SemaCXX/sizeless-1.cpp

#endif
   dump(&volatile_int8);
   dump(&const_volatile_int8);
 
   *&local_int8 = local_int8;
   *&const_int8 = local_int8; // expected-error {{read-only variable is not assignable}}
   *&volatile_int8 = local_int8;
   *&const_volatile_int8 = local_int8; // expected-error {{read-only variable is not assignable}}
 
+  global_int8_ptr[0] = local_int8;       // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}
+  global_int8_ptr[1] = local_int8;       // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}
+  global_int8_ptr = &global_int8_ptr[2]; // expected-error {{subscript of pointer to sizeless type 'svint8_t'}}
+
   overf(local_int8);
   overf(local_int16);
 
   overf8(local_int8);
   overf8(local_int16); // expected-error {{no matching function}}
 
   overf16(local_int8); // expected-error {{no matching function}}
   overf16(local_int16);