https://github.com/Holo-xy updated https://github.com/llvm/llvm-project/pull/244630
>From 45a6998e8b8b71ffdfbbc67c27f59c28b0bab239 Mon Sep 17 00:00:00 2001 From: Holo-xy <[email protected]> Date: Mon, 19 Oct 2026 19:52:27 +0300 Subject: [PATCH 1/2] [BoundsSafety] Support counted_by on out parameters One pointer level below a parameter may have a count, as for an out parameter, and a parameter's count may dereference a parameter: `int *__counted_by(*len) *buf`. The parameter's own pointer may not have a count too. --- clang/include/clang/Sema/Sema.h | 8 ++- clang/lib/Sema/SemaBoundsSafety.cpp | 36 ++++++---- clang/lib/Sema/SemaType.cpp | 71 +++++++++++++++---- .../AST/attr-counted-by-function-params.c | 10 +++ .../Sema/attr-counted-by-function-params.c | 69 +++++++++++++----- 5 files changed, 150 insertions(+), 44 deletions(-) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index d95e0af922f4e..bb3aad8fa7125 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -2533,6 +2533,12 @@ class Sema final : public SemaBase { static BoundsAttributedType::BoundsAttrKind getBoundsAttrKind(const BoundsAttrFlags &); + /// The reference that the count \p E of a counted_by-family attribute is + /// made of: \p E itself, or the operand of `*` in \p E, which sets \p IsDeref + /// (a parameter's count may be a dereferenced parameter, `*len`). Null if + /// \p E is neither. + static DeclRefExpr *getCountDeclRef(Expr *E, bool &IsDeref); + /// Check the type shape for counted_by, sized_by and their _or_null variants. /// The caller checks declaration context, count expressions, flexible array /// member eligibility and nesting. @@ -2638,7 +2644,7 @@ class Sema final : public SemaBase { FieldDecl *FD, Expr *Arg); /// Check that \p E is a valid count for a counted_by-family attribute on - /// \p ParamTy, the type of a parameter. + /// \p ParamTy, the type of a parameter or of the pointer it points to. /// /// \returns false iff semantically valid. bool CheckCountedByAttrOnParam(QualType ParamTy, Expr *E, bool CountInBytes, diff --git a/clang/lib/Sema/SemaBoundsSafety.cpp b/clang/lib/Sema/SemaBoundsSafety.cpp index 6fcce221a26f7..e61c68d3447ba 100644 --- a/clang/lib/Sema/SemaBoundsSafety.cpp +++ b/clang/lib/Sema/SemaBoundsSafety.cpp @@ -54,6 +54,16 @@ Sema::BoundsAttrFlags Sema::BoundsAttrFlags::get(AttributeCommonInfo::Kind K) { return Flags; } +DeclRefExpr *Sema::getCountDeclRef(Expr *E, bool &IsDeref) { + IsDeref = false; + if (auto *UO = dyn_cast<UnaryOperator>(E); + UO && UO->getOpcode() == UO_Deref) { + E = UO->getSubExpr()->IgnoreImpCasts(); + IsDeref = true; + } + return dyn_cast<DeclRefExpr>(E); +} + static const RecordDecl * GetEnclosingNamedOrTopAnonRecord(const RecordDecl *RD) { // An unnamed struct is treated as anonymous struct at this point. @@ -240,11 +250,8 @@ bool Sema::ValidateBoundsAttrPosition(BoundsAttributedType::BoundsAttrKind Kind, } // Currently, only attributes at the outermost level of the declared type - // are supported. - // - // FIXME: Support indirect parameters such as: - // void f(int *__counted_by(*len) *buf, int *len); - // See https://github.com/llvm/llvm-project/issues/166411. + // are supported. The caller passes zero for the pointer that a parameter + // points to, as for an out parameter: `int *__counted_by(*len) *buf`. if (PointerNestLevel > 0) { Diag(AttrLoc, diag::err_counted_by_on_nested_pointer) << Kind; return false; @@ -279,17 +286,20 @@ bool Sema::ValidateBoundsAttrTypeForTypePosition( } /// The checks shared by the counts of fields and parameters: \p E must be a -/// non-boolean integer and a plain reference to a declaration. Returns that -/// declaration, or null after diagnosing. -static ValueDecl *checkCountRefersToDecl(Sema &S, Expr *E, unsigned Kind) { +/// non-boolean integer and a plain reference to a declaration, or if +/// \p AllowDeref, a dereference of one. Returns that declaration, or null after +/// diagnosing. +static ValueDecl *checkCountRefersToDecl(Sema &S, Expr *E, unsigned Kind, + bool AllowDeref) { if (!E->getType()->isIntegerType() || E->getType()->isBooleanType()) { S.Diag(E->getBeginLoc(), diag::err_count_attr_argument_not_integer) << Kind << E->getSourceRange(); return nullptr; } - auto *DRE = dyn_cast<DeclRefExpr>(E); - if (!DRE) { + bool IsDeref; + auto *DRE = Sema::getCountDeclRef(E, IsDeref); + if (!DRE || (IsDeref && !AllowDeref)) { S.Diag(E->getBeginLoc(), diag::err_count_attr_only_support_simple_decl_reference) << Kind << E->getSourceRange(); @@ -321,7 +331,8 @@ bool Sema::CheckCountedByAttrInRecord(const DeclContext *DC, QualType Ty, return true; } - ValueDecl *CountDecl = checkCountRefersToDecl(*this, E, Kind); + ValueDecl *CountDecl = + checkCountRefersToDecl(*this, E, Kind, /*AllowDeref=*/false); if (!CountDecl) return true; @@ -403,7 +414,8 @@ bool Sema::CheckCountedByAttrOnParam(QualType ParamTy, Expr *E, return true; } - ValueDecl *CountDecl = checkCountRefersToDecl(*this, E, Kind); + ValueDecl *CountDecl = + checkCountRefersToDecl(*this, E, Kind, /*AllowDeref=*/true); if (!CountDecl) return true; diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 5215c9acab9c5..10eac661a2ff6 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -182,6 +182,13 @@ static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, case ParsedAttr::AT_TypeNullableResult: \ case ParsedAttr::AT_TypeNullUnspecified +// Bounds attributes of the counted_by family. +#define COUNTED_BY_TYPE_ATTRS_CASELIST \ + case ParsedAttr::AT_CountedBy: \ + case ParsedAttr::AT_CountedByOrNull: \ + case ParsedAttr::AT_SizedBy: \ + case ParsedAttr::AT_SizedByOrNull + namespace { /// An object which stores processing state for the entire /// GetTypeForDeclarator process. @@ -4388,6 +4395,41 @@ static bool shouldHaveNullability(QualType T) { T->getCanonicalTypeInternal()); } +/// Whether the count on declarator chunk \p ChunkIndex of \p D (on its +/// declaration specifiers if \p ChunkIndex is the number of chunks) is on the +/// pointer that a parameter's own pointer or array points to, as for an out +/// parameter: `int *__counted_by(*len) *buf`. Only that one level may have a +/// count, so the parameter's own type may not have one too. +static bool isIndirectParamCount(const Declarator &D, unsigned ChunkIndex) { + if (D.getContext() != DeclaratorContext::Prototype) + return false; + + auto IsCount = [](const ParsedAttr &A) { + switch (A.getKind()) { + COUNTED_BY_TYPE_ATTRS_CASELIST: + return true; + default: + return false; + } + }; + if (llvm::any_of(D.getAttributes(), IsCount)) + return false; + + unsigned Levels = 0; + for (unsigned I = 0; I != ChunkIndex; ++I) { + const DeclaratorChunk &Chunk = D.getTypeObject(I); + if (Chunk.isParen()) + continue; + if (Chunk.Kind != DeclaratorChunk::Pointer && + Chunk.Kind != DeclaratorChunk::Array) + return false; + if (llvm::any_of(Chunk.getAttrs(), IsCount)) + return false; + ++Levels; + } + return Levels == 1; +} + static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) { @@ -9146,6 +9188,13 @@ static void HandleCountedByAttrOnType(TypeProcessingState &State, } unsigned chunkIndex = State.getCurrentChunkIndex(); + unsigned PointerNestLevel = getPointerNestLevel(D, chunkIndex); + + // A parameter may point to a counted pointer, as an out parameter does: + // `int *__counted_by(*len) *buf`. That count is nested, but allowed. + if (PointerNestLevel == 1 && CurType->isPointerType() && + isIndirectParamCount(D, chunkIndex)) + PointerNestLevel = 0; bool IsParameter = D.getContext() == DeclaratorContext::Prototype || D.getContext() == DeclaratorContext::ObjCParameter; @@ -9153,8 +9202,8 @@ static void HandleCountedByAttrOnType(TypeProcessingState &State, Sema::BoundsAttrFlags Flags; if (!S.ValidateBoundsAttrTypeForTypePosition( CurType, Attr.getKind(), Attr.getLoc(), Attr.getRange(), - getPointerNestLevel(D, chunkIndex), - isOnFunctionReturnType(D, chunkIndex), Flags, IsParameter)) { + PointerNestLevel, isOnFunctionReturnType(D, chunkIndex), Flags, + IsParameter)) { Attr.setInvalid(); return; } @@ -9460,10 +9509,7 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type, break; } - case ParsedAttr::AT_CountedBy: - case ParsedAttr::AT_CountedByOrNull: - case ParsedAttr::AT_SizedBy: - case ParsedAttr::AT_SizedByOrNull: { + COUNTED_BY_TYPE_ATTRS_CASELIST: { DeclaratorContext Ctx = state.getDeclarator().getContext(); bool OnParam = Ctx == DeclaratorContext::Prototype || Ctx == DeclaratorContext::ObjCParameter || @@ -10223,9 +10269,10 @@ QualType Sema::BuildTypeofExprType(Expr *E, TypeOfKind Kind) { static void BuildTypeCoupledDecls(Expr *E, llvm::SmallVectorImpl<TypeCoupledDeclRefInfo> &Decls) { - // Currently, 'counted_by' only allows direct DeclRefExpr to FieldDecl. - auto *CountDecl = cast<DeclRefExpr>(E)->getDecl(); - Decls.push_back(TypeCoupledDeclRefInfo(CountDecl, /*IsDref*/ false)); + bool IsDeref; + DeclRefExpr *DRE = Sema::getCountDeclRef(E, IsDeref); + assert(DRE && "count is not a reference"); + Decls.push_back(TypeCoupledDeclRefInfo(DRE->getDecl(), IsDeref)); } bool Sema::ActOnLateParsedTypeAttrArgument(BoundsAttributedType *BATy, @@ -10268,10 +10315,10 @@ QualType Sema::BuildCountAttributedArrayOrPointerType(QualType WrappedTy, bool OrNull) { // Accept any array or pointer type here. The caller has checked the // declaration and its count (see CheckCountedByAttrInRecord and - // CheckCountedByAttrOnParam), so the count is a DeclRefExpr, and an array is - // a flexible array member or a parameter. + // CheckCountedByAttrOnParam), so the count is a reference, or a dereferenced + // one for a parameter, and an array is a flexible array member or a + // parameter. assert(WrappedTy->isArrayType() || WrappedTy->isPointerType()); - assert(isa<DeclRefExpr>(CountExpr) && "count must be checked by the caller"); llvm::SmallVector<TypeCoupledDeclRefInfo, 1> Decls; BuildTypeCoupledDecls(CountExpr, Decls); diff --git a/clang/test/AST/attr-counted-by-function-params.c b/clang/test/AST/attr-counted-by-function-params.c index 67a6decbc94ff..7ab9967830071 100644 --- a/clang/test/AST/attr-counted-by-function-params.c +++ b/clang/test/AST/attr-counted-by-function-params.c @@ -59,11 +59,21 @@ void typeof_fam(__typeof__(((struct fam *)0)->arr) arr); // expected-error@+1{{'counted_by' attribute cannot be applied to a pointer that already has a 'counted_by' attribute}} void repeated_array(int n, int m, int arr[] __counted_by(n) __counted_by(m)); +// An out parameter's count, here a dereferenced parameter, is on the pointer +// that the parameter points to. +// CHECK: FunctionDecl {{.*}} out 'void (int *, int * __counted_by(*len)*)' +void out(int *len, int *__counted_by(*len) *buf); + // A rejected count is not applied, and the function stays valid. // CHECK: FunctionDecl {{.*}} not_a_param 'void (int *)' // expected-error@+1{{count expression in function declaration may only reference function parameters}} void not_a_param(int *__counted_by(global_count) buf); +// A nested count is dropped; the parameter's own count stays. +// CHECK: FunctionDecl {{.*}} both_counted 'void (int, int, int ** __counted_by(m))' +// expected-error@+1{{'counted_by' attribute on nested pointer type is not allowed}} +void both_counted(int n, int m, int *__counted_by(n) *__counted_by(m) buf); + // A count on a K&R parameter declaration is ignored. // CHECK: FunctionDecl {{.*}} knr 'void (int, int *)' // expected-warning@+2{{a function definition without a prototype is deprecated}} diff --git a/clang/test/Sema/attr-counted-by-function-params.c b/clang/test/Sema/attr-counted-by-function-params.c index ff1abe099da7f..76e5059581120 100644 --- a/clang/test/Sema/attr-counted-by-function-params.c +++ b/clang/test/Sema/attr-counted-by-function-params.c @@ -169,29 +169,55 @@ void array_attr_after(int count, void array_attr_after(int count, int *__counted_by(count) arr); //============================================================================== -// Not supported yet +// Indirect parameters //============================================================================== +// A parameter may point to a counted pointer, as an out parameter does, and a +// parameter's count may dereference a parameter. +void out(int *len, int *__counted_by(*len) *buf); +void out_or_null(int *len, int *__counted_by_or_null(*len) *buf); +void out_sized(int *len, void *__sized_by(*len) *buf); +void out_sized_or_null(int *len, void *__sized_by_or_null(*len) *buf); +void out_count(int count, int *__counted_by(count) *buf); +void out_array(int count, int *__counted_by(count) buf[]); +void own_deref(int *count, int *__counted_by(*count) buf); +void own_deref_or_null(int *count, int *__counted_by_or_null(*count) buf); +void own_deref_sized(int *count, void *__sized_by(*count) buf); +void own_deref_sized_or_null(int *count, void *__sized_by_or_null(*count) buf); + +// Only one level down, and not below a pointer that has a count itself. // expected-error@+1{{'counted_by' attribute on nested pointer type is not allowed}} -void out(int count, int *__counted_by(count) *buf); +void two_levels(int count, int *__counted_by(count) **buf); // expected-error@+1{{'counted_by_or_null' attribute on nested pointer type is not allowed}} -void out_or_null(int count, int *__counted_by_or_null(count) *buf); +void two_levels_or_null(int count, int *__counted_by_or_null(count) **buf); // expected-error@+1{{'sized_by' attribute on nested pointer type is not allowed}} -void out_sized(int count, void *__sized_by(count) *buf); +void two_levels_sized(int count, void *__sized_by(count) **buf); // expected-error@+1{{'sized_by_or_null' attribute on nested pointer type is not allowed}} -void out_sized_or_null(int count, void *__sized_by_or_null(count) *buf); - -// The nesting is diagnosed before what the count names. +void two_levels_sized_or_null(int count, void *__sized_by_or_null(count) **buf); // expected-error@+1{{'counted_by' attribute on nested pointer type is not allowed}} -void nested_inner(int *__counted_by(global_count) *buf); +void both_counted(int n, int m, int *__counted_by(n) *__counted_by(m) buf); // expected-error@+1{{'counted_by_or_null' attribute on nested pointer type is not allowed}} -void nested_inner_or_null(int *__counted_by_or_null(global_count) *buf); +void both_counted_or_null(int n, int m, int *__counted_by_or_null(n) *__counted_by_or_null(m) buf); // expected-error@+1{{'sized_by' attribute on nested pointer type is not allowed}} -void nested_inner_sized(void *__sized_by(global_count) *buf); +void both_counted_sized(int n, int m, void *__sized_by(n) *__sized_by(m) buf); // expected-error@+1{{'sized_by_or_null' attribute on nested pointer type is not allowed}} +void both_counted_sized_or_null(int n, int m, void *__sized_by_or_null(n) *__sized_by_or_null(m) buf); +// FIXME: With late parsing, a count after the declarator is parsed once the +// pointer that the parameter points to already has its count, so both stay. +// eager-error@+1{{'counted_by' attribute on nested pointer type is not allowed}} +void both_counted_trailing(int *len, int n, int *__counted_by(*len) *buf __counted_by(n)); + +// The count of the pointer that a parameter points to names a parameter too. +// expected-error@+1{{count expression in function declaration may only reference function parameters}} +void nested_inner(int *__counted_by(global_count) *buf); +// expected-error@+1{{count expression in function declaration may only reference function parameters}} +void nested_inner_or_null(int *__counted_by_or_null(global_count) *buf); +// expected-error@+1{{count expression in function declaration may only reference function parameters}} +void nested_inner_sized(void *__sized_by(global_count) *buf); +// expected-error@+1{{count expression in function declaration may only reference function parameters}} void nested_inner_sized_or_null(void *__sized_by_or_null(global_count) *buf); -// A count on the outer pointer still names a parameter. +// So does a count on the parameter's own pointer. // expected-error@+1{{count expression in function declaration may only reference function parameters}} void nested_outer_global(int **__counted_by(global_count) buf); // expected-error@+1{{count expression in function declaration may only reference function parameters}} @@ -201,14 +227,19 @@ void nested_outer_global_sized(int **__sized_by(global_count) buf); // expected-error@+1{{count expression in function declaration may only reference function parameters}} void nested_outer_global_sized_or_null(int **__sized_by_or_null(global_count) buf); -// expected-error@+1{{'counted_by' argument must be a simple declaration reference}} -void deref(int *count, int *__counted_by(*count) buf); -// expected-error@+1{{'counted_by_or_null' argument must be a simple declaration reference}} -void deref_or_null(int *count, int *__counted_by_or_null(*count) buf); -// expected-error@+1{{'sized_by' argument must be a simple declaration reference}} -void deref_sized(int *count, void *__sized_by(*count) buf); -// expected-error@+1{{'sized_by_or_null' argument must be a simple declaration reference}} -void deref_sized_or_null(int *count, void *__sized_by_or_null(*count) buf); +// A count that comes with another declaration's type, through '__typeof__', was +// checked where it was written, so it is not nested here. +void typeof_param(int count, int *__counted_by(count) buf, + __typeof__(buf) **out, __typeof__(buf) (**out_paren)); +struct with_count { int n; int *__counted_by(n) p; }; +void typeof_field(struct with_count *s) { + __typeof__(s->p) (**x); + (void)x; +} + +//============================================================================== +// Not supported yet +//============================================================================== // expected-warning@+2{{a function definition without a prototype is deprecated}} // expected-warning@+1{{'counted_by' attribute ignored}} >From 91df70b039038a5ff8734410b448c6c671506392 Mon Sep 17 00:00:00 2001 From: Holo-xy <[email protected]> Date: Fri, 20 Nov 2026 17:55:32 +0200 Subject: [PATCH 2/2] [BoundsSafety] Fix formatting --- clang/lib/Sema/SemaType.cpp | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 10eac661a2ff6..d1306b35884fb 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -182,13 +182,6 @@ static void diagnoseBadTypeAttribute(Sema &S, const ParsedAttr &attr, case ParsedAttr::AT_TypeNullableResult: \ case ParsedAttr::AT_TypeNullUnspecified -// Bounds attributes of the counted_by family. -#define COUNTED_BY_TYPE_ATTRS_CASELIST \ - case ParsedAttr::AT_CountedBy: \ - case ParsedAttr::AT_CountedByOrNull: \ - case ParsedAttr::AT_SizedBy: \ - case ParsedAttr::AT_SizedByOrNull - namespace { /// An object which stores processing state for the entire /// GetTypeForDeclarator process. @@ -4406,7 +4399,10 @@ static bool isIndirectParamCount(const Declarator &D, unsigned ChunkIndex) { auto IsCount = [](const ParsedAttr &A) { switch (A.getKind()) { - COUNTED_BY_TYPE_ATTRS_CASELIST: + case ParsedAttr::AT_CountedBy: + case ParsedAttr::AT_CountedByOrNull: + case ParsedAttr::AT_SizedBy: + case ParsedAttr::AT_SizedByOrNull: return true; default: return false; @@ -9509,7 +9505,10 @@ static void processTypeAttrs(TypeProcessingState &state, QualType &type, break; } - COUNTED_BY_TYPE_ATTRS_CASELIST: { + case ParsedAttr::AT_CountedBy: + case ParsedAttr::AT_CountedByOrNull: + case ParsedAttr::AT_SizedBy: + case ParsedAttr::AT_SizedByOrNull: { DeclaratorContext Ctx = state.getDeclarator().getContext(); bool OnParam = Ctx == DeclaratorContext::Prototype || Ctx == DeclaratorContext::ObjCParameter || _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
