[Demangle] Add support for D anonymous symbols

[ljmf00]

Summary

Anonymous symbols are represented by 0 in the mangled symbol. We should skip
them in order to represent the demangled name correctly, otherwise demangled
names like `demangle..anon` can happen.

[dblaikie]

Looks OK, though the "anonymous" in the mangled name tests seems misleading - the "anonymous" isn't itself, anonymous, right? IT's followed by anonymous symbol (0), yeah? So maybe change that text/name - might be clearer.

Alternatively, wouldn't this fall out naturally from parseIdentifier if parseIdentifier returned Mangled (rather than nullptr) when Len == 0? Seems that'd be simpler/tidier?

[ljmf00]

In D114307#3144845, @dblaikie wrote:

Looks OK, though the "anonymous" in the mangled name tests seems misleading - the "anonymous" isn't itself, anonymous, right? IT's followed by anonymous symbol (0), yeah? So maybe change that text/name - might be clearer.

Yeah, I understand that this could be misleading. I changed anonymous to test.

Alternatively, wouldn't this fall out naturally from parseIdentifier if parseIdentifier returned Mangled (rather than nullptr) when Len == 0? Seems that'd be simpler/tidier?

No, it would not fall naturally since backreferencing symbols may happen (in the future, not yet implemented). As is, it would fall naturally since e.g. 00035 would be decoded as 35, but in the case where 0Q..., a dot would be appended anyway and logic would be needed later to avoid it. The reason for doing this early is also for performance reasons since other checks are not needed such as whether it is a template or a backreference. Other expensive checks should be avoided like when a number decoding overflows.

[dblaikie]

The reason for doing this early is also for performance reasons since other checks are not needed such as whether it is a template or a backreference. Other expensive checks should be avoided like when a number decoding overflows.

I wouldn't mind avoiding that sort of thing on the first pass & implementing it separately for optimization if/when/with data to show it's valuable, but no worries - if it complicates the code (such as avoiding the ".") that's enough justification for me not to go the other way that I was suggesting. Thanks for explaining!

llvm/lib/Demangle/DLangDemangle.cpp

const char *Demangler::parseQualified(OutputBuffer *Demangled,
   //        SymbolName TypeFunctionNoReturn
   //        SymbolName M TypeFunctionNoReturn
   //        SymbolName M TypeModifiers TypeFunctionNoReturn
   // The start pointer should be at the above location.
 
   // Whether it has more than one symbol
   size_t NotFirst = false;
   do {
+    // Skip over anonymous symbols.
+    if (*Mangled == '0') {
+      do
+        ++Mangled;
+      while (*Mangled == '0');
+
+      continue;
+    }
+
     if (NotFirst)
       *Demangled << '.';
     NotFirst = true;
 
     Mangled = parseIdentifier(Demangled, Mangled);
 
   } while (Mangled && isSymbolName(Mangled));
 

llvm/unittests/Demangle/DLangDemangleTest.cpp

 INSTANTIATE_TEST_SUITE_P(
     DLangDemangleTest, DLangDemangleTestFixture,
     testing::Values(
         std::make_pair("_Dmain", "D main"), std::make_pair(nullptr, nullptr),
         std::make_pair("_Z", nullptr), std::make_pair("_DDD", nullptr),
         std::make_pair("_D88", nullptr),
         std::make_pair("_D8demangleZ", "demangle"),
         std::make_pair("_D8demangle4testZ", "demangle.test"),
-        std::make_pair("_D8demangle4test5test2Z", "demangle.test.test2")));
+        std::make_pair("_D8demangle4test5test2Z", "demangle.test.test2"),
+        std::make_pair("_D8demangle4test0Z", "demangle.test"),
+        std::make_pair("_D8demangle4test03fooZ", "demangle.test.foo")));