[Sema][SVE] Don't allow sizeless objects to be thrown

[rsandifo-arm]

Summary

The same rules for throwing and catching incomplete types also apply
to sizeless types. This patch enforces that for throw statements.
It also make sure that we use "sizeless type" rather "incomplete type"
in the associated message. (Both are correct, but "sizeless type" is
more specific and hopefully more user-friendly.)

[efriedma]

Why is throwing an svint8_t * an error? I don't see any obvious reason to forbid that.

[rsandifo-arm]

In D76088#1920070, @efriedma wrote:

Why is throwing an svint8_t * an error? I don't see any obvious reason to forbid that.

Yeah, I agree there's no obvious reason why it wouldn't work. The same reasoning applies here as for D76086:

(In practice, throwing pointers to sizeless types could probably
be handled without problems. It would be an odd thing to do though,
and so it didn't seem worth treating as a special case.)

I.e. once sizeless types are treated as incomplete types (which happens towards the end of the series), we'd have to create a new rule to allow sizeless types only for the pointer case. But since no-one will hopefully want to throw such a thing, it seemed better to keep it simple and leave the rule unchanged.

[efriedma]

We already have a special case for void* here; it's trivial to extend that to also check for sizeless types. I don't want to add weird semantic restrictions just to save a few characters in the compiler.

I agree that most people won't run into it either way.

[rsandifo-arm]

Allow pointers to sizeless types to be thrown.

[rsandifo-arm]

In D76088#1920241, @efriedma wrote:

We already have a special case for void* here; it's trivial to extend that to also check for sizeless types. I don't want to add weird semantic restrictions just to save a few characters in the compiler.

OK, I've done that in v2. It didn't feel right to add a Ty->isSizelessType() check alongside the existing Ty->isVoidType() check because sizelessness is IMO logically orthogonal to whether we have a fully fleshed-out definition or not. E.g. an earlier version of the extension allowed sizeless structures, and although they are no longer supported, the principle still holds that forward declarations of sizeless types make just as much conceptual sense as forward declarations of sized types. We'd then want to treat pointers to incompletely-defined sizeless types in the same as pointers to incompletely-defined sized types. The patch therefore checks for a sizeless type after RequireCompleteType instead.

[efriedma]

LGTM

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_conditional_vector_mismatched_vectors
     : Error<"vector operands to the vector conditional must be the same type "
             "%diff{($ and $)|}0,1}">;
 
 def err_throw_incomplete : Error<
   "cannot throw object of incomplete type %0">;
 def err_throw_incomplete_ptr : Error<
   "cannot throw pointer to object of incomplete type %0">;
+def err_throw_sizeless : Error<
+  "cannot throw object of sizeless type %0">;
 def warn_throw_underaligned_obj : Warning<
   "underaligned exception object thrown">,
   InGroup<UnderalignedExceptionObject>;
 def note_throw_underaligned_obj : Note<
   "required alignment of type %0 (%1 bytes) is larger than the supported "
   "alignment of C++ exception objects on this target (%2 bytes)">;
 def err_return_in_constructor_handler : Error<
   "return in the catch of a function try block of a constructor is illegal">;

clang/lib/Sema/SemaExprCXX.cpp

bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc,
   }
   if (!isPointer || !Ty->isVoidType()) {
     if (RequireCompleteType(ThrowLoc, Ty,
                             isPointer ? diag::err_throw_incomplete_ptr
                                       : diag::err_throw_incomplete,
                             E->getSourceRange()))
       return true;
 
+    if (!isPointer && Ty->isSizelessType()) {
+      Diag(ThrowLoc, diag::err_throw_sizeless) << Ty << E->getSourceRange();
+      return true;
+    }
+
     if (RequireNonAbstractType(ThrowLoc, ExceptionObjectTy,
                                diag::err_throw_abstract_type, E))
       return true;
   }
 
   // If the exception has class type, we need additional handling.
   CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
   if (!RD)

clang/test/SemaCXX/sizeless-1.cpp

 #endif
 
   local_int8 = static_cast<svint8_t>(local_int8);
   local_int8 = static_cast<svint8_t>(local_int16);  // expected-error {{static_cast from 'svint16_t' (aka '__SVInt16_t') to 'svint8_t' (aka '__SVInt8_t') is not allowed}}
   local_int8 = static_cast<svint8_t>(0);            // expected-error {{static_cast from 'int' to 'svint8_t' (aka '__SVInt8_t') is not allowed}}
   local_int16 = static_cast<svint16_t>(local_int8); // expected-error {{static_cast from 'svint8_t' (aka '__SVInt8_t') to 'svint16_t' (aka '__SVInt16_t') is not allowed}}
   sel = static_cast<int>(local_int8);               // expected-error {{static_cast from 'svint8_t' (aka '__SVInt8_t') to 'int' is not allowed}}
 
+  throw local_int8; // expected-error {{cannot throw object of sizeless type 'svint8_t'}}
+  throw global_int8_ptr;
+
   local_int8.~__SVInt8_t(); // expected-error {{object expression of non-scalar type 'svint8_t' (aka '__SVInt8_t') cannot be used in a pseudo-destructor expression}}
 
   (void)svint8_t();
 
   local_int8 = svint8_t();
   local_int8 = svint16_t(); // expected-error {{assigning to 'svint8_t' (aka '__SVInt8_t') from incompatible type 'svint16_t'}}
 
   s_template<int> st_int;