[clang] [Clang] Add -fhash-mangled-names to shorten Itanium C++ symbol names (PR #241482)
Vy Nguyen via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 11 12:13:39 PST 2026
https://github.com/oontvoo created https://github.com/llvm/llvm-project/pull/241482
Nested templates and long param lists can produce extremely long mangled names (eg., we've seen 760K character-long symbols in our codebase). These resulted in very large .strtab (and .dynstr)(eg., some reaching 35% of our total binaries size).
This patch provides an option to use custom mangling scheme via -fhash-mangled-names (-fno-hash-mangled-names by default) on ELF targets (May consider MachO, et al, later).
Format: Replaces template arguments, function parameters/return types, method qualifiers, and ABI tags with a .h.<uint64> suffix (64-bit BLAKE3 hash of the full mangled name) after a scope-only Itanium mangling whenever the hashed form is strictly shorter.
Demangler compat: Because .h.<digits> matches the standard .<alpha>+.<digit>+ clone-suffix grammar after a complete _Z encoding, existing Itanium demanglers should continue to work without issues.
Profile & special-case list support: Emits "sample-profile-suffix-elision-policy"="selected" so SamplePGO preserves .h.<digits> across distinct specializations while still stripping .llvm./.part. suffixes, and matches canonical unhashed mangled names in -fsanitize-ignorelist, -fxray-attr-list, and -fprofile-list.
>From a4541ba31fad8b3070b4d778dada38f9d2baa782 Mon Sep 17 00:00:00 2001
From: Vy Nguyen <vyng at google.com>
Date: Wed, 11 Nov 2026 15:02:04 -0500
Subject: [PATCH] [Clang] Add -fhash-mangled-names to shorten Itanium C++
symbol names
Nested templates and long param lists can produce extremely long mangled names (eg., we've seen 760K character-long symbols in our codebase).
These resulted in very large .strtab (and .dynstr)(eg., some reaching 35% of our total binaries size).
This patch provides an option to use custom mangling scheme via -fhash-mangled-names (-fno-hash-mangled-names by default) on ELF targets (May consider MachO, et al, later).
Format: Replaces template arguments, function parameters/return types, method qualifiers, and ABI tags with a .h.<uint64> suffix (64-bit BLAKE3 hash of the full mangled name) after a scope-only Itanium mangling whenever the hashed form is strictly shorter.
Demangler compat: Because .h.<digits> matches the standard .<alpha>+.<digit>+ clone-suffix grammar after a complete _Z encoding, existing Itanium demanglers should continue to work without issues.
Profile & special-case list support: Emits "sample-profile-suffix-elision-policy"="selected" so SamplePGO preserves .h.<digits> across distinct specializations while still stripping .llvm./.part. suffixes, and matches canonical unhashed mangled names in -fsanitize-ignorelist, -fxray-attr-list, and -fprofile-list.
---
clang/docs/ReleaseNotes.md | 8 +
clang/docs/UsersManual.md | 26 ++
clang/include/clang/AST/Mangle.h | 7 +
clang/include/clang/Basic/LangOptions.def | 3 +
clang/include/clang/Basic/NoSanitizeList.h | 9 +-
clang/include/clang/Options/Options.td | 9 +
clang/lib/AST/ItaniumMangle.cpp | 270 +++++++++++++-
clang/lib/Basic/NoSanitizeList.cpp | 20 +-
clang/lib/CodeGen/CGCall.cpp | 3 +
clang/lib/CodeGen/CodeGenModule.cpp | 47 ++-
clang/lib/CodeGen/CodeGenModule.h | 3 +
clang/lib/Driver/ToolChains/Clang.cpp | 2 +
clang/test/CodeGenCXX/mangle-hash-names.cpp | 388 ++++++++++++++++++++
clang/test/Driver/fhash-mangled-names.c | 6 +
14 files changed, 772 insertions(+), 29 deletions(-)
create mode 100644 clang/test/CodeGenCXX/mangle-hash-names.cpp
create mode 100644 clang/test/Driver/fhash-mangled-names.c
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index 7205fd4ab2968e..a0f10f7919e3ed 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -373,6 +373,14 @@ documentation](CIR/index.md) for more information regarding ClangIR's status and
### New Compiler Flags
+- Added `-fhash-mangled-names` (and `-fno-hash-mangled-names`, the default) on
+ ELF targets to shorten long Itanium C++ mangled symbol names by emitting a
+ scope-only Itanium mangling followed by a `.h.<uint64>` clone-style suffix
+ computed from the 64-bit BLAKE3 hash of the full mangled name whenever that
+ is strictly shorter. Because `.h.<digits>` conforms to the standard
+ supported grammar after a complete `_Z` encoding, existing demanglers
+ should be able to demangle those new hashed symbols without any issue.
+
- New option `-fmodules-validate-directory-dependencies` makes an implicitly
built module out of date when a header is added to a directory it enumerated,
such as an umbrella directory or the directory of an umbrella header, after it
diff --git a/clang/docs/UsersManual.md b/clang/docs/UsersManual.md
index 96d1c4e009c71a..9e0ee8be7f9b9b 100644
--- a/clang/docs/UsersManual.md
+++ b/clang/docs/UsersManual.md
@@ -2835,6 +2835,32 @@ $ cd $P && clang foo/name_conflict.o && bar/name_conflict.o
```
:::
+(fhash_mangled_names)=
+(fhash-mangled-names)=
+
+:::{option} -f[no-]hash-mangled-names
+
+Shorten long Itanium C++ mangled symbol names on ELF targets by replacing
+template arguments, function parameter/return types, method qualifiers, and ABI
+tags with a `.h.<uint64>` suffix derived from the 64-bit BLAKE3 hash of the full
+mangled name whenever the hashed form is strictly shorter than the original
+mangled name. Because `.h.<digits>` conforms to the standard grammar
+after a valid scope-only `_Z` encoding, existing C++ demanglers and symbolizers
+should be able to demangle these without any issue.
+
+Declarations in top-level standard/runtime namespaces (`std`, `__gnu_cxx`,
+`__gnu_debug`, `__cxxabiv1`), global allocation/deallocation operators,
+typeinfo name strings (`_ZTS`), CUDA/HIP/OpenCL device symbols and kernel entry
+points, and non-ELF targets keep standard unhashed Itanium manglings.
+Sanitizer ignorelists (`-fsanitize-ignorelist`), XRay attribute lists
+(`-fxray-attr-list`), and profile lists (`-fprofile-list`) match both the
+hashed symbol name and the canonical unhashed mangled name.
+
+Note that `-fhash-mangled-names` changes emitted C++ symbol names; translation
+units that share hashed C++ symbols across object or library boundaries must be
+compiled consistently with the same setting. Off by default.
+:::
+
:::{option} -f[no-]keep-inline-functions
Force inline functions to be emitted into the object file, even when they
diff --git a/clang/include/clang/AST/Mangle.h b/clang/include/clang/AST/Mangle.h
index 0e0bfef9053f98..48488d8d81573d 100644
--- a/clang/include/clang/AST/Mangle.h
+++ b/clang/include/clang/AST/Mangle.h
@@ -66,6 +66,7 @@ class MangleContext {
/// For aux target. If true, uses mangling number for aux target from
/// ASTContext.
bool IsAux = false;
+ bool SuppressHashMangledNames = false;
llvm::DenseMap<const BlockDecl *, unsigned> GlobalBlockIds;
llvm::DenseMap<const BlockDecl *, unsigned> LocalBlockIds;
@@ -77,6 +78,12 @@ class MangleContext {
bool isAux() const { return IsAux; }
+ bool isHashMangledNamesSuppressed() const { return SuppressHashMangledNames; }
+
+ void setSuppressHashMangledNames(bool Suppress) {
+ SuppressHashMangledNames = Suppress;
+ }
+
explicit MangleContext(ASTContext &Context, DiagnosticsEngine &Diags,
ManglerKind Kind, bool IsAux = false)
: Context(Context), Diags(Diags), Kind(Kind), IsAux(IsAux) {}
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
index b4a57a9c0944b1..b3e16bfdfea040 100644
--- a/clang/include/clang/Basic/LangOptions.def
+++ b/clang/include/clang/Basic/LangOptions.def
@@ -540,6 +540,9 @@ LANGOPT(Reflection , 1, 0, NotCompatible, "C++26 Reflection")
LANGOPT(StablePointerSubtraction, 1, 0, NotCompatible, "Make unaligned pointer subtraction stable")
+LANGOPT(HashMangledNames, 1, 0, Benign,
+ "hash template and function parameters in C++ mangled names")
+
#undef LANGOPT
#undef ENUM_LANGOPT
#undef VALUE_LANGOPT
diff --git a/clang/include/clang/Basic/NoSanitizeList.h b/clang/include/clang/Basic/NoSanitizeList.h
index a7a7a29d50a9a3..9e6a20bf0e72da 100644
--- a/clang/include/clang/Basic/NoSanitizeList.h
+++ b/clang/include/clang/Basic/NoSanitizeList.h
@@ -30,17 +30,20 @@ class NoSanitizeList {
std::unique_ptr<SanitizerSpecialCaseList> SSCL;
SourceManager &SM;
bool containsPrefix(SanitizerMask Mask, StringRef Prefix, StringRef Name,
- StringRef Category) const;
+ StringRef Category,
+ StringRef AltName = StringRef()) const;
public:
NoSanitizeList(const std::vector<std::string> &NoSanitizeListPaths,
SourceManager &SM);
~NoSanitizeList();
bool containsGlobal(SanitizerMask Mask, StringRef GlobalName,
- StringRef Category = StringRef()) const;
+ StringRef Category = StringRef(),
+ StringRef AltGlobalName = StringRef()) const;
bool containsType(SanitizerMask Mask, StringRef MangledTypeName,
StringRef Category = StringRef()) const;
- bool containsFunction(SanitizerMask Mask, StringRef FunctionName) const;
+ bool containsFunction(SanitizerMask Mask, StringRef FunctionName,
+ StringRef AltFunctionName = StringRef()) const;
bool containsFile(SanitizerMask Mask, StringRef FileName,
StringRef Category = StringRef()) const;
bool containsMainFile(SanitizerMask Mask, StringRef FileName,
diff --git a/clang/include/clang/Options/Options.td b/clang/include/clang/Options/Options.td
index db1648c2d55d87..f650556f5db178 100644
--- a/clang/include/clang/Options/Options.td
+++ b/clang/include/clang/Options/Options.td
@@ -5149,6 +5149,15 @@ defm unique_internal_linkage_names : BoolFOption<"unique-internal-linkage-names"
"Uniqueify Internal Linkage Symbol Names by appending"
" the MD5 hash of the module path">,
NegFlag<SetFalse, [], [ClangOption, CC1Option, FlangOption]>>;
+defm hash_mangled_names : BoolFOption<"hash-mangled-names",
+ LangOpts<"HashMangledNames">, DefaultFalse,
+ PosFlag<SetTrue, [], [ClangOption, CC1Option],
+ "Shorten C++ mangled names by hashing template and function parameters (ELF Only)">,
+ NegFlag<SetFalse>>,
+ DocBrief<[{When enabled on ELF targets, shorten long Itanium C++ mangled names by
+emitting a scope-only mangling followed by a ``.h.<uint64>`` suffix computed from the
+64-bit BLAKE3 hash of the full mangled name whenever that representation is strictly
+shorter. Off by default.}]>;
defm unique_section_names : BoolFOption<"unique-section-names",
CodeGenOpts<"UniqueSectionNames">, DefaultTrue,
NegFlag<SetFalse, [], [ClangOption, CC1Option],
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index 6ebbdbd5369245..cffc02b3b7e045 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -33,7 +33,10 @@
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/Thunk.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/BLAKE3.h"
+#include "llvm/Support/Endian.h"
#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/SaveAndRestore.h"
#include "llvm/Support/raw_ostream.h"
#include <optional>
@@ -210,6 +213,9 @@ class ItaniumMangleContextImpl : public ItaniumMangleContext {
bool isInternalLinkageDecl(const NamedDecl *ND);
+ bool InHashMangle = false;
+ bool ScopeOnly = false;
+
/// @}
};
@@ -228,6 +234,8 @@ class CXXNameMangler {
/// Also it is required to avoid infinite recursion in some cases.
bool DisableDerivedAbiTags = false;
+ bool isScopeOnly() const { return Context.ScopeOnly; }
+
/// The "structor" is the top-level declaration being mangled, if
/// that's not a template specialization; otherwise it's the pattern
/// for that specialization.
@@ -810,6 +818,8 @@ bool ItaniumMangleContextImpl::shouldMangleCXXName(const NamedDecl *D) {
void CXXNameMangler::writeAbiTags(const NamedDecl *ND,
ArrayRef<StringRef> AdditionalAbiTags) {
+ if (isScopeOnly())
+ return;
assert(AbiTags && "require AbiTagState");
AbiTags->write(Out, ND,
DisableDerivedAbiTags ? ArrayRef<StringRef>{}
@@ -849,6 +859,12 @@ void CXXNameMangler::mangleFunctionEncoding(GlobalDecl GD) {
return;
}
+ if (isScopeOnly()) {
+ mangleName(GD);
+ Out << 'v';
+ return;
+ }
+
AbiTagList ReturnTypeAbiTags = makeFunctionReturnTypeTags(FD);
if (ReturnTypeAbiTags.empty()) {
// There are no tags for return type, the simplest case. Enter the function
@@ -1019,6 +1035,10 @@ static TemplateName asTemplateName(GlobalDecl GD) {
}
void CXXNameMangler::mangleName(GlobalDecl GD) {
+ if (isScopeOnly()) {
+ mangleNameWithAbiTags(GD);
+ return;
+ }
const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
// Variables should have implicit tags from its type.
@@ -1197,7 +1217,7 @@ void CXXNameMangler::mangleUnscopedTemplateName(
const TemplateDecl *ND = cast<TemplateDecl>(GD.getDecl());
// <unscoped-template-name> ::= <unscoped-name>
// ::= <substitution>
- if (mangleSubstitution(ND))
+ if (!isScopeOnly() && mangleSubstitution(ND))
return;
// <template-template-param> ::= <template-param>
@@ -1212,7 +1232,8 @@ void CXXNameMangler::mangleUnscopedTemplateName(
AdditionalAbiTags);
}
- addSubstitution(ND);
+ if (!isScopeOnly())
+ addSubstitution(ND);
}
void CXXNameMangler::mangleFloat(const llvm::APFloat &f) {
@@ -1591,8 +1612,11 @@ void CXXNameMangler::mangleUnqualifiedName(
if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
// Proposed in https://github.com/itanium-cxx-abi/cxx-abi/issues/63.
Out << "TA";
- mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
- TPO->getValue(), /*TopLevel=*/true);
+ if (isScopeOnly())
+ mangleType(TPO->getType().getUnqualifiedType());
+ else
+ mangleValueInTemplateArg(TPO->getType().getUnqualifiedType(),
+ TPO->getValue(), /*TopLevel=*/true);
break;
}
@@ -1873,7 +1897,8 @@ void CXXNameMangler::mangleNestedName(GlobalDecl GD, const DeclContext *DC,
// <template-args> E
Out << 'N';
- if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(ND)) {
+ if (const CXXMethodDecl *Method =
+ !isScopeOnly() ? dyn_cast<CXXMethodDecl>(ND) : nullptr) {
Qualifiers MethodQuals = Method->getMethodQualifiers();
// We do not consider restrict a distinguishing attribute for overloading
// purposes so we must not mangle it.
@@ -1886,7 +1911,9 @@ void CXXNameMangler::mangleNestedName(GlobalDecl GD, const DeclContext *DC,
// Check if we have a template.
const TemplateArgumentList *TemplateArgs = nullptr;
- if (GlobalDecl TD = isTemplate(GD, TemplateArgs)) {
+ if (GlobalDecl TD = (isScopeOnly() && isa<CXXConversionDecl>(ND))
+ ? GlobalDecl()
+ : isTemplate(GD, TemplateArgs)) {
mangleTemplatePrefix(TD, NoFunction);
mangleTemplateArgs(asTemplateName(TD), *TemplateArgs);
} else {
@@ -2245,6 +2272,10 @@ void CXXNameMangler::mangleLambda(const CXXRecordDecl *Lambda) {
}
void CXXNameMangler::mangleLambdaSig(const CXXRecordDecl *Lambda) {
+ if (isScopeOnly()) {
+ Out << 'v';
+ return;
+ }
// Proposed on https://github.com/itanium-cxx-abi/cxx-abi/issues/31.
for (auto *D : Lambda->getLambdaExplicitTemplateParameters())
mangleTemplateParamDecl(D);
@@ -2362,12 +2393,12 @@ void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) {
// Clang 11 and before mangled the substitution for a dependent template name
// after already having emitted (a substitution for) the prefix.
bool Clang11Compat = isCompatibleWith(LangOptions::ClangABI::Ver11);
- if (!Clang11Compat && mangleSubstitution(Template))
+ if (!isScopeOnly() && !Clang11Compat && mangleSubstitution(Template))
return;
manglePrefix(Dependent->getQualifier());
- if (Clang11Compat && mangleSubstitution(Template))
+ if (!isScopeOnly() && Clang11Compat && mangleSubstitution(Template))
return;
if (IdentifierOrOverloadedOperator Name = Dependent->getName();
@@ -2376,7 +2407,8 @@ void CXXNameMangler::mangleTemplatePrefix(TemplateName Template) {
else
mangleOperatorName(Name.getOperator(), UnknownArity);
- addSubstitution(Template);
+ if (!isScopeOnly())
+ addSubstitution(Template);
}
void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD,
@@ -2388,7 +2420,7 @@ void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD,
// <template-template-param> ::= <template-param>
// <substitution>
- if (mangleSubstitution(ND))
+ if (!isScopeOnly() && mangleSubstitution(ND))
return;
// <template-template-param> ::= <template-param>
@@ -2403,7 +2435,8 @@ void CXXNameMangler::mangleTemplatePrefix(GlobalDecl GD,
mangleUnqualifiedName(GD.getWithDecl(ND->getTemplatedDecl()), DC);
}
- addSubstitution(ND);
+ if (!isScopeOnly())
+ addSubstitution(ND);
}
const NamedDecl *CXXNameMangler::getClosurePrefix(const Decl *ND) {
@@ -2735,7 +2768,10 @@ void CXXNameMangler::mangleOperatorName(DeclarationName Name, unsigned Arity) {
case DeclarationName::CXXConversionFunctionName:
// <operator-name> ::= cv <type> # (cast)
Out << "cv";
- mangleType(Name.getCXXNameType());
+ if (isScopeOnly() && Name.getCXXNameType()->isDependentType())
+ Out << 'v';
+ else
+ mangleType(Name.getCXXNameType());
break;
case DeclarationName::CXXLiteralOperatorName:
@@ -4546,7 +4582,7 @@ void CXXNameMangler::mangleType(const ObjCObjectType *T) {
mangleType(T->getBaseType());
- if (T->isSpecialized()) {
+ if (!isScopeOnly() && T->isSpecialized()) {
// Mangle type arguments as I <type>+ E
Out << 'I';
for (auto typeArg : T->getTypeArgs())
@@ -6417,6 +6453,8 @@ struct CXXNameMangler::TemplateArgManglingInfo {
void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
const TemplateArgumentLoc *TemplateArgs,
unsigned NumTemplateArgs) {
+ if (isScopeOnly())
+ return;
// <template-args> ::= I <template-arg>+ [Q <requires-clause expr>] E
Out << 'I';
TemplateArgManglingInfo Info(*this, TN);
@@ -6429,6 +6467,8 @@ void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
const TemplateArgumentList &AL) {
+ if (isScopeOnly())
+ return;
// <template-args> ::= I <template-arg>+ [Q <requires-clause expr>] E
Out << 'I';
TemplateArgManglingInfo Info(*this, TN);
@@ -6441,6 +6481,8 @@ void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
void CXXNameMangler::mangleTemplateArgs(TemplateName TN,
ArrayRef<TemplateArgument> Args) {
+ if (isScopeOnly())
+ return;
// <template-args> ::= I <template-arg>+ [Q <requires-clause expr>] E
Out << 'I';
TemplateArgManglingInfo Info(*this, TN);
@@ -7295,6 +7337,9 @@ bool CXXNameMangler::mangleStandardSubstitution(const NamedDecl *ND) {
return false;
}
+ if (isScopeOnly())
+ return false;
+
if (const ClassTemplateDecl *TD = dyn_cast<ClassTemplateDecl>(ND)) {
if (!isStdNamespace(Context.getEffectiveDeclContext(TD)))
return false;
@@ -7435,6 +7480,156 @@ bool CXXNameMangler::shouldHaveAbiTags(ItaniumMangleContextImpl &C,
return TrackAbiTags.AbiTagsRoot.getUsedAbiTags().size();
}
+/// Declarations inside top-level C++ standard/runtime namespaces (`std`,
+/// `__gnu_cxx`, `__gnu_debug`, `__cxxabiv1`, including inline namespaces such
+/// as `std::__1` and `std::__cxx11`) are kept unhashed to preserve ABI
+/// compatibility with prebuilt C++ standard and runtime libraries. Functions
+/// and types outside `std` that take `std::*` parameters are hashed normally.
+static bool isInStdOrRuntimeNamespace(ItaniumMangleContextImpl &Ctx,
+ const NamedDecl *D) {
+ if (!D)
+ return false;
+ for (const DeclContext *DC = Ctx.getEffectiveDeclContext(D);
+ DC && !DC->isTranslationUnit(); DC = Ctx.getEffectiveParentContext(DC)) {
+ if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) {
+ if (Ctx.getEffectiveParentContext(NS)->isTranslationUnit()) {
+ if (const IdentifierInfo *II = NS->getFirstDecl()->getIdentifier()) {
+ if (II->isStr("std") || II->isStr("__gnu_cxx") ||
+ II->isStr("__gnu_debug") || II->isStr("__cxxabiv1"))
+ return true;
+ }
+ }
+ }
+ }
+ return false;
+}
+
+static const NamedDecl *getRTTIDecl(QualType Ty) {
+ while (!Ty.isNull()) {
+ if (const auto *Tag = Ty->getAsTagDecl())
+ return Tag;
+ QualType Pointee = Ty->getPointeeType();
+ if (!Pointee.isNull()) {
+ Ty = Pointee;
+ continue;
+ }
+ if (const auto *AT = Ty->getAsArrayTypeUnsafe()) {
+ Ty = AT->getElementType();
+ continue;
+ }
+ break;
+ }
+ return nullptr;
+}
+
+/// CUDA/HIP `__global__` and OpenCL/device `__attribute__((device_kernel))`
+/// entry points (and device variables / nested local entities) must keep
+/// standard Itanium manglings so host launch stubs match device toolchains
+/// such as `nvcc` that do not pass `-fhash-mangled-names`.
+static bool isDeviceKernelOrVarDecl(const NamedDecl *D) {
+ if (!D)
+ return false;
+ if (D->hasAttr<CUDAGlobalAttr>() || D->hasAttr<DeviceKernelAttr>())
+ return true;
+ if (isa<VarDecl>(D) &&
+ (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>()))
+ return true;
+ for (const DeclContext *DC = D->getDeclContext();
+ DC && !DC->isTranslationUnit(); DC = DC->getParent()) {
+ if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
+ if (FD->hasAttr<CUDAGlobalAttr>() || FD->hasAttr<DeviceKernelAttr>())
+ return true;
+ }
+ }
+ return false;
+}
+
+/// Global ::operator new / ::operator new[] / ::operator delete /
+/// ::operator delete[] overloads (including C++17 aligned/nothrow and custom
+/// global placement/tagged forms) are ABI/runtime entry points matched by
+/// literal symbol name in LLVM TargetLibraryInfo, MemProf/AllocToken passes,
+/// sanitizer interceptors, and C++ allocator libraries. Keep their standard
+/// Itanium manglings unhashed.
+static bool isGlobalAllocationFunction(ItaniumMangleContextImpl &Ctx,
+ const NamedDecl *D) {
+ const auto *FD = dyn_cast<FunctionDecl>(D);
+ if (!FD)
+ return false;
+ switch (FD->getOverloadedOperator()) {
+ case OO_New:
+ case OO_Array_New:
+ case OO_Delete:
+ case OO_Array_Delete:
+ return Ctx.getEffectiveDeclContext(FD)->isTranslationUnit();
+ default:
+ return false;
+ }
+}
+
+static bool shouldTryHashMangle(ItaniumMangleContextImpl &Ctx,
+ const NamedDecl *D, bool AllowHash = true) {
+ // Non-ELF object formats (e.g. NVPTX PTX where '.' is a syntax error in
+ // ptxas, Mach-O, COFF, WASM, SPIR-V) and CUDA/HIP device or auxiliary device
+ // manglings must keep standard dot-free Itanium manglings.
+ return AllowHash && !Ctx.InHashMangle &&
+ !Ctx.isHashMangledNamesSuppressed() &&
+ Ctx.getASTContext().getLangOpts().HashMangledNames && !Ctx.isAux() &&
+ !Ctx.getASTContext().getLangOpts().CUDAIsDevice &&
+ Ctx.getASTContext().getTargetInfo().getTriple().isOSBinFormatELF() &&
+ !isDeviceKernelOrVarDecl(D) && !isInStdOrRuntimeNamespace(Ctx, D);
+}
+
+template <typename Fn>
+static void mangleWithOptionalHash(ItaniumMangleContextImpl &Ctx,
+ raw_ostream &Out, Fn &&MangleFn) {
+ llvm::SaveAndRestore<bool> InHashGuard(Ctx.InHashMangle, true);
+ const unsigned NumErrorsBefore = Ctx.getDiags().getNumErrors();
+ SmallString<256> FullName;
+ {
+ llvm::raw_svector_ostream FullOS(FullName);
+ MangleFn(FullOS);
+ }
+
+ // Only hash Itanium '_Z' manglings when mangling itself emitted no new
+ // diagnostic errors and the full mangled name is long enough that
+ // '<short>.h.<uint64>' can be strictly shorter. Minimum suffix '.h.<digit>'
+ // is 4 chars and minimum '_Z' short name is 3 chars, so FullName must be at
+ // least 8 chars to possibly shrink. Emitting a standard '.<alpha>+.<digit>+'
+ // clone suffix after a complete Itanium mangled prefix allows existing
+ // Itanium demanglers (such as llvm::itaniumDemangle, libc++abi, libiberty,
+ // and LLDB) to demangle hashed symbols without modification.
+ constexpr size_t MinHashSuffixOverhead = 4;
+ if (!FullName.starts_with("_Z") ||
+ FullName.size() <= 3 + MinHashSuffixOverhead ||
+ Ctx.getDiags().getNumErrors() != NumErrorsBefore) {
+ Out << FullName;
+ return;
+ }
+
+ SmallString<128> ShortName;
+ {
+ llvm::SaveAndRestore<bool> ScopeGuard(Ctx.ScopeOnly, true);
+ llvm::raw_svector_ostream ShortOS(ShortName);
+ MangleFn(ShortOS);
+ }
+
+ if (Ctx.getDiags().getNumErrors() == NumErrorsBefore &&
+ ShortName.size() + MinHashSuffixOverhead < FullName.size()) {
+ auto Hash = llvm::BLAKE3::hash<8>(llvm::arrayRefFromStringRef(FullName));
+ uint64_t HashVal = llvm::support::endian::read64le(Hash.data());
+ SmallString<24> HashSuffix;
+ {
+ llvm::raw_svector_ostream SuffixOS(HashSuffix);
+ SuffixOS << ".h." << HashVal;
+ }
+ if (ShortName.size() + HashSuffix.size() < FullName.size()) {
+ Out << ShortName << HashSuffix;
+ return;
+ }
+ }
+ Out << FullName;
+}
+
/// Mangles the name of the declaration \p GD and emits that name to the given
/// output stream \p Out.
void ItaniumMangleContextImpl::mangleCXXName(GlobalDecl GD,
@@ -7442,6 +7637,9 @@ void ItaniumMangleContextImpl::mangleCXXName(GlobalDecl GD,
const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
assert((isa<FunctionDecl, VarDecl, TemplateParamObjectDecl>(D)) &&
"Invalid mangleName() call, argument is not a variable or function!");
+ if (shouldTryHashMangle(*this, D, !isGlobalAllocationFunction(*this, D)))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleCXXName(GD, OS); });
PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
getASTContext().getSourceManager(),
@@ -7465,12 +7663,18 @@ void ItaniumMangleContextImpl::mangleCXXName(GlobalDecl GD,
void ItaniumMangleContextImpl::mangleCXXCtorComdat(const CXXConstructorDecl *D,
raw_ostream &Out) {
+ if (shouldTryHashMangle(*this, D))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleCXXCtorComdat(D, OS); });
CXXNameMangler Mangler(*this, Out, D, Ctor_Comdat);
Mangler.mangle(GlobalDecl(D, Ctor_Comdat));
}
void ItaniumMangleContextImpl::mangleCXXDtorComdat(const CXXDestructorDecl *D,
raw_ostream &Out) {
+ if (shouldTryHashMangle(*this, D))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleCXXDtorComdat(D, OS); });
CXXNameMangler Mangler(*this, Out, D, Dtor_Comdat);
Mangler.mangle(GlobalDecl(D, Dtor_Comdat));
}
@@ -7558,6 +7762,10 @@ void ItaniumMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
assert(!isa<CXXDestructorDecl>(MD) &&
"Use mangleCXXDtor for destructor decls!");
+ if (shouldTryHashMangle(*this, MD))
+ return mangleWithOptionalHash(*this, Out, [&](raw_ostream &OS) {
+ mangleThunk(MD, Thunk, ElideOverrideInfo, OS);
+ });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZT";
if (!Thunk.Return.isEmpty())
@@ -7573,7 +7781,7 @@ void ItaniumMangleContextImpl::mangleThunk(const CXXMethodDecl *MD,
Thunk.Return.Virtual.Itanium.VBaseOffsetOffset);
Mangler.mangleFunctionEncoding(MD);
- if (!ElideOverrideInfo)
+ if (!ScopeOnly && !ElideOverrideInfo)
mangleOverrideDiscrimination(Mangler, getASTContext(), Thunk);
}
@@ -7584,6 +7792,10 @@ void ItaniumMangleContextImpl::mangleCXXDtorThunk(const CXXDestructorDecl *DD,
raw_ostream &Out) {
// <special-name> ::= T <call-offset> <base encoding>
// # base is the nominal target function of thunk
+ if (shouldTryHashMangle(*this, DD))
+ return mangleWithOptionalHash(*this, Out, [&](raw_ostream &OS) {
+ mangleCXXDtorThunk(DD, Type, Thunk, ElideOverrideInfo, OS);
+ });
CXXNameMangler Mangler(*this, Out, DD, Type);
Mangler.getStream() << "_ZT";
@@ -7593,7 +7805,7 @@ void ItaniumMangleContextImpl::mangleCXXDtorThunk(const CXXDestructorDecl *DD,
ThisAdjustment.Virtual.Itanium.VCallOffsetOffset);
Mangler.mangleFunctionEncoding(GlobalDecl(DD, Type));
- if (!ElideOverrideInfo)
+ if (!ScopeOnly && !ElideOverrideInfo)
mangleOverrideDiscrimination(Mangler, getASTContext(), Thunk);
}
@@ -7602,6 +7814,9 @@ void ItaniumMangleContextImpl::mangleStaticGuardVariable(const VarDecl *D,
raw_ostream &Out) {
// <special-name> ::= GV <object name> # Guard variable for one-time
// # initialization
+ if (shouldTryHashMangle(*this, D))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleStaticGuardVariable(D, OS); });
CXXNameMangler Mangler(*this, Out);
// GCC 5.3.0 doesn't emit derived ABI tags for local names but that seems to
// be a bug that is fixed in trunk.
@@ -7665,6 +7880,10 @@ void ItaniumMangleContextImpl::mangleSEHFinallyBlock(
void ItaniumMangleContextImpl::mangleItaniumThreadLocalInit(const VarDecl *D,
raw_ostream &Out) {
// <special-name> ::= TH <object name>
+ if (shouldTryHashMangle(*this, D))
+ return mangleWithOptionalHash(*this, Out, [&](raw_ostream &OS) {
+ mangleItaniumThreadLocalInit(D, OS);
+ });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTH";
Mangler.mangleName(D);
@@ -7674,6 +7893,10 @@ void
ItaniumMangleContextImpl::mangleItaniumThreadLocalWrapper(const VarDecl *D,
raw_ostream &Out) {
// <special-name> ::= TW <object name>
+ if (shouldTryHashMangle(*this, D))
+ return mangleWithOptionalHash(*this, Out, [&](raw_ostream &OS) {
+ mangleItaniumThreadLocalWrapper(D, OS);
+ });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTW";
Mangler.mangleName(D);
@@ -7684,6 +7907,10 @@ void ItaniumMangleContextImpl::mangleReferenceTemporary(const VarDecl *D,
raw_ostream &Out) {
// We match the GCC mangling here.
// <special-name> ::= GR <object name>
+ if (shouldTryHashMangle(*this, D))
+ return mangleWithOptionalHash(*this, Out, [&](raw_ostream &OS) {
+ mangleReferenceTemporary(D, ManglingNumber, OS);
+ });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZGR";
Mangler.mangleName(D);
@@ -7694,6 +7921,9 @@ void ItaniumMangleContextImpl::mangleReferenceTemporary(const VarDecl *D,
void ItaniumMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *RD,
raw_ostream &Out) {
// <special-name> ::= TV <type> # virtual table
+ if (shouldTryHashMangle(*this, RD))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleCXXVTable(RD, OS); });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTV";
Mangler.mangleCXXRecordDecl(RD);
@@ -7702,6 +7932,9 @@ void ItaniumMangleContextImpl::mangleCXXVTable(const CXXRecordDecl *RD,
void ItaniumMangleContextImpl::mangleCXXVTT(const CXXRecordDecl *RD,
raw_ostream &Out) {
// <special-name> ::= TT <type> # VTT structure
+ if (shouldTryHashMangle(*this, RD))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleCXXVTT(RD, OS); });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTT";
Mangler.mangleCXXRecordDecl(RD);
@@ -7712,6 +7945,10 @@ void ItaniumMangleContextImpl::mangleCXXCtorVTable(const CXXRecordDecl *RD,
const CXXRecordDecl *Type,
raw_ostream &Out) {
// <special-name> ::= TC <type> <offset number> _ <base type>
+ if (shouldTryHashMangle(*this, RD))
+ return mangleWithOptionalHash(*this, Out, [&](raw_ostream &OS) {
+ mangleCXXCtorVTable(RD, Offset, Type, OS);
+ });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTC";
// Older versions of clang did not add the record as a substitution candidate
@@ -7727,6 +7964,9 @@ void ItaniumMangleContextImpl::mangleCXXCtorVTable(const CXXRecordDecl *RD,
void ItaniumMangleContextImpl::mangleCXXRTTI(QualType Ty, raw_ostream &Out) {
// <special-name> ::= TI <type> # typeinfo structure
assert(!Ty.hasQualifiers() && "RTTI info cannot have top-level qualifiers");
+ if (shouldTryHashMangle(*this, getRTTIDecl(Ty)))
+ return mangleWithOptionalHash(
+ *this, Out, [&](raw_ostream &OS) { mangleCXXRTTI(Ty, OS); });
CXXNameMangler Mangler(*this, Out);
Mangler.getStream() << "_ZTI";
Mangler.mangleType(Ty);
diff --git a/clang/lib/Basic/NoSanitizeList.cpp b/clang/lib/Basic/NoSanitizeList.cpp
index 96f79fb2a2a295..4c3eec61550779 100644
--- a/clang/lib/Basic/NoSanitizeList.cpp
+++ b/clang/lib/Basic/NoSanitizeList.cpp
@@ -16,6 +16,7 @@
#include "clang/Basic/SanitizerSpecialCaseList.h"
#include "clang/Basic/Sanitizers.h"
#include "clang/Basic/SourceManager.h"
+#include <algorithm>
using namespace clang;
@@ -28,13 +29,20 @@ NoSanitizeList::NoSanitizeList(const std::vector<std::string> &NoSanitizePaths,
NoSanitizeList::~NoSanitizeList() = default;
bool NoSanitizeList::containsPrefix(SanitizerMask Mask, StringRef Prefix,
- StringRef Name, StringRef Category) const {
+ StringRef Name, StringRef Category,
+ StringRef AltName) const {
std::pair<unsigned, unsigned> NoSan =
SSCL->inSectionBlame(Mask, Prefix, Name, Category);
+ if (!AltName.empty())
+ NoSan =
+ std::max(NoSan, SSCL->inSectionBlame(Mask, Prefix, AltName, Category));
if (NoSan == llvm::SpecialCaseList::NotFound)
return false;
std::pair<unsigned, unsigned> San =
SSCL->inSectionBlame(Mask, Prefix, Name, "sanitize");
+ if (!AltName.empty())
+ San =
+ std::max(San, SSCL->inSectionBlame(Mask, Prefix, AltName, "sanitize"));
// The statement evaluates to true under the following conditions:
// 1. The string "prefix:*=sanitize" is absent.
// 2. If "prefix:*=sanitize" is present, its (File Index, Line Number) is less
@@ -43,8 +51,9 @@ bool NoSanitizeList::containsPrefix(SanitizerMask Mask, StringRef Prefix,
}
bool NoSanitizeList::containsGlobal(SanitizerMask Mask, StringRef GlobalName,
- StringRef Category) const {
- return containsPrefix(Mask, "global", GlobalName, Category);
+ StringRef Category,
+ StringRef AltGlobalName) const {
+ return containsPrefix(Mask, "global", GlobalName, Category, AltGlobalName);
}
bool NoSanitizeList::containsType(SanitizerMask Mask, StringRef MangledTypeName,
@@ -53,8 +62,9 @@ bool NoSanitizeList::containsType(SanitizerMask Mask, StringRef MangledTypeName,
}
bool NoSanitizeList::containsFunction(SanitizerMask Mask,
- StringRef FunctionName) const {
- return containsPrefix(Mask, "fun", FunctionName, {});
+ StringRef FunctionName,
+ StringRef AltFunctionName) const {
+ return containsPrefix(Mask, "fun", FunctionName, {}, AltFunctionName);
}
bool NoSanitizeList::containsFile(SanitizerMask Mask, StringRef FileName,
diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp
index 5a05f8686b70b5..ba6f7ac45014ed 100644
--- a/clang/lib/CodeGen/CGCall.cpp
+++ b/clang/lib/CodeGen/CGCall.cpp
@@ -2506,6 +2506,9 @@ static void getTrivialDefaultFunctionAttributes(
if (!AttrOnCallSite) {
TargetInfo::BranchProtectionInfo BPI(LangOpts);
TargetCodeGenInfo::initBranchProtectionFnAttributes(BPI, FuncAttrs);
+ if (LangOpts.HashMangledNames)
+ FuncAttrs.addAttribute("sample-profile-suffix-elision-policy",
+ "selected");
}
}
diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp
index bdfbdeb1059384..2ad2d009d82757 100644
--- a/clang/lib/CodeGen/CodeGenModule.cpp
+++ b/clang/lib/CodeGen/CodeGenModule.cpp
@@ -2777,6 +2777,27 @@ std::string CodeGenModule::getMangledNameIgnoringAsmLabel(GlobalDecl GD,
return MangledName;
}
+StringRef CodeGenModule::getUnhashedMangledName(StringRef Name) const {
+ if (!LangOpts.HashMangledNames || !Name.contains(".h."))
+ return StringRef();
+ if (auto It = UnhashedManglings.find(Name); It != UnhashedManglings.end())
+ return It->second;
+ GlobalDecl GD;
+ if (!lookupRepresentativeDecl(Name, GD) || !GD.getDecl())
+ return StringRef();
+ const auto *ND = dyn_cast<NamedDecl>(GD.getDecl());
+ if (!ND)
+ return StringRef();
+ auto &MutableThis = *const_cast<CodeGenModule *>(this);
+ MangleContext &MC = MutableThis.getCXXABI().getMangleContext();
+ bool PrevSuppress = MC.isHashMangledNamesSuppressed();
+ MC.setSuppressHashMangledNames(true);
+ std::string Unhashed = getMangledNameImpl(MutableThis, GD, ND);
+ MC.setSuppressHashMangledNames(PrevSuppress);
+ auto [Inserted, _] = UnhashedManglings.try_emplace(Name, std::move(Unhashed));
+ return Inserted->second;
+}
+
StringRef CodeGenModule::getBlockMangledName(GlobalDecl GD,
const BlockDecl *BD) {
MangleContext &MangleCtx = getCXXABI().getMangleContext();
@@ -4476,8 +4497,10 @@ void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
bool CodeGenModule::isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn,
SourceLocation Loc) const {
const auto &NoSanitizeL = getContext().getNoSanitizeList();
- // NoSanitize by function name.
- if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
+ // NoSanitize by function name (also matching unhashed canonical mangled names
+ // under -fhash-mangled-names).
+ if (NoSanitizeL.containsFunction(Kind, Fn->getName(),
+ getUnhashedMangledName(Fn->getName())))
return true;
// NoSanitize by location. Check "mainfile" prefix.
auto &SM = Context.getSourceManager();
@@ -4498,7 +4521,8 @@ bool CodeGenModule::isInNoSanitizeList(SanitizerMask Kind,
SourceLocation Loc, QualType Ty,
StringRef Category) const {
const auto &NoSanitizeL = getContext().getNoSanitizeList();
- if (NoSanitizeL.containsGlobal(Kind, GV->getName(), Category))
+ if (NoSanitizeL.containsGlobal(Kind, GV->getName(), Category,
+ getUnhashedMangledName(GV->getName())))
return true;
auto &SM = Context.getSourceManager();
if (NoSanitizeL.containsMainFile(
@@ -4532,8 +4556,13 @@ bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
auto Attr = ImbueAttr::NONE;
if (Loc.isValid())
Attr = XRayFilter.shouldImbueLocation(Loc, Category);
- if (Attr == ImbueAttr::NONE)
- Attr = XRayFilter.shouldImbueFunction(Fn->getName());
+ if (Attr == ImbueAttr::NONE) {
+ StringRef Unhashed = getUnhashedMangledName(Fn->getName());
+ if (!Unhashed.empty())
+ Attr = XRayFilter.shouldImbueFunction(Unhashed);
+ if (Attr == ImbueAttr::NONE)
+ Attr = XRayFilter.shouldImbueFunction(Fn->getName());
+ }
switch (Attr) {
case ImbueAttr::NONE:
return false;
@@ -4559,7 +4588,12 @@ CodeGenModule::isFunctionBlockedByProfileList(llvm::Function *Fn,
if (ProfileList.isEmpty())
return ProfileList::Allow;
llvm::driver::ProfileInstrKind Kind = getCodeGenOpts().getProfileInstr();
- // First, check the function name.
+ // First, check the function name (preferring the unhashed canonical mangled
+ // name under -fhash-mangled-names so allow/forbid precedence matches).
+ StringRef Unhashed = getUnhashedMangledName(Fn->getName());
+ if (!Unhashed.empty())
+ if (auto V = ProfileList.isFunctionExcluded(Unhashed, Kind))
+ return *V;
if (auto V = ProfileList.isFunctionExcluded(Fn->getName(), Kind))
return *V;
// Next, check the source location.
@@ -9015,6 +9049,7 @@ void CodeGenModule::moveLazyEmissionStates(CodeGenModule *NewBuilder) {
assert(NewBuilder->Manglings.empty() &&
"Newly created module should not have manglings");
NewBuilder->Manglings = std::move(Manglings);
+ NewBuilder->UnhashedManglings = std::move(UnhashedManglings);
NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
diff --git a/clang/lib/CodeGen/CodeGenModule.h b/clang/lib/CodeGen/CodeGenModule.h
index e2bd6bc4701fda..5632a51959f21d 100644
--- a/clang/lib/CodeGen/CodeGenModule.h
+++ b/clang/lib/CodeGen/CodeGenModule.h
@@ -500,6 +500,8 @@ class CodeGenModule : public CodeGenTypeCache {
/// An ordered map of canonical GlobalDecls to their mangled names.
llvm::MapVector<GlobalDecl, StringRef> MangledDeclNames;
llvm::StringMap<GlobalDecl, llvm::BumpPtrAllocator> Manglings;
+ mutable llvm::StringMap<std::string, llvm::BumpPtrAllocator>
+ UnhashedManglings;
/// Global annotations.
std::vector<llvm::Constant*> Annotations;
@@ -1534,6 +1536,7 @@ class CodeGenModule : public CodeGenTypeCache {
StringRef getMangledName(GlobalDecl GD);
std::string getMangledNameIgnoringAsmLabel(GlobalDecl GD,
const NamedDecl *ND);
+ StringRef getUnhashedMangledName(StringRef Name) const;
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD);
const GlobalDecl getMangledNameDecl(StringRef);
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
index df8c9ccb1027bb..ca81368643a386 100644
--- a/clang/lib/Driver/ToolChains/Clang.cpp
+++ b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -6710,6 +6710,8 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
addPGOAndCoverageFlags(TC, C, JA, Output, Args, SanitizeArgs, CmdArgs);
Args.AddLastArg(CmdArgs, options::OPT_fclang_abi_compat_EQ);
+ Args.addOptInFlag(CmdArgs, options::OPT_fhash_mangled_names,
+ options::OPT_fno_hash_mangled_names);
if (getLastProfileSampleUseArg(Args) &&
Args.hasFlag(options::OPT_fsample_profile_use_profi,
diff --git a/clang/test/CodeGenCXX/mangle-hash-names.cpp b/clang/test/CodeGenCXX/mangle-hash-names.cpp
new file mode 100644
index 00000000000000..6f8e2f43a24b74
--- /dev/null
+++ b/clang/test/CodeGenCXX/mangle-hash-names.cpp
@@ -0,0 +1,388 @@
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fhash-mangled-names -emit-llvm %s -o %t.ll
+// RUN: FileCheck %s --input-file=%t.ll
+// RUN: FileCheck %s --input-file=%t.ll --check-prefix=HASHDIFF
+// RUN: llvm-cxxfilt < %t.ll | FileCheck %s --check-prefix=DEMANGLE
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix=NOHASH
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -x c++-header -emit-pch %s -o %t.nohash.pch
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fhash-mangled-names -include-pch %t.nohash.pch -emit-llvm %s -o - | FileCheck %s --check-prefix=PCH-HASH
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -x c++-header -fhash-mangled-names -emit-pch %s -o %t.hash.pch
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -include-pch %t.hash.pch -emit-llvm %s -o - | FileCheck %s --check-prefix=PCH-NOHASH
+// RUN: %clang_cc1 -x cuda -fcuda-is-device -std=c++20 -triple nvptx64-nvidia-cuda -fhash-mangled-names -emit-llvm %s -o - | FileCheck %s --check-prefix=CUDA --implicit-check-not=.h.
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-apple-macosx11.0.0 -fhash-mangled-names -emit-llvm %s -o - | FileCheck %s --check-prefix=MACHO --implicit-check-not=.h.
+// RUN: printf 'fun:_ZN1a1b1c6MyFuncI1BEE1TI1AEP1PI2C1EPS7_I2C2EPS7_I2C3EPS7_I2C4EPS7_I2C5EPS7_I2C6EPS7_I2C7EPS7_I2C8E\nfun:*consumeStdStrings*\nfun:_ZN1a1b1c17consumeStdStringsERKSbIDsSt11char_traitsIDsESaIDsEEP1PI2C1EPS8_I2C2EPS8_I2C3EPS8_I2C4E=sanitize\nglobal:_ZN1a1b1c17GlobalVarTemplateB14custom_abi_tagI1PI2C1ES3_I2C2ES3_I2C3ES3_I2C4EEE\n' > %t.san.ignorelist
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fhash-mangled-names -fsanitize=memory,address -fsanitize-ignorelist=%t.san.ignorelist -emit-llvm %s -o - | FileCheck %s --check-prefix=SANLIST
+// RUN: printf '[always]\nfun:_ZN1a1b1c6MyFuncI1BEE1TI1AEP1PI2C1EPS7_I2C2EPS7_I2C3EPS7_I2C4EPS7_I2C5EPS7_I2C6EPS7_I2C7EPS7_I2C8E\n[never]\nfun:*MyFunc*\n' > %t.xray.list
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fhash-mangled-names -fxray-instrument -fxray-attr-list=%t.xray.list -emit-llvm %s -o - | FileCheck %s --check-prefix=XRAYLIST
+// RUN: printf '[llvm]\nfunction:_ZN1a1b1c6MyFuncI1BEE1TI1AEP1PI2C1EPS7_I2C2EPS7_I2C3EPS7_I2C4EPS7_I2C5EPS7_I2C6EPS7_I2C7EPS7_I2C8E=allow\nfunction:*MyFunc*=forbid\n' > %t.prof.list
+// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-linux-gnu -fhash-mangled-names -fprofile-instrument=llvm -fprofile-list=%t.prof.list -emit-llvm %s -o - | FileCheck %s --check-prefix=PROFLIST
+
+#ifndef HEADER
+#define HEADER
+
+template <typename> struct T {};
+struct A {};
+struct B {};
+struct B2 {};
+template <typename> struct P {};
+struct C1 {};
+struct C2 {};
+struct C3 {};
+struct C4 {};
+struct C5 {};
+struct C6 {};
+struct C7 {};
+struct C8 {};
+
+namespace a {
+namespace b {
+namespace c {
+
+// 1. Function template with long return type and parameter list:
+// Drops template args, return type, and parameters into '.h.<uint64>' BLAKE3 hash.
+template <typename U>
+T<A> MyFunc(P<C1> *, P<C2> *, P<C3> *, P<C4> *, P<C5> *, P<C6> *, P<C7> *,
+ P<C8> *) {
+ return {};
+}
+
+template T<A> MyFunc<B>(P<C1> *, P<C2> *, P<C3> *, P<C4> *, P<C5> *, P<C6> *,
+ P<C7> *, P<C8> *);
+template T<A> MyFunc<B2>(P<C1> *, P<C2> *, P<C3> *, P<C4> *, P<C5> *, P<C6> *,
+ P<C7> *, P<C8> *);
+
+// 2. Short mangled name stays unhashed because shortened + suffix >= original.
+int shortFn(int x) { return x; }
+
+// 3. Nested class templates, method qualifiers, ctors, dtors, conversion ops,
+// virtual tables, typeinfo, and thunks.
+template <typename X, typename Y> struct Outer {
+ template <typename U, typename V> struct Inner {
+ int method(P<C1> *, P<C2> *, P<C3> *, P<C4> *) const & { return 0; }
+ int method(P<C1> *, P<C2> *, P<C3> *, P<C4> *) && { return 1; }
+
+ template <typename W>
+ Inner(W, P<C1> *, P<C2> *, P<C3> *, P<C4> *) {}
+
+ operator P<C1>() const { return {}; }
+
+ template <typename W>
+ operator P<W>() const { return {}; }
+
+ operator Outer<P<C5>, P<C6>>() const { return {}; }
+ };
+};
+
+void instantiateNested(P<C1> *p1, P<C2> *p2, P<C3> *p3, P<C4> *p4) {
+ Outer<C1, C2>::Inner<C3, C4> obj(B{}, p1, p2, p3, p4);
+ const auto &cref = obj;
+ (void)cref.method(p1, p2, p3, p4);
+ (void)static_cast<Outer<C1, C2>::Inner<C3, C4> &&>(obj).method(p1, p2, p3, p4);
+ (void)static_cast<P<C1>>(cref);
+ (void)cref.operator P<C2>();
+ (void)static_cast<Outer<P<C5>, P<C6>>>(cref);
+}
+
+// 4. Local static variable and guard variable inside a long template function.
+int makeVal();
+template <typename U>
+int WithLocalStatic(P<C1> *, P<C2> *, P<C3> *, P<C4> *, P<C5> *, P<C6> *) {
+ static int cachedValue = makeVal();
+ auto genericLambda = []<typename L>(L, P<C1> *, P<C2> *, P<C3> *, P<C4> *) {
+ return 42;
+ };
+ return cachedValue + genericLambda(U{}, nullptr, nullptr, nullptr, nullptr);
+}
+
+template int WithLocalStatic<B>(P<C1> *, P<C2> *, P<C3> *, P<C4> *, P<C5> *,
+ P<C6> *);
+
+// 5. Multiple inheritance virtual thunk, vtable, and RTTI.
+struct Base1 {
+ virtual ~Base1() = default;
+ virtual void first() {}
+};
+struct Base2 {
+ virtual ~Base2() = default;
+ virtual void vfunc(P<C1> *, P<C2> *, P<C3> *, P<C4> *) = 0;
+};
+template <typename U, typename V, typename W>
+struct MultiDerived : Base1, Base2 {
+ void vfunc(P<C1> *, P<C2> *, P<C3> *, P<C4> *) override {}
+};
+
+void useMultiDerived() {
+ MultiDerived<P<C1>, P<C2>, P<C3>> d;
+ d.vfunc(nullptr, nullptr, nullptr, nullptr);
+}
+
+// 6. Variable template and ABI tags.
+template <typename U, typename V, typename W, typename Z>
+int __attribute__((abi_tag("custom_abi_tag"))) GlobalVarTemplate = 7;
+
+int useVarTemplate() {
+ return GlobalVarTemplate<P<C1>, P<C2>, P<C3>, P<C4>>;
+}
+
+// 7. Class-member operator new / operator delete SHOULD still be hashed.
+struct WithMemberAlloc {
+ static void *operator new(decltype(sizeof(0)), P<C1> *, P<C2> *, P<C3> *,
+ P<C4> *);
+ static void operator delete(void *, P<C1> *, P<C2> *, P<C3> *, P<C4> *);
+};
+
+} // namespace c
+} // namespace b
+} // namespace a
+
+namespace std {
+enum class align_val_t : decltype(sizeof(0)) {};
+struct nothrow_t {
+ explicit nothrow_t() = default;
+};
+extern const nothrow_t nothrow;
+
+template <typename CharT> struct char_traits {};
+template <typename T> struct allocator {};
+
+template <typename CharT, typename Traits = char_traits<CharT>>
+struct basic_ios {
+ virtual ~basic_ios() = default;
+ virtual void clear(P<C1> *, P<C2> *, P<C3> *, P<C4> *) {}
+};
+
+template <typename CharT, typename Traits, typename Alloc>
+struct basic_string {
+ void append(P<C1> *, P<C2> *, P<C3> *, P<C4> *, P<C5> *, P<C6> *) {}
+};
+
+inline namespace __1 {
+template <typename CharT> struct inline_basic_streambuf {
+ virtual ~inline_basic_streambuf() = default;
+ virtual void syncbuf(P<C1> *, P<C2> *, P<C3> *, P<C4> *) {}
+};
+} // namespace __1
+} // namespace std
+
+namespace __gnu_debug {
+struct _Safe_sequence_base {};
+struct _Safe_iterator_base {
+ void _M_attach(_Safe_sequence_base *, bool);
+};
+} // namespace __gnu_debug
+
+namespace a {
+namespace b {
+namespace c {
+void consumeStdStrings(
+ const std::basic_string<char16_t, std::char_traits<char16_t>,
+ std::allocator<char16_t>> &,
+ P<C1> *, P<C2> *, P<C3> *, P<C4> *) {}
+} // namespace c
+} // namespace b
+} // namespace a
+
+// 8. Global ::operator new / ::operator new[] / ::operator delete /
+// ::operator delete[] (including aligned/nothrow and custom global
+// placement/tagged overloads) MUST stay unhashed.
+enum class custom_alloc_tag_t : unsigned char {};
+
+void *operator new(decltype(sizeof(0)), std::align_val_t,
+ const std::nothrow_t &) noexcept;
+void *operator new[](decltype(sizeof(0)), std::align_val_t,
+ const std::nothrow_t &) noexcept;
+void operator delete(void *, std::align_val_t,
+ const std::nothrow_t &) noexcept;
+void operator delete[](void *, std::align_val_t,
+ const std::nothrow_t &) noexcept;
+extern "C++" {
+void *operator new(decltype(sizeof(0)), std::align_val_t,
+ const std::nothrow_t &, custom_alloc_tag_t) noexcept;
+void *operator new[](decltype(sizeof(0)), std::align_val_t,
+ const std::nothrow_t &, custom_alloc_tag_t) noexcept;
+}
+
+void sinkPtr(void *);
+
+void useAllocators() {
+ void *p1 = ::operator new(8, std::align_val_t{16}, std::nothrow);
+ sinkPtr(p1);
+ ::operator delete(p1, std::align_val_t{16}, std::nothrow);
+
+ void *p2 = ::operator new[](16, std::align_val_t{32}, std::nothrow);
+ sinkPtr(p2);
+ ::operator delete[](p2, std::align_val_t{32}, std::nothrow);
+
+ sinkPtr(::operator new(8, std::align_val_t{16}, std::nothrow,
+ custom_alloc_tag_t{1}));
+ sinkPtr(::operator new[](16, std::align_val_t{32}, std::nothrow,
+ custom_alloc_tag_t{2}));
+
+ void *pm = a::b::c::WithMemberAlloc::operator new(
+ sizeof(a::b::c::WithMemberAlloc), nullptr, nullptr, nullptr, nullptr);
+ sinkPtr(pm);
+ a::b::c::WithMemberAlloc::operator delete(pm, nullptr, nullptr, nullptr,
+ nullptr);
+}
+
+void useStdString() {
+ using LongElem = a::b::c::MultiDerived<P<C1>, P<C2>, P<C3>>;
+ std::basic_ios<LongElem> ios;
+ ios.clear(nullptr, nullptr, nullptr, nullptr);
+ std::inline_basic_streambuf<LongElem> sbuf;
+ sbuf.syncbuf(nullptr, nullptr, nullptr, nullptr);
+ std::basic_string<char16_t, std::char_traits<char16_t>,
+ std::allocator<char16_t>>
+ s;
+ s.append(nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
+ __gnu_debug::_Safe_iterator_base safe_it;
+ safe_it._M_attach(nullptr, false);
+ a::b::c::consumeStdStrings(s, nullptr, nullptr, nullptr, nullptr);
+}
+
+// CUDA __global__ kernels and __device__ functions on NVPTX MUST stay unhashed
+// so host launch stubs match external device compilers (e.g. nvcc) and PTX
+// symbol names never contain '.' (rejected by ptxas).
+#ifdef __CUDA__
+template <typename T>
+__attribute__((device)) int myCudaDeviceHelper(P<C1> *, P<C2> *, P<C3> *,
+ P<C4> *, T *) {
+ return 0;
+}
+template <typename T>
+__attribute__((global)) void myCudaTemplateKernel(P<C1> *p1, P<C2> *p2,
+ P<C3> *p3, P<C4> *p4, T *t) {
+ (void)myCudaDeviceHelper<T>(p1, p2, p3, p4, t);
+}
+template __attribute__((global)) void
+myCudaTemplateKernel<C5>(P<C1> *, P<C2> *, P<C3> *, P<C4> *, C5 *);
+#endif
+
+#else
+
+T<A> useFromPCH() {
+ return a::b::c::MyFunc<int>(nullptr, nullptr, nullptr, nullptr, nullptr,
+ nullptr, nullptr, nullptr);
+}
+
+#endif
+
+// --- Verify IR symbols with -fhash-mangled-names ---
+
+// Guard and local static variable:
+// CHECK-DAG: @_ZZN1a1b1c15WithLocalStaticEvE11cachedValue{{[.]h[.][0-9]+[ ]}}= linkonce_odr global
+// CHECK-DAG: @_ZGVZN1a1b1c15WithLocalStaticEvE11cachedValue{{[.]h[.][0-9]+[ ]}}= linkonce_odr global
+
+// Variable template with ABI tag stripped into hash:
+// CHECK-DAG: @_ZN1a1b1c17GlobalVarTemplateE{{[.]h[.][0-9]+[ ]}}= linkonce_odr global
+
+// VTable and RTTI structure are hashed, while _ZTS (typeinfo name string) is NOT hashed:
+// CHECK-DAG: @_ZTVN1a1b1c12MultiDerivedE{{[.]h[.][0-9]+[ ]}}= linkonce_odr constant
+// CHECK-DAG: @_ZTSN1a1b1c12MultiDerivedI1PI2C1ES3_I2C2ES3_I2C3EEE = linkonce_odr constant
+// CHECK-DAG: @_ZTIN1a1b1c12MultiDerivedE{{[.]h[.][0-9]+[ ]}}= linkonce_odr constant
+
+// Distinct template instantiations get distinct hashes:
+// CHECK-DAG: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+[(]}}
+// CHECK-DAG: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+[(]}}
+// HASHDIFF: define weak_odr void @_ZN1a1b1c6MyFuncEv.h.[[HASH_B:[0-9]+]](
+// HASHDIFF-NOT: @_ZN1a1b1c6MyFuncEv.h.[[HASH_B]](
+
+// Short name is untouched:
+// CHECK-DAG: define{{.*}} i32 @_ZN1a1b1c7shortFnEi(i32
+
+// Nested class templates, constructor template, qualified methods, conversion ops:
+// CHECK-DAG: define linkonce_odr void @_ZN1a1b1c5Outer5InnerC2Ev{{[.]h[.][0-9]+[(]}}
+// CHECK-DAG: define linkonce_odr{{.*}} i32 @_ZN1a1b1c5Outer5Inner6methodEv{{[.]h[.][0-9]+[(]}}
+// CHECK-DAG: define linkonce_odr void @_ZN1a1b1c5Outer5Innercv1PEv{{[.]h[.][0-9]+[(]}}
+// CHECK-DAG: define linkonce_odr void @_ZN1a1b1c5Outer5InnercvNS1_5OuterEEv{{[.]h[.][0-9]+[(]}}
+
+// Generic lambda inside long template function:
+// CHECK-DAG: define linkonce_odr{{.*}} i32 @_ZZN1a1b1c15WithLocalStaticEvENUlvE_clEv{{[.]h[.][0-9]+[(]}}
+
+// Virtual method and non-virtual thunk:
+// CHECK-DAG: define linkonce_odr void @_ZN1a1b1c12MultiDerived5vfuncEv{{[.]h[.][0-9]+[(]}}
+// CHECK-DAG: define linkonce_odr void @_ZThn8_N1a1b1c12MultiDerived5vfuncEv{{[.]h[.][0-9]+[(]}}
+
+// Declarations inside top-level namespace std (including inline std::__1,
+// methods, and vtables) and __gnu_debug remain unhashed, while functions
+// outside std taking std::basic_string args ARE hashed:
+// CHECK-DAG: @_ZTVSt9basic_iosIN1a1b1c12MultiDerivedI1PI2C1E{{[A-Za-z0-9_]+}}EE = linkonce_odr constant
+// CHECK-DAG: @_ZTVNSt3__122inline_basic_streambufIN1a1b1c12MultiDerivedI1PI2C1E{{[A-Za-z0-9_]+}}EE = linkonce_odr constant
+// CHECK-DAG: define linkonce_odr void @_ZNSt3__122inline_basic_streambufIN1a1b1c12MultiDerivedI1PI2C1E{{[A-Za-z0-9_]+}}E7syncbufEP{{[A-Za-z0-9_]+}}E(
+// CHECK-DAG: define linkonce_odr void @_ZNSbIDsSt11char_traitsIDsESaIDsEE6appendEP1PI2C1E{{[A-Za-z0-9_]+}}E(
+// CHECK-DAG: declare{{.*}} void @_ZN11__gnu_debug19_Safe_iterator_base9_M_attachEPNS_19_Safe_sequence_baseEb(
+// CHECK-DAG: define{{.*}} void @_ZN1a1b1c17consumeStdStringsEv{{[.]h[.][0-9]+[(]}}
+
+// Global allocation/deallocation functions remain unhashed even when long:
+// CHECK-DAG: declare{{.*}} ptr @_ZnwmSt11align_val_tRKSt9nothrow_t(
+// CHECK-DAG: declare{{.*}} ptr @_ZnamSt11align_val_tRKSt9nothrow_t(
+// CHECK-DAG: declare{{.*}} void @_ZdlPvSt11align_val_tRKSt9nothrow_t(
+// CHECK-DAG: declare{{.*}} void @_ZdaPvSt11align_val_tRKSt9nothrow_t(
+// CHECK-DAG: declare{{.*}} ptr @_ZnwmSt11align_val_tRKSt9nothrow_t18custom_alloc_tag_t(
+// CHECK-DAG: declare{{.*}} ptr @_ZnamSt11align_val_tRKSt9nothrow_t18custom_alloc_tag_t(
+
+// Class-member allocation/deallocation functions ARE hashed:
+// CHECK-DAG: declare{{.*}} ptr @_ZN1a1b1c15WithMemberAllocnwEv{{[.]h[.][0-9]+[(]}}
+// CHECK-DAG: declare{{.*}} void @_ZN1a1b1c15WithMemberAllocdlEv{{[.]h[.][0-9]+[(]}}
+
+// SamplePGO suffix elision policy is set to "selected" so '.h.<uint64>' is preserved:
+// CHECK-DAG: attributes #{{[0-9]+}} = { {{.*}}"sample-profile-suffix-elision-policy"="selected"{{.*}} }
+
+// CUDA-DAG: define{{.*}} ptx_kernel void @_Z20myCudaTemplateKernelI2C5EvP1PI2C1EPS1_I2C2EPS1_I2C3EPS1_I2C4EPT_(
+// CUDA-DAG: define linkonce_odr{{.*}} i32 @_Z18myCudaDeviceHelperI2C5EiP1PI2C1EPS1_I2C2EPS1_I2C3EPS1_I2C4EPT_(
+
+// Non-ELF targets (e.g. Apple Mach-O) keep standard dot-free Itanium mangling:
+// MACHO: define weak_odr void @_ZN1a1b1c6MyFuncI1BEE1TI1AEP1PI2C1EPS7_I2C2EPS7_I2C3EPS7_I2C4EPS7_I2C5EPS7_I2C6EPS7_I2C7EPS7_I2C8E(
+
+// --- Verify end-to-end demangling via unmodified llvm-cxxfilt ---
+// DEMANGLE-DAG: a::b::c::WithLocalStatic()::cachedValue ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: guard variable for a::b::c::WithLocalStatic()::cachedValue ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::GlobalVarTemplate ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: vtable for a::b::c::MultiDerived ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: typeinfo for a::b::c::MultiDerived ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::MyFunc() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::Outer::Inner::Inner() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::Outer::Inner::method() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::Outer::Inner::operator P() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::Outer::Inner::operator a::b::c::Outer() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: non-virtual thunk to a::b::c::MultiDerived::vfunc() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::consumeStdStrings() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::WithMemberAlloc::operator new() ({{[.]h[.][0-9]+[)]}}
+// DEMANGLE-DAG: a::b::c::WithMemberAlloc::operator delete() ({{[.]h[.][0-9]+[)]}}
+
+// --- Verify default mode (flag off) keeps standard Itanium mangling ---
+// NOHASH-DAG: define weak_odr void @_ZN1a1b1c6MyFuncI1BEE1TI1AEP1PI2C1EPS7_I2C2EPS7_I2C3EPS7_I2C4EPS7_I2C5EPS7_I2C6EPS7_I2C7EPS7_I2C8E(
+// NOHASH-NOT: {{[.]h[.][0-9]+[ (]}}
+// NOHASH-NOT: "sample-profile-suffix-elision-policy"
+
+// --- Verify Benign PCH/module compatibility across mismatched -fhash-mangled-names ---
+// PCH-HASH: define linkonce_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+[(]}}
+// PCH-NOHASH: define linkonce_odr void @_ZN1a1b1c6MyFuncIiEE1TI1AE{{.*}}(
+// PCH-NOHASH-NOT: {{[.]h[.][0-9]+[ (]}}
+
+// --- Verify Sanitizer, XRay, and Profile special-case lists match unhashed canonical mangled names ---
+// MyFunc<B> is in san.ignorelist (no sanitize_memory/address), MyFunc<B2> is NOT (has both),
+// consumeStdStrings matched fun:*consumeStdStrings* then =sanitize (re-enabled, shares #SAN_ACTIVE),
+// and GlobalVarTemplate is in global: ignorelist (no_sanitize_address):
+// SANLIST: @_ZN1a1b1c17GlobalVarTemplateE{{[.]h[.][0-9]+[ ]}}= linkonce_odr global i32 7, no_sanitize_address, comdat, align 4{{$}}
+// SANLIST: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[SAN_IGNORED:[0-9]+]]
+// SANLIST: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[SAN_ACTIVE:[0-9]+]]
+// SANLIST: define{{.*}} void @_ZN1a1b1c17consumeStdStringsEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[SAN_ACTIVE]]
+// SANLIST: attributes #[[SAN_IGNORED]] = {
+// SANLIST-NOT: sanitize_address
+// SANLIST-NOT: sanitize_memory
+// SANLIST-SAME: }
+// SANLIST: attributes #[[SAN_ACTIVE]] = {{{.*}}sanitize_address{{.*}}sanitize_memory{{.*}}}
+
+// XRay [always] on canonical MyFunc<B> overrides [never] fun:*MyFunc*:
+// XRAYLIST: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[XRAY_ALWAYS:[0-9]+]]
+// XRAYLIST: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[XRAY_NEVER:[0-9]+]]
+// XRAYLIST-DAG: attributes #[[XRAY_ALWAYS]] = {{{.*}}"function-instrument"="xray-always"{{.*}}}
+// XRAYLIST-DAG: attributes #[[XRAY_NEVER]] = {{{.*}}"function-instrument"="xray-never"{{.*}}}
+
+// ProfileList =allow on canonical MyFunc<B> overrides fun:*MyFunc*=forbid (noprofile on MyFunc<B2>):
+// PROFLIST: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[PROF_ALLOW:[0-9]+]]
+// PROFLIST: define weak_odr void @_ZN1a1b1c6MyFuncEv{{[.]h[.][0-9]+}}(ptr {{.*}}) #[[PROF_FORBID:[0-9]+]]
+// PROFLIST: attributes #[[PROF_ALLOW]] = {
+// PROFLIST-NOT: noprofile
+// PROFLIST-SAME: }
+// PROFLIST: attributes #[[PROF_FORBID]] = {{{.*}}noprofile{{.*}}}
diff --git a/clang/test/Driver/fhash-mangled-names.c b/clang/test/Driver/fhash-mangled-names.c
new file mode 100644
index 00000000000000..b037c43ea1b533
--- /dev/null
+++ b/clang/test/Driver/fhash-mangled-names.c
@@ -0,0 +1,6 @@
+// RUN: %clang -### -fhash-mangled-names %s -c 2>&1 | FileCheck --check-prefix=CHECK-OPT %s
+// RUN: %clang -### -fhash-mangled-names -fno-hash-mangled-names %s -c 2>&1 | FileCheck --check-prefix=CHECK-NOOPT %s
+// RUN: %clang -### %s -c 2>&1 | FileCheck --check-prefix=CHECK-NOOPT %s
+
+// CHECK-OPT: "-fhash-mangled-names"
+// CHECK-NOOPT-NOT: "-fhash-mangled-names"
More information about the cfe-commits
mailing list