Simplify microsoft mangling of template instantiations

[K-ballo]

Summary

Use mangled template instantiation name as key for back references. Templates have their own context for back references, so their mangling is always the same regardless of context. This avoids mangling template instantiations twice.

[majnemer]

Hi,

What's the motivation behind this patch?

[timurrrr]

Tesr cases?

[K-ballo]

In D3983#4, @majnemer wrote:

What's the motivation behind this patch?

Efficiency.

I have been profiling the compilation of a heavily templated C++ code, for which name mangling is the dominant part. The Microsoft mangling implementation is about 4 times slower than the Itanium one for this particular case, and it's mainly due to mangling template instantiations twice. As far as I understand, there is no reason to have a back reference key different than the actual mangled name, and thus no reason to mangle template instantiations twice. After this particular change, the Microsoft mangling implementation is just about 2 times slower than the Itanium one.

[K-ballo]

In D3983#5, @timurrrr wrote:

Tesr cases?

No functionality change is intended by this patch. The test case at /cfe/trunk/test/CodeGenCXX/mangle-ms-back-references-pr13207.cpp should be sufficient.

[timurrrr]

The change looks good -- it simplifies the code and makes it faster.

David,
Do you have a good way to make sure we don't regress other than commit-and-see-if-it-explodes?

lib/AST/MicrosoftMangle.cpp

673

This variable is no longer used as just a key.
Please use something like TemplateMangling or TDMangling instead?

[K-ballo]

Renamed BackReferenceKey to TemplateMangling

[K-ballo]

Commited in r210416.

lib/AST/MicrosoftMangle.cpp

class MicrosoftCXXNameMangler {
   /// The "structor" is the top-level declaration being mangled, if
   /// that's not a template specialization; otherwise it's the pattern
   /// for that specialization.
   const NamedDecl *Structor;
   unsigned StructorType;
 
   typedef llvm::StringMap<unsigned> BackRefMap;
   BackRefMap NameBackReferences;
-  bool UseNameBackReferences;
 
   typedef llvm::DenseMap<void *, unsigned> ArgBackRefMap;
   ArgBackRefMap TypeBackReferences;
 
   ASTContext &getASTContext() const { return Context.getASTContext(); }
 
   // FIXME: If we add support for __ptr32/64 qualifiers, then we should push
   // this check into mangleQualifiers().
   const bool PointersAre64Bit;
 
 public:
   enum QualifierMangleMode { QMM_Drop, QMM_Mangle, QMM_Escape, QMM_Result };
 
   MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_)
       : Context(C), Out(Out_), Structor(nullptr), StructorType(-1),
-        UseNameBackReferences(true),
         PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
                          64) {}
 
   MicrosoftCXXNameMangler(MicrosoftMangleContextImpl &C, raw_ostream &Out_,
                           const CXXDestructorDecl *D, CXXDtorType Type)
       : Context(C), Out(Out_), Structor(getStructor(D)), StructorType(Type),
-        UseNameBackReferences(true),
         PointersAre64Bit(C.getASTContext().getTargetInfo().getPointerWidth(0) ==
                          64) {}
 
   raw_ostream &getStream() const { return Out; }
 
   void mangle(const NamedDecl *D, StringRef Prefix = "\01?");
   void mangleName(const NamedDecl *ND);
   void mangleFunctionEncoding(const FunctionDecl *FD);
   void mangleVariableEncoding(const VarDecl *VD);
   void mangleMemberDataPointer(const CXXRecordDecl *RD, const ValueDecl *VD);
   void mangleMemberFunctionPointer(const CXXRecordDecl *RD,
                                    const CXXMethodDecl *MD);
   void mangleVirtualMemPtrThunk(
       const CXXMethodDecl *MD,
       const MicrosoftVTableContext::MethodVFTableLocation &ML);
   void mangleNumber(int64_t Number);
   void mangleType(QualType T, SourceRange Range,
                   QualifierMangleMode QMM = QMM_Mangle);
   void mangleFunctionType(const FunctionType *T,
                           const FunctionDecl *D = nullptr,
                           bool ForceInstMethod = false);
   void mangleNestedName(const NamedDecl *ND);
 
 private:
