[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