[clang] 0665669 - [Sema] Mark alias/ifunc targets used and consider mangled names

[Fangrui Song via cfe-commits]

Author: Fangrui Song
Date: 2024-04-16T11:49:25-07:00
New Revision: 0665669876cd7f51f7572cff3bb97485d78f5de5

URL: 
https://github.com/llvm/llvm-project/commit/0665669876cd7f51f7572cff3bb97485d78f5de5
DIFF: 
https://github.com/llvm/llvm-project/commit/0665669876cd7f51f7572cff3bb97485d78f5de5.diff

LOG: [Sema] Mark alias/ifunc targets used and consider mangled names

https://reviews.llvm.org/D54188 marked "alias" targets as used in C to
fix -Wunused false positives. This patch extends the approach to handle
mangled names to support global scope names in C++ and the
`overloadable` attribute in C.

(Note: we should skip `UsingShadowDecl`, which would trigger an
assertion failure in `ItaniumMangleContextImpl::mangleCXXName`.
See regression test added by commit 1c2afbae9af22b58190c10e3517242d01d89d612.)

In addition, we mark ifunc targets as used to fix #63957 (temporarily
used by xz; ifunc was removed by
https://github.com/tukaani-project/xz/commit/689ae2427342a2ea1206eb5ca08301baf410e7e0)

While our approach has false negatives for namespace scope names, the
majority of alias/ifunc C++ uses (global scope with no overloads) are
handled.

Note: The following function with internal linkage but C language
linkage type is mangled in Clang but not in GCC. This inconsistency
makes alias/ifunc difficult to use in C++ with portability (#88593).
```
extern "C" {
static void f0() {}
// GCC: void g0() __attribute__((alias("_ZL2f0v")));
// Clang: void g0() __attribute__((alias("f0")));
}
```

Pull Request: https://github.com/llvm/llvm-project/pull/87130

Added: 


Modified: 
clang/lib/Sema/CMakeLists.txt
clang/lib/Sema/SemaDeclAttr.cpp
clang/test/AST/ast-dump-attr-json.cpp
clang/test/Sema/alias-unused-win.cpp
clang/test/Sema/alias-unused.cpp
utils/bazel/llvm-project-overlay/clang/BUILD.bazel

Removed: 




diff  --git a/clang/lib/Sema/CMakeLists.txt b/clang/lib/Sema/CMakeLists.txt
index ab3b813a9ccd97..a96439df664228 100644
--- a/clang/lib/Sema/CMakeLists.txt
+++ b/clang/lib/Sema/CMakeLists.txt
@@ -1,5 +1,6 @@
 set(LLVM_LINK_COMPONENTS
   Core
+  Demangle
   FrontendHLSL
   FrontendOpenMP
   MC

diff  --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp
index b7b1fbc625a150..c3bf18a3f79e23 100644
--- a/clang/lib/Sema/SemaDeclAttr.cpp
+++ b/clang/lib/Sema/SemaDeclAttr.cpp
@@ -45,6 +45,7 @@
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/STLForwardCompat.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/IR/Assumptions.h"
 #include "llvm/MC/MCSectionMachO.h"
 #include "llvm/Support/Error.h"
@@ -1983,6 +1984,38 @@ static void handleWeakRefAttr(Sema &S, Decl *D, const 
ParsedAttr &AL) {
   D->addAttr(::new (S.Context) WeakRefAttr(S.Context, AL));
 }
 
+// Mark alias/ifunc target as used. Due to name mangling, we look up the
+// demangled name ignoring parameters (not supported by microsoftDemangle
+// https://github.com/llvm/llvm-project/issues/88825). This should handle the
+// majority of use cases while leaving namespace scope names unmarked.
+static void markUsedForAliasOrIfunc(Sema &S, Decl *D, const ParsedAttr &AL,
+StringRef Str) {
+  std::unique_ptr Demangled;
+  if (S.getASTContext().getCXXABIKind() != TargetCXXABI::Microsoft)
+Demangled.reset(llvm::itaniumDemangle(Str, /*ParseParams=*/false));
+  std::unique_ptr MC(S.Context.createMangleContext());
+  SmallString<256> Name;
+
+  const DeclarationNameInfo Target(
+  &S.Context.Idents.get(Demangled ? Demangled.get() : Str), AL.getLoc());
+  LookupResult LR(S, Target, Sema::LookupOrdinaryName);
+  if (S.LookupName(LR, S.TUScope)) {
+for (NamedDecl *ND : LR) {
+  if (!isa(ND) && !isa(ND))
+continue;
+  if (MC->shouldMangleDeclName(ND)) {
+llvm::raw_svector_ostream Out(Name);
+Name.clear();
+MC->mangleName(GlobalDecl(ND), Out);
+  } else {
+Name = ND->getIdentifier()->getName();
+  }
+  if (Name == Str)
+ND->markUsed(S.Context);
+}
+  }
+}
+
 static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   StringRef Str;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, Str))
