[MS Demangler] Properly handle backreferences of special names

[zturner]

Summary

Function template names are not stored in the backref table,
but non-template function names are.  The general pattern seems
to be that when you are demangling a symbol name, if the name
starts with '?' it does not go into the backreference table,
otherwise it does.  Note that this even handles the general case
of operator names (template or otherwise) not going into the
back-reference table, anonymous namespaces not going into the
backreference table, and perhaps other yet-to-be-supported kinds
of names.

It's important that we apply this check only for the
*unqualified* portion of a name, and only for *symbol* names.
For example, this does not apply to type names (such as class
templates) and we need to make sure that these still do go
into the backref table.

There is still one remaining backreference test failure, and
although the failure is likely related, this code is complex enough
that I'd rather address it separately.

[majnemer]

LGTM

llvm/lib/Demangle/MicrosoftDemangle.cpp

1416

(NBB & NBB_Simple) == 0 isn't too many more characters and looks less weird.

[majnemer]

llvm/lib/Demangle/MicrosoftDemangle.cpp

1416

Er, that should be (NBB & NBB_Simple) != 0

llvm/lib/Demangle/MicrosoftDemangle.cpp

enum FuncClass : uint8_t {
   Protected = 1 << 1,
   Private = 1 << 2,
   Global = 1 << 3,
   Static = 1 << 4,
   Virtual = 1 << 5,
   Far = 1 << 6,
 };
 
