Avoid extra back reference key lookup in msmangler

[K-ballo]

Summary

Avoid a second key lookup when the back reference key is going to be inserted in the StringMap. The string lookups in the msmangler are the main responsible for the huge overhead when compared to the itanium mangler. This patch makes a small but noticeable improvement.

[timurrrr]

Looks good overall.

lib/AST/MicrosoftMangle.cpp

614

You probably want

std::tie(I, Inserted) = NameBackReferences.insert(...)

See MicrosoftCXXABI::getAddrOfVTable as an example.

673

Am I right that you need raw_svector_ostream just to use SmallString instead of string?

[K-ballo]

lib/AST/MicrosoftMangle.cpp

614

Indeed, the standard insert interface is what I would want. However, StringMap does not offer this interface, its insert member simply returns bool.

673

That is correct.

[timurrrr]

Is it hard to add that function to the interface?

[K-ballo]

In D4130#6, @timurrrr wrote:

Is it hard to add that function to the interface?

It seems doable at first sight. I will try adding those insert overloads to StringMap.

[K-ballo]

I think that instead of introducing a new function I should just be using mangleSourceName. A template instantiation name is a source name too (considering anonymous type names are treated as source names), it's just that their terminating '@' is currently being added at the end of the template argument list. If the argument list no longer appends the '@', then they would be treated as any other source name.

[K-ballo]

Changes in this iteration:

• Use the new StringMap::insert overload.
• Template instantiation names are source names, mangle them as such.

[rnk]

lgtm

Timur is on vacation. Do you need me to commit this for you?

[K-ballo]

In D4130#13, @rnk wrote:

Do you need me to commit this for you?

Yes, please. Thank you.

[rnk]

Landed as rL211813. Not sure why phab didn't close this.

lib/AST/MicrosoftMangle.cpp

else {
     Out << '@';
   }
 }
 
 static const TemplateDecl *
 isTemplate(const NamedDecl *ND, const TemplateArgumentList *&TemplateArgs) {
   // Check if we have a function template.
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
     if (const TemplateDecl *TD = FD->getPrimaryTemplate()) {
       TemplateArgs = FD->getTemplateSpecializationArgs();
       return TD;
     }
   }
 
   // Check if we have a class template.
   if (const ClassTemplateSpecializationDecl *Spec =
           dyn_cast<ClassTemplateSpecializationDecl>(ND)) {
void MicrosoftCXXNameMangler::mangleUnqualifiedName(const NamedDecl *ND,
   const TemplateArgumentList *TemplateArgs = nullptr;
   if (const TemplateDecl *TD = isTemplate(ND, TemplateArgs)) {
     // Function templates aren't considered for name back referencing.  This
     // makes sense since function templates aren't likely to occur multiple
     // times in a symbol.
     // FIXME: Test alias template mangling with MSVC 2013.
     if (!isa<ClassTemplateDecl>(TD)) {
       mangleTemplateInstantiationName(TD, *TemplateArgs);
+      Out << '@';
       return;
     }
 
     // Here comes the tricky thing: if we need to mangle something like
     //   void foo(A::X<Y>, B::X<Y>),
     // the X<Y> part is aliased. However, if you need to mangle
     //   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) 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);
+    llvm::SmallString<64> TemplateMangling;
+    llvm::raw_svector_ostream Stream(TemplateMangling);
     MicrosoftCXXNameMangler Extra(Context, Stream);
     Extra.mangleTemplateInstantiationName(TD, *TemplateArgs);
     Stream.flush();
 
-    BackRefMap::iterator Found = NameBackReferences.find(TemplateMangling);
-    if (Found == NameBackReferences.end()) {
-      Out << TemplateMangling;
-      if (NameBackReferences.size() < 10) {
-        size_t Size = NameBackReferences.size();
-        NameBackReferences[TemplateMangling] = Size;
-      }
-    } else {
-      Out << Found->second;
-    }
+    mangleSourceName(TemplateMangling);
     return;
   }
 
   switch (Name.getNameKind()) {
     case DeclarationName::Identifier: {
       if (const IdentifierInfo *II = Name.getAsIdentifierInfo()) {
         mangleSourceName(II->getName());
         break;
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 = NameBackReferences.find(Name);
-  if (Found == NameBackReferences.end()) {
-    Out << Name << '@';
-    if (NameBackReferences.size() < 10) {
-      size_t Size = NameBackReferences.size();
-      NameBackReferences[Name] = Size;
-    }
+  BackRefMap::iterator Found;
+    bool Inserted;
+    std::tie(Found, Inserted) =
+        NameBackReferences.insert(std::make_pair(Name, Size));
+    if (Inserted)
+      Found = NameBackReferences.end();
+  } else {
+    Found = NameBackReferences.find(Name);
+
+  if (Found == NameBackReferences.end()) {
+    Out << Name << '@';
   } else {
     Out << Found->second;
   }
 }
 
 void MicrosoftCXXNameMangler::mangleObjCMethodName(const ObjCMethodDecl *MD) {
   Context.mangleObjCMethodName(MD, Out);
 }
void MicrosoftCXXNameMangler::mangleExpression(const Expr *E) {
   unsigned DiagID = Diags.getCustomDiagID(
       DiagnosticsEngine::Error, "cannot yet mangle expression type %0");
   Diags.Report(E->getExprLoc(), DiagID) << E->getStmtClassName()
                                         << E->getSourceRange();
 }
 
 void MicrosoftCXXNameMangler::mangleTemplateArgs(
     const TemplateDecl *TD, const TemplateArgumentList &TemplateArgs) {
-  // <template-args> ::= <template-arg>+ @
+  // <template-args> ::= <template-arg>+
   for (const TemplateArgument &TA : TemplateArgs.asArray())
     mangleTemplateArg(TD, TA);
-  Out << '@';
 }
 
 void MicrosoftCXXNameMangler::mangleTemplateArg(const TemplateDecl *TD,
                                                 const TemplateArgument &TA) {
   // <template-arg> ::= <type>
   //                ::= <integer-literal>
   //                ::= <member-data-pointer>
   //                ::= <member-function-pointer>