https://github.com/redcode updated https://github.com/llvm/llvm-project/pull/232986
From cf6bc51b6c05b752d249c32ceb6a066fa6daffad Mon Sep 17 00:00:00 2001 From: redcode <[email protected]> Date: Sat, 17 Oct 2026 01:50:04 +0200 Subject: [PATCH 1/2] [analyzer] Fix crash in PaddingChecker on dependent field types --- clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp | 6 ++++++ clang/test/Analysis/padding_dependent.cpp | 7 +++++++ 2 files changed, 13 insertions(+) create mode 100644 clang/test/Analysis/padding_dependent.cpp diff --git a/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp index c8d7b6555f3f42..8fbd1831f91756 100644 --- a/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp @@ -178,6 +178,12 @@ class PaddingChecker : public Checker<check::ASTDecl<TranslationUnitDecl>> { QualType Ty = FD->getType(); if (Ty->isIncompleteArrayType()) return true; + // Dependent field types have no known layout, so we can't compute the + // padding of the enclosing record. This can happen for lambda captures + // in a dependent context, e.g. an init-capture of a forwarding reference + // inside a noexcept specifier. + if (Ty->isDependentType()) + return true; return false; }; diff --git a/clang/test/Analysis/padding_dependent.cpp b/clang/test/Analysis/padding_dependent.cpp new file mode 100644 index 00000000000000..ea337d13379503 --- /dev/null +++ b/clang/test/Analysis/padding_dependent.cpp @@ -0,0 +1,7 @@ +// RUN: %clang_analyze_cc1 -std=c++20 -analyzer-checker=optin.performance -verify %s + +// The static analyzer must not crash when computing the layout of a lambda +// closure type with a dependent init-capture inside a noexcept specifier. +// https://github.com/llvm/llvm-project/issues/232874 +// expected-no-diagnostics +void crasher(auto&& fn) noexcept(noexcept([_ = fn] {})) {} From 2194ad1d912a54c42d6ff0ccee93e2f7de08daad Mon Sep 17 00:00:00 2001 From: redcode <[email protected]> Date: Sat, 17 Oct 2026 17:51:57 +0200 Subject: [PATCH 2/2] Add FIXME to `Sema::ActOnLambdaExpressionAfterIntroducer`and reword comment in `PaddingChecker::shouldSkipDecl` --- clang/lib/Sema/SemaLambda.cpp | 8 ++++++++ .../StaticAnalyzer/Checkers/PaddingChecker.cpp | 16 ++++++++++------ 2 files changed, 18 insertions(+), 6 deletions(-) diff --git a/clang/lib/Sema/SemaLambda.cpp b/clang/lib/Sema/SemaLambda.cpp index 0c9a92cdd0c320..3f77c57223a46a 100644 --- a/clang/lib/Sema/SemaLambda.cpp +++ b/clang/lib/Sema/SemaLambda.cpp @@ -1141,6 +1141,14 @@ void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, // Determine if we're within a context where we know that the lambda will // be dependent, because there are template parameters in scope. + // + // FIXME: A lambda in the noexcept specifier of an abbreviated function + // template (e.g. `auto&&`) is not marked dependent, even though it captures + // a dependent entity. Could this be because the implicit template parameter + // is not in scope while the specifier is parsed, leaving the lambda's + // dependency kind as LDK_Unknown? See: + // * https://github.com/llvm/llvm-project/issues/232874 + // * https://github.com/llvm/llvm-project/issues/233102 CXXRecordDecl::LambdaDependencyKind LambdaDependencyKind = CXXRecordDecl::LDK_Unknown; if (CurScope->getTemplateParamParent() != nullptr) { diff --git a/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp index 8fbd1831f91756..e39caf79465059 100644 --- a/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp @@ -169,7 +169,7 @@ class PaddingChecker : public Checker<check::ASTDecl<TranslationUnitDecl>> { else if (RD->field_empty()) return true; - auto IsTrickyField = [](const FieldDecl *FD) -> bool { + auto IsTrickyField = [RD](const FieldDecl *FD) -> bool { // Bitfield layout is hard. if (FD->isBitField()) return true; @@ -178,12 +178,16 @@ class PaddingChecker : public Checker<check::ASTDecl<TranslationUnitDecl>> { QualType Ty = FD->getType(); if (Ty->isIncompleteArrayType()) return true; - // Dependent field types have no known layout, so we can't compute the - // padding of the enclosing record. This can happen for lambda captures - // in a dependent context, e.g. an init-capture of a forwarding reference - // inside a noexcept specifier. - if (Ty->isDependentType()) + // Defensive backstop: a lambda closure type can be left non-dependent + // due to a bug in Sema (see SemaLambda.cpp), leaving a field of a bare + // dependent type whose layout cannot be computed. See: + // * https://github.com/llvm/llvm-project/issues/232874 + // * https://github.com/llvm/llvm-project/issues/233102 + if (Ty->isDependentType()) { + assert(RD->isDependentType() && + "record with a dependent field should itself be dependent"); return true; + } return false; }; _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