-  void disableBackReferences() { UseNameBackReferences = false; }
   void mangleUnqualifiedName(const NamedDecl *ND) {
     mangleUnqualifiedName(ND, ND->getDeclName());
   }
   void mangleUnqualifiedName(const NamedDecl *ND, DeclarationName Name);
   void mangleSourceName(StringRef Name);
   void mangleOperatorName(OverloadedOperatorKind OO, SourceLocation Loc);
   void mangleCXXDtorType(CXXDtorType T);
   void mangleQualifiers(Qualifiers Quals, bool IsMember);
if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
     //   void foo(A::X<A::Y>, A::X<B::Y>),
     // the A::X<> part is not aliased.
     // That said, from the mangler's perspective we have a structure like this:
     //   namespace[s] -> type[ -> template-parameters]
     // but from the Clang perspective we have
     //   type [ -> template-parameters]
     //      \-> namespace[s]
     // What we do is we create a new mangler, mangle the same type (without
-    // a namespace suffix) using the extra mangler with back references
-    // disabled (to avoid infinite recursion) and then use the mangled type
-    // name as a key to check the mangling of different types for aliasing.
-
-    std::string BackReferenceKey;
-    BackRefMap::iterator Found;
-    if (UseNameBackReferences) {
-      llvm::raw_string_ostream Stream(BackReferenceKey);
-      MicrosoftCXXNameMangler Extra(Context, Stream);
-      Extra.disableBackReferences();
-      Extra.mangleUnqualifiedName(ND, Name);
-      Stream.flush();
+    // a namespace suffix) to a string using the extra mangler and then use 
+    // the mangled type name as a key to check the mangling of different types
+    // for aliasing.
+
+    std::string TemplateMangling;
+    llvm::raw_string_ostream Stream(TemplateMangling);
+    Extra.mangleTemplateInstantiationName(TD, *TemplateArgs);
 
-      Found = NameBackReferences.find(BackReferenceKey);
-    }
-    if (!UseNameBackReferences || Found == NameBackReferences.end()) {
-      mangleTemplateInstantiationName(TD, *TemplateArgs);
-      if (UseNameBackReferences && NameBackReferences.size() < 10) {
+    BackRefMap::iterator Found = NameBackReferences.find(TemplateMangling);
+    if (Found == NameBackReferences.end()) {
+      Out << TemplateMangling;
+      if (NameBackReferences.size() < 10) {
         size_t Size = NameBackReferences.size();
-        NameBackReferences[BackReferenceKey] = Size;
+        NameBackReferences[TemplateMangling] = Size;
       }
     } else {
       Out << Found->second;
     }
     return;
   }
 
   switch (Name.getNameKind()) {
void MicrosoftCXXNameMangler::mangleOperatorName(OverloadedOperatorKind OO,
   case OO_None:
   case NUM_OVERLOADED_OPERATORS:
     llvm_unreachable("Not an overloaded operator");
   }
 }
 
 void MicrosoftCXXNameMangler::mangleSourceName(StringRef Name) {
   // <source name> ::= <identifier> @
-  BackRefMap::iterator Found;
-  if (UseNameBackReferences)
-    Found = NameBackReferences.find(Name);
-  if (!UseNameBackReferences || Found == NameBackReferences.end()) {
+  BackRefMap::iterator Found = NameBackReferences.find(Name);
+  if (Found == NameBackReferences.end()) {
     Out << Name << '@';
-    if (UseNameBackReferences && NameBackReferences.size() < 10) {
+    if (NameBackReferences.size() < 10) {
       size_t Size = NameBackReferences.size();
       NameBackReferences[Name] = Size;
     }
   } else {
     Out << Found->second;
   }
 }