@@ -1995,6 +2028,7 @@ static void handleIFuncAttr(Sema &S, Decl *D, const 
ParsedAttr &AL) {
 return;
   }
 
+  markUsedForAliasOrIfunc(S, D, AL, Str);
   D->addAttr(::new (S.Context) IFuncAttr(S.Context, AL, Str));
 }
 
@@ -2029,17 +2063,7 @@ static void handleAliasAttr(Sema &S, Decl *D, const 
ParsedAttr &AL) {
 }
   }
 
-  // Mark target used to prevent unneeded-internal-declaration warnings.
-  if (!S.LangOpts.CPlusPlus) {
-// FIXME: demangle Str for C++, as the attribute refers to the mangled
-// linkage name, not the pre-mangled identifier.
-const DeclarationNameInfo target(&S.Context.Idents.get(Str), AL.getLoc());
-LookupResult LR(S, target, Sema::LookupOrdinaryName);
-

[clang] [Clang][Sema] placement new initializes typedef array with correct size (PR #88902)

[via cfe-commits]

@@ -1,5 +1,5 @@
-// RUN: %clang -S -fno-discard-value-names -emit-llvm -o - %s | FileCheck %s
-// Issue no: 41441
+// RUN: %clang --target=x86_64-pc-linux -S -fno-discard-value-names -emit-llvm 
-o - %s | FileCheck %s
+
 #include 

dyung wrote:

It does:

https://lab.llvm.org/buildbot/#/builders/280/builds/1989
```
/Users/buildbot/buildbot-root/aarch64-darwin/llvm-project/clang/test/SemaCXX/PR41441.cpp:3:10:
 fatal error: 'new' file not found
3 | #include 
  |  ^
1 error generated.
```

https://github.com/llvm/llvm-project/pull/88902
___
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

[clang] [Clang][Sema] Improve support for explicit specializations of constrained member functions & member function templates (PR #88963)

[Krystian Stasiowski via cfe-commits]

https://github.com/sdkrystian created 
https://github.com/llvm/llvm-project/pull/88963

Consider the following snippet from the discussion of 
[CWG2847](https://cplusplus.github.io/CWG/issues/2847.html) on the [core 
reflector](https://lists.isocpp.org/core/2024/04/15720.php) ([godbolt 
link](https://godbolt.org/z/dvvef9xzM)):
```cpp
template
concept C = sizeof(T) <= sizeof(long);

template
struct A 
{
template
void f(U) requires C; // #1, declares a function template 

void g() requires C; // #2, declares a function

template<>
void f(char);  // #3, an explicit specialization of a function template 
that declares a function
};

template<>
template
void A::f(U) requires C; // #4, an explicit specialization of a 
function template that declares a function template

template<>
template<>
void A::f(int); // #5, an explicit specialization of a function template 
that declares a function

template<>
void A::g(); // #6, an explicit specialization of a function that 
declares a function
```

A number of problems exist:
- Clang rejects `#4` because the trailing _requires-clause_ has `U` substituted 
with the wrong template parameter depth when 
`Sema::AreConstraintExpressionsEqual` is called to determine whether it matches 
the trailing _requires-clause_ of the implicitly instantiated function template.
- Clang rejects `#5` because the function template specialization instantiated 
from `A::f` has a trailing _requires-clause_, but `#5` does not (nor can 
it have one as it isn't a templated function).
- Clang rejects `#6` for the same reasons it rejects `#5`.

This patch resolves these issues by making the following changes:
- To fix `#4`, `Sema::AreConstraintExpressionsEqual` is passed 
`FunctionTemplateDecl`s when comparing the trailing _requires-clauses_ of `#4` 
and the function template instantiated from `#1`.
- To fix `#5` and `#6`, the trailing _requires-clauses_ are not compared for 
explicit specializations that declare functions.

In addition to these changes, `CheckMemberSpecialization` now considers 
constraint satisfaction/constraint partial ordering when determining which 
member function is specialized by an explicit specialization of a member 
function for an implicit instantiation of a class template.

>From ede52d5020c12b1a3010c6637bb2fad0157da79e Mon Sep 17 00:00:00 2001
From: Krystian Stasiowski 
Date: Tue, 16 Apr 2024 13:36:11 -0400
Subject: [PATCH] [Clang][Sema] Improve support for explicit specializations of
 constrained member functions & member function templates

---
 clang/lib/Sema/SemaConcept.cpp|  2 +-
 clang/lib/Sema/SemaOverload.cpp   | 11 ++-
 clang/lib/Sema/SemaTemplate.cpp   | 44 +--
 clang/lib/Sema/SemaTemplateInstantiate.cpp|  4 +
 .../CXX/temp/temp.spec/temp.expl.spec/p8.cpp  | 74 +++
 5 files changed, 124 insertions(+), 11 deletions(-)
 create mode 100644 clang/test/CXX/temp/temp.spec/temp.expl.spec/p8.cpp

diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index e00c972602829e..7bfec4e11f7aab 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -811,7 +811,7 @@ static const Expr 
*SubstituteConstraintExpressionWithoutSatisfaction(
   // this may happen while we're comparing two templates' constraint
   // equivalence.
   LocalInstantiationScope ScopeForParameters(S);
-  if (auto *FD = llvm::dyn_cast(DeclInfo.getDecl()))
+  if (auto *FD = DeclInfo.getDecl()->getAsFunction())
 for (auto *PVD : FD->parameters())
   ScopeForParameters.InstantiatedLocal(PVD, PVD);
 
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 227ef564ba3e08..594cfc58d2226a 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -1303,6 +1303,8 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, 
FunctionDecl *New,
   if (New->isMSVCRTEntryPoint())
 return false;
 
+  NamedDecl *OldDecl = Old;
+  NamedDecl *NewDecl = New;
   FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
   FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
 
@@ -1347,6 +1349,8 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, 
FunctionDecl *New,
   // references to non-instantiated entities during constraint substitution.
   // GH78101.
   if (NewTemplate) {
+OldDecl = OldTemplate;
+NewDecl = NewTemplate;
 // C++ [temp.over.link]p4:
 //   The signature of a function template consists of its function
 //   signature, its return type and its template parameter list. The names
@@ -1506,13 +1510,14 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, 
FunctionDecl *New,
 }
   }
 
-  if (!UseOverrideRules) {
+  if (!UseOverrideRules &&
+  New->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) {
 Expr *NewRC = New->getTrailingRequiresClause(),
  *OldRC = Old->getTrailingRequiresClause();
 if ((NewRC != nullptr) != (O

[clang] [Clang][Sema] Improve support for explicit specializations of constrained member functions & member function templates (PR #88963)

[via cfe-commits]

llvmbot wrote:




@llvm/pr-subscribers-clang

Author: Krystian Stasiowski (sdkrystian)


Changes

Consider the following snippet from the discussion of 
[CWG2847](https://cplusplus.github.io/CWG/issues/2847.html) on the [core 
reflector](https://lists.isocpp.org/core/2024/04/15720.php) ([godbolt 
link](https://godbolt.org/z/dvvef9xzM)):
```cpp
template
concept C = sizeof(T) <= sizeof(long);

template
struct A 
{
template
void f(U) requires C; // #1, declares a function template 

void g() requires C; // #2, declares a function

template<>
void f(char);  // #3, an explicit specialization of a function 
template that declares a function
};

template<>
template
void A::f(U) requires C; // #4, an explicit 
specialization of a function template that declares a function template

template<>
template<>
void A::f(int); // #5, an explicit specialization of a 
function template that declares a function

template<>
void A::g(); // #6, an explicit specialization of a 
function that declares a function
```

A number of problems exist:
- Clang rejects `#4` because the trailing _requires-clause_ has `U` 
substituted with the wrong template parameter depth when 
`Sema::AreConstraintExpressionsEqual` is called to determine whether it matches 
the trailing _requires-clause_ of the implicitly instantiated function template.
- Clang rejects `#5` because the function template specialization 
instantiated from `A::f` has a trailing _requires-clause_, but 
`#5` does not (nor can it have one as it isn't a templated function).
- Clang rejects `#6` for the same reasons it rejects `#5`.

This patch resolves these issues by making the following changes:
- To fix `#4`, `Sema::AreConstraintExpressionsEqual` is passed 
`FunctionTemplateDecl`s when comparing the trailing _requires-clauses_ of 
`#4` and the function template instantiated from `#1`.
- To fix `#5` and `#6`, the trailing _requires-clauses_ are not 
compared for explicit specializations that declare functions.

In addition to these changes, `CheckMemberSpecialization` now considers 
constraint satisfaction/constraint partial ordering when determining which 
member function is specialized by an explicit specialization of a member 
function for an implicit instantiation of a class template.

---
Full diff: https://github.com/llvm/llvm-project/pull/88963.diff


5 Files Affected:

- (modified) clang/lib/Sema/SemaConcept.cpp (+1-1) 
- (modified) clang/lib/Sema/SemaOverload.cpp (+8-3) 
- (modified) clang/lib/Sema/SemaTemplate.cpp (+37-7) 
- (modified) clang/lib/Sema/SemaTemplateInstantiate.cpp (+4) 
- (added) clang/test/CXX/temp/temp.spec/temp.expl.spec/p8.cpp (+74) 


``diff
diff --git a/clang/lib/Sema/SemaConcept.cpp b/clang/lib/Sema/SemaConcept.cpp
index e00c972602829e..7bfec4e11f7aab 100644
--- a/clang/lib/Sema/SemaConcept.cpp
+++ b/clang/lib/Sema/SemaConcept.cpp
@@ -811,7 +811,7 @@ static const Expr 
*SubstituteConstraintExpressionWithoutSatisfaction(
   // this may happen while we're comparing two templates' constraint
   // equivalence.
   LocalInstantiationScope ScopeForParameters(S);
-  if (auto *FD = llvm::dyn_cast(DeclInfo.getDecl()))
+  if (auto *FD = DeclInfo.getDecl()->getAsFunction())
 for (auto *PVD : FD->parameters())
   ScopeForParameters.InstantiatedLocal(PVD, PVD);
 
diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp
index 227ef564ba3e08..594cfc58d2226a 100644
--- a/clang/lib/Sema/SemaOverload.cpp
+++ b/clang/lib/Sema/SemaOverload.cpp
@@ -1303,6 +1303,8 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, 
FunctionDecl *New,
   if (New->isMSVCRTEntryPoint())
 return false;
 
+  NamedDecl *OldDecl = Old;
+  NamedDecl *NewDecl = New;
   FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
   FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
 
@@ -1347,6 +1349,8 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, 
FunctionDecl *New,
   // references to non-instantiated entities during constraint substitution.
   // GH78101.
   if (NewTemplate) {
+OldDecl = OldTemplate;
+NewDecl = NewTemplate;
 // C++ [temp.over.link]p4:
 //   The signature of a function template consists of its function
 //   signature, its return type and its template parameter list. The names
@@ -1506,13 +1510,14 @@ static bool IsOverloadOrOverrideImpl(Sema &SemaRef, 
FunctionDecl *New,
 }
   }
 
-  if (!UseOverrideRules) {
+  if (!UseOverrideRules &&
+  New->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) {
 Expr *NewRC = New->getTrailingRequiresClause(),
  *OldRC = Old->getTrailingRequiresClause();
 if ((NewRC != nullptr) != (OldRC != nullptr))
   return true;
-
-if (NewRC && !SemaRef.AreConstraintExpressionsEqual(Old, OldRC, New, 
NewRC))
+if (NewRC &&
+!SemaRef.AreConstraintExpressionsEqual(OldDecl, OldRC, NewDecl, NewRC