+enum NameBackrefBehavior : uint8_t {
+  NBB_None = 0,          // don't save any names as backrefs.
+  NBB_Template = 1 << 0, // save template instanations.
+  NBB_Simple = 1 << 1,   // save simple names.
+};
+
 enum class SymbolCategory { Function, Variable };
 
 namespace {
 
 struct NameResolver {
   virtual ~NameResolver() = default;
   virtual StringView resolve(StringView S) = 0;
 };
private:
 
   /// Allocate a copy of \p Borrowed into memory that we own.
   StringView copyString(StringView Borrowed);
 
   Name *demangleFullyQualifiedTypeName(StringView &MangledName);
   Name *demangleFullyQualifiedSymbolName(StringView &MangledName);
 
   Name *demangleUnqualifiedTypeName(StringView &MangledName, bool Memorize);
-  Name *demangleUnqualifiedSymbolName(StringView &MangledName, bool Memorize);
+  Name *demangleUnqualifiedSymbolName(StringView &MangledName,
+                                      NameBackrefBehavior NBB);
 
   Name *demangleNameScopeChain(StringView &MangledName, Name *UnqualifiedName);
   Name *demangleNameScopePiece(StringView &MangledName);
 
   Name *demangleBackRefName(StringView &MangledName);
-  Name *demangleTemplateInstantiationName(StringView &MangledName);
+  Name *demangleTemplateInstantiationName(StringView &MangledName,
+                                          NameBackrefBehavior NBB);
   Name *demangleOperatorName(StringView &MangledName);
   Name *demangleSimpleName(StringView &MangledName, bool Memorize);
   Name *demangleAnonymousNamespaceName(StringView &MangledName);
   Name *demangleLocallyScopedNamePiece(StringView &MangledName);
 
   StringView demangleSimpleString(StringView &MangledName, bool Memorize);
 
   FuncClass demangleFunctionClass(StringView &MangledName);
Name *Demangler::demangleBackRefName(StringView &MangledName) {
   assert(startsWithDigit(MangledName));
   Name *Node = Arena.alloc<Name>();
   Node->IsBackReference = true;
   Node->Str = {MangledName.begin(), 1};
   MangledName = MangledName.dropFront();
   return Node;
 }
 
-Name *Demangler::demangleTemplateInstantiationName(StringView &MangledName) {
+Name *Demangler::demangleTemplateInstantiationName(StringView &MangledName,
+                                                   NameBackrefBehavior NBB) {
   assert(MangledName.startsWith("?$"));
   MangledName.consumeFront("?$");
 
-  Name *Node = demangleUnqualifiedSymbolName(MangledName, false);
+  Name *Node = demangleUnqualifiedSymbolName(MangledName, NBB_None);
   if (Error)
     return nullptr;
 
   Node->TParams = demangleTemplateParameterList(MangledName);
   if (Error)
     return nullptr;
 
   Node->IsTemplateInstantiation = true;
 
+  if (NBB & NBB_Template) {
     // Render this class template name into a string buffer so that we can
     // memorize it for the purpose of back-referencing.
     OutputStream OS = OutputStream::create(nullptr, nullptr, 1024);
     outputName(OS, Node, *this);
     OS << '\0';
     char *Name = OS.getBuffer();
 
     StringView Owned = copyString(Name);
     memorizeString(Owned);
     std::free(Name);
+  }
 
   return Node;
 }
 
 Name *Demangler::demangleOperatorName(StringView &MangledName) {
   assert(MangledName.startsWith('?'));
   MangledName.consumeFront('?');
 
Name *Demangler::demangleFullyQualifiedTypeName(StringView &MangledName) {
   assert(QualName);
   return QualName;
 }
 
 // Parses a symbol name in the form of A@B@C@@ which represents C::B::A.
 // Symbol names have slightly different rules regarding what can appear
 // so we separate out the implementations for flexibility.
 Name *Demangler::demangleFullyQualifiedSymbolName(StringView &MangledName) {
-  Name *SymbolName = demangleUnqualifiedSymbolName(MangledName, true);
+  Name *SymbolName = demangleUnqualifiedSymbolName(MangledName, NBB_Simple);
   if (Error)
     return nullptr;
   assert(SymbolName);
 
   Name *QualName = demangleNameScopeChain(MangledName, SymbolName);
   if (Error)
     return nullptr;
   assert(QualName);
   return QualName;
 }
 
 Name *Demangler::demangleUnqualifiedTypeName(StringView &MangledName,
                                              bool Memorize) {
   // An inner-most name can be a back-reference, because a fully-qualified name
   // (e.g. Scope + Inner) can contain other fully qualified names inside of
   // them (for example template parameters), and these nested parameters can
   // refer to previously mangled types.
   if (startsWithDigit(MangledName))
     return demangleBackRefName(MangledName);
 
   if (MangledName.startsWith("?$"))
-    return demangleTemplateInstantiationName(MangledName);
+    return demangleTemplateInstantiationName(MangledName, NBB_Template);
 
   return demangleSimpleName(MangledName, Memorize);
 }
 
 Name *Demangler::demangleUnqualifiedSymbolName(StringView &MangledName,
-                                               bool Memorize) {
+                                               NameBackrefBehavior NBB) {
   if (startsWithDigit(MangledName))
     return demangleBackRefName(MangledName);
   if (MangledName.startsWith("?$"))
-    return demangleTemplateInstantiationName(MangledName);
+    return demangleTemplateInstantiationName(MangledName, NBB);
   if (MangledName.startsWith('?'))
     return demangleOperatorName(MangledName);
-  return demangleSimpleName(MangledName, Memorize);
+  return demangleSimpleName(MangledName, !!(NBB & NBB_Simple));
 }
 
 Name *Demangler::demangleNameScopePiece(StringView &MangledName) {
   if (startsWithDigit(MangledName))
     return demangleBackRefName(MangledName);
 
   if (MangledName.startsWith("?$"))
-    return demangleTemplateInstantiationName(MangledName);
+    return demangleTemplateInstantiationName(MangledName, NBB_Template);
 
   if (MangledName.startsWith("?A"))
     return demangleAnonymousNamespaceName(MangledName);
 
   if (startsWithLocalScopePattern(MangledName))
     return demangleLocallyScopedNamePiece(MangledName);
 
   return demangleSimpleName(MangledName, true);

llvm/test/Demangle/ms-back-references.test

 ; CHECK: void __cdecl h2(void (__cdecl *)(void *), void *)
 
 ?h3@@YAP6APAHPAH0@ZP6APAH00@Z10@Z
 ; CHECK: int * (__cdecl * __cdecl h3(int * (__cdecl *)(int *, int *), int * (__cdecl *)(int *, int *), int *))(int *, int *)
 
 ?foo@0@YAXXZ
 ; CHECK: void __cdecl foo::foo(void)
 
-; We have some issues with back-references and class / function templates.
 ??$?HH@S@@QEAAAEAU0@H@Z
-; FIXME: struct S &__cdecl S::operator+<int>(int)
+struct S & __cdecl S::operator+<int>(int)
 No newline at end of file