fixup: drop alloc_size attribute changes

Extending the range of functions alloc_size applies to makes no sense
without the __builtin_object_size-side support.

For now, just the malloc attribute changes should be enough.

Author: a-nogikh

clang/lib/Sema/SemaDeclAttr.cpp

@@ -564,37 +564,14 @@ static bool checkParamIsIntegerType(Sema &S, const Decl *D, const AttrInfo &AI,
   return true;
 }
 
-static bool isSpanLikeType(const QualType &Ty) {
-  // Check that the type is a plain record with the first field being a pointer
-  // type and the second field being an integer.
-  // This matches the common implementation of std::span or sized_allocation_t
-  // in P0901R11.
-  // Note that there may also be numerous cases of pointer+integer structures
-  // not actually exhibiting a std::span-like semantics, so sometimes
-  // this heuristic expectedly leads to false positive results.
-  const RecordDecl *RD = Ty->getAsRecordDecl();
-  if (!RD || RD->isUnion())
-    return false;
-  const RecordDecl *Def = RD->getDefinition();
-  if (!Def)
-    return false; // This is an incomplete type.
-  auto FieldsBegin = Def->field_begin();
-  if (std::distance(FieldsBegin, Def->field_end()) != 2)
-    return false;
-  const FieldDecl *FirstField = *FieldsBegin;
-  const FieldDecl *SecondField = *std::next(FieldsBegin);
-  return FirstField->getType()->isAnyPointerType() &&
-         SecondField->getType()->isIntegerType();
-}
-
 static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (!AL.checkAtLeastNumArgs(S, 1) || !AL.checkAtMostNumArgs(S, 2))
     return;
 
   assert(isFuncOrMethodForAttrSubject(D) && hasFunctionProto(D));
 
   QualType RetTy = getFunctionOrMethodResultType(D);
-  if (!RetTy->isPointerType() && !isSpanLikeType(RetTy)) {
+  if (!RetTy->isPointerType()) {
     S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL;
     return;
   }
@@ -1771,6 +1748,29 @@ static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   D->addAttr(::new (S.Context) TLSModelAttr(S.Context, AL, Model));
 }
 
+static bool isSpanLikeType(const QualType &Ty) {
+  // Check that the type is a plain record with the first field being a pointer
+  // type and the second field being an integer.
+  // This matches the common implementation of std::span or sized_allocation_t
+  // in P0901R11.
+  // Note that there may also be numerous cases of pointer+integer structures
+  // not actually exhibiting a std::span-like semantics, so sometimes
+  // this heuristic expectedly leads to false positive results.
+  const RecordDecl *RD = Ty->getAsRecordDecl();
+  if (!RD || RD->isUnion())
+    return false;
+  const RecordDecl *Def = RD->getDefinition();
+  if (!Def)
+    return false; // This is an incomplete type.
+  auto FieldsBegin = Def->field_begin();
+  if (std::distance(FieldsBegin, Def->field_end()) != 2)
+    return false;
+  const FieldDecl *FirstField = *FieldsBegin;
+  const FieldDecl *SecondField = *std::next(FieldsBegin);
+  return FirstField->getType()->isAnyPointerType() &&
+         SecondField->getType()->isIntegerType();
+}
+
 static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   QualType ResultType = getFunctionOrMethodResultType(D);
   if (!ResultType->isAnyPointerType() && !ResultType->isBlockPointerType() &&

clang/test/Sema/alloc-size.c

@@ -30,14 +30,6 @@ void *KR() __attribute__((alloc_size(1))); //expected-warning{{'alloc_size' attr
 void *(__attribute__((alloc_size(1))) * func_ptr1)(int);
 void *(__attribute__((alloc_size(1, 2))) func_ptr2)(int, int);
 
-// Applying alloc_size to functions returning a struct with a pointer as a first field should work.
-typedef struct {
-  void* p;
-  int n;
-} sized_ptr;
-
-sized_ptr sized_ptr_alloc(int len) __attribute__((alloc_size(1)));
-
 // TODO: according to GCC documentation the following should actually be the type
 // “pointer to pointer to alloc_size attributed function returning void*” and should
 // therefore be supported