From 2871f6905257169f8a49b13289421a668bf24051 Mon Sep 17 00:00:00 2001 From: Mariya Podchishchaeva Date: Fri, 28 Feb 2025 09:35:59 +0100 Subject: [PATCH] [clang] Fix issues with #embed and intializer lists/template arguments (#128890) Sometimes number of expressions in InitListExpr is used for template argument deduction. So, in these cases we need to pay attention to real number of expressions including expanded #embed data. Fixes https://github.com/llvm/llvm-project/issues/122306 --- clang/docs/ReleaseNotes.rst | 2 + clang/include/clang/AST/Expr.h | 10 ++++ clang/lib/Sema/SemaInit.cpp | 2 +- clang/lib/Sema/SemaOverload.cpp | 12 ++-- clang/lib/Sema/SemaTemplateDeduction.cpp | 3 +- clang/test/SemaCXX/embed-init-list.cpp | 71 ++++++++++++++++++++++++ 6 files changed, 93 insertions(+), 7 deletions(-) create mode 100644 clang/test/SemaCXX/embed-init-list.cpp diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 2b7214348294..7873c2048e53 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -225,6 +225,8 @@ Bug Fixes in This Version - Clang now outputs correct values when #embed data contains bytes with negative signed char values (#GH102798). +- Fixed rejects-valid problem when #embed appears in std::initializer_list or + when it can affect template argument deduction (#GH122306). Bug Fixes to Compiler Builtins ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index 0f98d237dcbc..cfe49acf20b7 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -5189,6 +5189,16 @@ public: unsigned getNumInits() const { return InitExprs.size(); } + /// getNumInits but if the list has an EmbedExpr inside includes full length + /// of embedded data. + unsigned getNumInitsWithEmbedExpanded() const { + unsigned Sum = InitExprs.size(); + for (auto *IE : InitExprs) + if (auto *EE = dyn_cast(IE)) + Sum += EE->getDataElementCount() - 1; + return Sum; + } + /// Retrieve the set of initializers. Expr **getInits() { return reinterpret_cast(InitExprs.data()); } diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index 925af06894f7..86f5a5c1d443 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -4261,7 +4261,7 @@ static bool TryInitializerListConstruction(Sema &S, QualType ArrayType = S.Context.getConstantArrayType( E.withConst(), llvm::APInt(S.Context.getTypeSize(S.Context.getSizeType()), - List->getNumInits()), + List->getNumInitsWithEmbedExpanded()), nullptr, clang::ArraySizeModifier::Normal, 0); InitializedEntity HiddenArray = InitializedEntity::InitializeTemporary(ArrayType); diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 08586b4908dd..c344b6fff40c 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -5710,12 +5710,14 @@ TryListConversion(Sema &S, InitListExpr *From, QualType ToType, // - if the initializer list has one element that is not itself an // initializer list, the implicit conversion sequence is the one // required to convert the element to the parameter type. + // Bail out on EmbedExpr as well since we never create EmbedExpr for a + // single integer. unsigned NumInits = From->getNumInits(); - if (NumInits == 1 && !isa(From->getInit(0))) - Result = TryCopyInitialization(S, From->getInit(0), ToType, - SuppressUserConversions, - InOverloadResolution, - AllowObjCWritebackConversion); + if (NumInits == 1 && !isa(From->getInit(0)) && + !isa(From->getInit(0))) + Result = TryCopyInitialization( + S, From->getInit(0), ToType, SuppressUserConversions, + InOverloadResolution, AllowObjCWritebackConversion); // - if the initializer list has no elements, the implicit conversion // sequence is the identity conversion. else if (NumInits == 0) { diff --git a/clang/lib/Sema/SemaTemplateDeduction.cpp b/clang/lib/Sema/SemaTemplateDeduction.cpp index 627cd82ed1c7..dbd73ead8a63 100644 --- a/clang/lib/Sema/SemaTemplateDeduction.cpp +++ b/clang/lib/Sema/SemaTemplateDeduction.cpp @@ -4506,7 +4506,8 @@ static TemplateDeductionResult DeduceFromInitializerList( // C++ [temp.deduct.type]p13: // The type of N in the type T[N] is std::size_t. QualType T = S.Context.getSizeType(); - llvm::APInt Size(S.Context.getIntWidth(T), ILE->getNumInits()); + llvm::APInt Size(S.Context.getIntWidth(T), + ILE->getNumInitsWithEmbedExpanded()); if (auto Result = DeduceNonTypeTemplateArgument( S, TemplateParams, NTTP, llvm::APSInt(Size), T, /*ArrayBound=*/true, Info, /*PartialOrdering=*/false, Deduced, diff --git a/clang/test/SemaCXX/embed-init-list.cpp b/clang/test/SemaCXX/embed-init-list.cpp new file mode 100644 index 000000000000..c511ca707a53 --- /dev/null +++ b/clang/test/SemaCXX/embed-init-list.cpp @@ -0,0 +1,71 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c23-extensions %s +// expected-no-diagnostics + +namespace std { +typedef decltype(sizeof(int)) size_t; + +template class initializer_list { + const _E *__begin_; + size_t __size_; + + constexpr initializer_list(const _E *__b, size_t __s) + : __begin_(__b), __size_(__s) {} + +public: + constexpr initializer_list() : __begin_(nullptr), __size_(0) {} +}; +} // namespace std + +template struct S { + S(std::initializer_list); +}; + +template <> struct S { + S(std::initializer_list); +}; + +struct S1 { + S data; + int a; +}; + +template void to_array(_Tp (&&__a)[_Nm]) {} + + +template +void tfn(T) {} + +void tests() { + + S{{ +#embed __FILE__ + }}; + + S1 ss{std::initializer_list{ +#embed __FILE__ + }}; + + S sss = { +#embed __FILE__ + }; + + std::initializer_list il{ +#embed __FILE__ + }; + + static constexpr auto initializer_list = std::initializer_list{ +#embed __FILE__ + , '\0'}; + + static constexpr auto intinitializer_list = std::initializer_list{ +#embed __FILE__ + , '\0'}; + + to_array({ +#embed __FILE__ + }); + + tfn>({ +#embed __FILE__ + }); +}