[PDB] Introduce `MSVCUndecoratedNameParser`

[aleksandr.urakov]

Summary

This patch introduces the simple MSVCUndecoratedNameParser. It is needed for parsing names of PDB symbols corresponding to template instantiations. For example, for the name

`operator<<A>'::`2'::B::operator>

we can't just split the name with :: (as it is implemented for now) to retrieve its scopes. This parser processes such names in a more correct way.

[labath]

I think you should look at CPlusPlusLanguage::MethodName. It already contains a parser (in fact, two of them) of c++ names, and I think it should be easy to extend it to do what you want.

[clayborg]

In D52461#1244813, @labath wrote:

I think you should look at CPlusPlusLanguage::MethodName. It already contains a parser (in fact, two of them) of c++ names, and I think it should be easy to extend it to do what you want.

I agree with Pavel here. Try to use and extend CPlusPlusLanguage::MethodName as needed. I believe it was recently backed by a new clang parser that knows how to chop up C++ demangled names

[aleksandr.urakov]

Ok, I'll look into that, thanks!

[aleksandr.urakov]

In D52461#1245058, @clayborg wrote:

Try to use and extend CPlusPlusLanguage::MethodName as needed. I believe it was recently backed by a new clang parser that knows how to chop up C++ demangled names

It seems that CPlusPlusLanguage::MethodName is backed by LLDB CPlusPlusNameParser, which can't parse demangled names... Can you tell me, please, how is called a new Clang parser you have mentioned? May be I'll use it directly instead of PDBNameParser, or will back PDBNameParser by it (if the interface will be not very convenient)?

[Hui]

In D52461#1249259, @aleksandr.urakov wrote:

In D52461#1245058, @clayborg wrote:

Try to use and extend CPlusPlusLanguage::MethodName as needed. I believe it was recently backed by a new clang parser that knows how to chop up C++ demangled names

It seems that CPlusPlusLanguage::MethodName is backed by LLDB CPlusPlusNameParser, which can't parse demangled names... Can you tell me, please, how is called a new Clang parser you have mentioned? May be I'll use it directly instead of PDBNameParser, or will back PDBNameParser by it (if the interface will be not very convenient)?

Maybe you can try RichManglingContext::FromCxxMethodName(the_demangled_name). Parse it wtih RichManglingContext::ParseFunctionBaseName and extract the full/base name or function decl context (NS) if any with related methods.
No need to introduce a new one.

[aleksandr.urakov]

Ok, I'll look at this, thank you!

[labath]

In D52461#1249259, @aleksandr.urakov wrote:

It seems that CPlusPlusLanguage::MethodName is backed by LLDB CPlusPlusNameParser, which can't parse demangled names...

What makes you say that? If you look at the MethodName unit tests (unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp), you will see that they all operate on demangled names -- there isn't a mangled name in the whole file.

Using RichManglingContext would work too, though I'm not sure if that will buy you anything, as that is just a wrapper around this parser.

[aleksandr.urakov]

I've tried to parse with it a name like

N0::`unnamed namespase'::Name

and it can't parse it correctly. May be it just can't parse MSVC demangled names?

Unfortunately, I can't look at the tests right now, I have a vacation. I'll look at these a week later, ok?

[labath]

In D52461#1250555, @aleksandr.urakov wrote:

I've tried to parse with it a name like

N0::`unnamed namespase'::Name

and it can't parse it correctly. May be it just can't parse MSVC demangled names?

I expect the backqoutes are confusing it. If you try something without anonymous namespaces, it should work fine, and adding support for them shouldn't be too hard (though we may run also into problems with function pointers or other funky names, if they don't demangle the same way as with itanium).

Regardless of how this is exactly implemented, I think it's important to make the CPlusPlusLanguage::MethodName class understand these MSVC names, as this class is already used in a bunch of places. So, if it chokes on MSVC names, you're bound to run into more problems down the line.

Unfortunately, I can't look at the tests right now, I have a vacation. I'll look at these a week later, ok?

That's fine. There's no hurry here..

[aleksandr.urakov]

Hello!

I just have tried to patch CPlusPlusNameParser in the way to support MSVC demangled names, but there is a problem. CPlusPlusNameParser splits an incoming name in tokens with clang::Lexer. I've lexed the next name:

`anonymous namespace'::foo

The lexer treats the first character (a grave accent) as an unknown token, and it's ok for our purposes. Then it sees an identifier (anonymous), a keyword (namespace), and it's ok too. But the problem is with the last part of the string. The lexer sees an apostrophe and supposes that it's a character constant, it looks for a closing apostrophe, don't find it and treats all the line ending ('::foo) as a single unknown token.

It is possible to somehow make clang::Lexer lex MSVC demangled names correctly, but I'm not sure if it is the right place to do it. And it may have then some side effects during lexing a real code.

Another option is to somehow preprocess the name before lexing and replace all paired apostrophes with grave accents, and after lexing replace with apostrophes back, and make CPlusPlusNameParser understand unknown grave accent tokens. But it's a bit tricky, may be you can suggest some better solution?

[zturner]

In D52461#1265335, @aleksandr.urakov wrote:

Hello!

I just have tried to patch CPlusPlusNameParser in the way to support MSVC demangled names, but there is a problem. CPlusPlusNameParser splits an incoming name in tokens with clang::Lexer. I've lexed the next name:

`anonymous namespace'::foo

The lexer treats the first character (a grave accent) as an unknown token, and it's ok for our purposes. Then it sees an identifier (anonymous), a keyword (namespace), and it's ok too. But the problem is with the last part of the string. The lexer sees an apostrophe and supposes that it's a character constant, it looks for a closing apostrophe, don't find it and treats all the line ending ('::foo) as a single unknown token.

It is possible to somehow make clang::Lexer lex MSVC demangled names correctly, but I'm not sure if it is the right place to do it. And it may have then some side effects during lexing a real code.

Another option is to somehow preprocess the name before lexing and replace all paired apostrophes with grave accents, and after lexing replace with apostrophes back, and make CPlusPlusNameParser understand unknown grave accent tokens. But it's a bit tricky, may be you can suggest some better solution?

Just handle the anonymous namespace' thing specially before passing to CPlusPlusNameParser`.

[aleksandr.urakov]

In D52461#1265633, @zturner wrote:

Just handle the anonymous namespace' thing specially before passing to CPlusPlusNameParser`.

Yes, it's an interesting idea to somehow preprocess an MSVC demangled name and make a GCC demangled name from it (and make an MSVC-like name back after parsing). But then we need to handle not only anonymous namespaces, also things like this:

`operator<<A>'::`2'::B::operator>

Such a preprocessing will be comparable to the current implementation of PDBNameParser by complexity (or even more complex). I'll try to somehow estimate the complexity of this approach, thanks.

[labath]

In D52461#1266302, @aleksandr.urakov wrote:

`operator<<A>'::`2'::B::operator>

The reason we had to use clang lexer for parsing itanium names is because parsing itanium demangled names is tricky precisely for cases like these. If the MSVC demangler makes these cases trivial by enclosing them in quotes, maybe a separate (simpler) parser is not such a bad idea.

However, I still think this should be done within the scope of CPlusPlusLanguage::MethodName otherwise, you'll have to special case MSVC for all existing uses of this class.

[aleksandr.urakov]

Yes, it's simpler to move it to the CPlusPlusLanguage::MethodName (or CPlusPlusNameParser?) I think. The only question left is how to differentiate MSVC demangled names from others? May be it would be ok to treat name as an MSVC name if it contains a grave accent? Because we probably already can parse MSVC names without grave accents with CPlusPlusLanguage::MethodName.

[aleksandr.urakov]

Update the diff according to the discussion, making it possible to parse MSVC demangled names by CPlusPlusLanguage. The old PDB plugin still uses MSVCUndecoratedNameParser directly because:

• we are sure that the name in PDB is an MSVC name;
• it has a more convenient interface, especially for restoring namespaces from the parsed name.

[zturner]

In D52461#1280527, @aleksandr.urakov wrote:

Update the diff according to the discussion, making it possible to parse MSVC demangled names by CPlusPlusLanguage. The old PDB plugin still uses MSVCUndecoratedNameParser directly because:

• we are sure that the name in PDB is an MSVC name;
• it has a more convenient interface, especially for restoring namespaces from the parsed name.

So I had an interesting solution to this while working on the native pdb plugin. it is impossible to use it with the old pdb plugin, but given that it works flawlessly for the native pdb plugin, depending on how urgent your need is, maybe you can just put off working on this until you're ready to move over to the native pdb plugin?

Basically the idea is that the raw PDB contains mangled type names for every type. You can see this by dumping types using llvm-pdbutil, as follows (I just picked a random one from my build directory).

D:\src\llvmbuild\ninja-x64>bin\llvm-pdbutil.exe dump -types bin\sancov.pdb | grep -A 2 LF_STRUCT | more
    0x1001 | LF_STRUCTURE [size = 88] ``anonymous-namespace'::RawCoverage`
             unique name: `.?AURawCoverage@?A0xa74cdb40@@`
             vtable: <no type>, base list: <no type>, field list: <no type>
--
    0x100A | LF_STRUCTURE [size = 212] `std::default_delete<std::set<unsigned __int64,std::less<unsigned __int64>,std::allocator<unsigned __int64> > >`
             unique name: `.?AU?$default_delete@V?$set@_KU?$less@_K@std@@V?$allocator@_K@2@@std@@@std@@`
             vtable: <no type>, base list: <no type>, field list: <no type>
--
    0x102B | LF_STRUCTURE [size = 88] ``anonymous-namespace'::FileHeader`
             unique name: `.?AUFileHeader@?A0xa74cdb40@@`
             vtable: <no type>, base list: <no type>, field list: <no type>
--
    0x1031 | LF_STRUCTURE [size = 112] `std::default_delete<llvm::MemoryBuffer>`
             unique name: `.?AU?$default_delete@VMemoryBuffer@llvm@@@std@@`
             vtable: <no type>, base list: <no type>, field list: <no type>
--
    0x1081 | LF_STRUCTURE [size = 304] `llvm::AlignedCharArrayUnion<std::unique_ptr<llvm::MemoryBuffer,std::default_delete<llvm::MemoryBuffer> >,char,char,char,char,char,char,char,char,char>`
             unique name: `.?AU?$AlignedCharArrayUnion@V?$unique_ptr@VMemoryBuffer@llvm@@U?$default_delete@VMemoryBuffer@llvm@@@std@@@std@@DDDDDDDDD@llvm@@`
             vtable: <no type>, base list: <no type>, field list: <no type>
--
    0x1082 | LF_STRUCTURE [size = 176] `llvm::AlignedCharArrayUnion<std::error_code,char,char,char,char,char,char,char,char,char>`
             unique name: `.?AU?$AlignedCharArrayUnion@Verror_code@std@@DDDDDDDDD@llvm@@`
             vtable: <no type>, base list: <no type>, field list: <no type>

So the interesting thing here is this "unique name" field. This is not possible to access via DIA SDK but it gives us complete rich information about the type that is otherwise impossible. We don't even have to guess, because we can just demangle the name. And coincidentally, I recently just finished writing an Microsoft ABI demangler which is now in LLVM. :) This .?AU syntax is non-standard, but it was easy for me to figure out, and I hacked up our demangle library to support this prefix (it's not checked in yet). And basically everything that comes after it exactly matches a mangled type.

So, just to give an example. Instead of teaching CPlusPlusNameParser to handle `anonymous namespace'::RawCoverage, we simply demangle .?AURawCoverage@?A0xa74cdb40@@, and we get back a vector of 2 strings which are `anonymous namespace' and RawCoverage. But instead of just that, there are so many other benefits. Since PDB doesn't contain rich information about template parameters, all we could do until now is just say create an entry in the AST that says "there's a type with this enormously long name that contains angle brackets and other junk". But with this technique, we could actually create legitimate template decls in the AST the way it's supposed to be.

There is obviously a lot of complexity in doing it here, but I think long term it will be a richer experience if we parse the mangled name than if we parse the demangled name. But it's only possible with the native plugin.

What do you think?

[aleksandr.urakov]

In D52461#1281742, @zturner wrote:

What do you think?

Yes, it's a really cool idea! When I was starting the implementation of the parser from this patch, I thought that it would be good to have mangled names instead - then we could retrieve fully structured names (with all its scope specifiers, template parameters etc.), but I didn't know that we actually have them on the lower level!

I want to join the development of the new PDB plugin, but some time later - may be in a month or two. I want to contribute now all changes I made to support expressions on Windows, and then I have some LLVM unrelated work to do. But I think that the way you suggest to solve the problem from the patch is the really right way to do it, and I'm planning to implement it when I'll join the new plugin development.

But is the MSVC demangled names parsing really necessary for CPlusPlusLanguage? Can such names ever somehow occur there? May be (if they can't) we could move this parser back to the old PDB plugin, and then drop it as a weirder solution when the new plugin will be done? Then we could commit this as a solution for the old PDB plugin to proceed with some dependent (and not related to the old PDB plugin) patches?

[labath]

It's not fully clear to me from the previous comments if you are proceeding with this or not, but in case you are, I have made comments inline. I see that you've added some lit tests, but I also think you it would be good add some unit tests for the name parser functionality per-se (similar to the existing name parsing tests), as it is much easier to see what is going on from those.

Right now, I don't think this solution can be specific to the "old" PDB plugin, as this functionality is used from other places as well (RichManglingContext being the most important one). Maybe once we start using the fancy MSVC demangler there, we can revisit that. (But given that the declared intent of that class is to chop up demangled names, I think it would make sense to keep this there even then. Unless it turns out we can delete the whole class at that point.)

source/Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.cpp

63–65

Rewrite this (and all other instances of StringRef -> char * -> StringRef roundtripping) in terms of StringRef functions.
Maybe something like: emplace_back(name.take_front(i-1), name.slice(last_base_start, i-1)); ?

source/Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h

36–40

Could we replace these by something like ArrayRef<MSVCUndecoratedNameSpecifier> GetSpecifiers()

[aleksandr.urakov]

Thank you for comments! I've updated the patch.

[labath]

Thanks for your patience. This looks good to me now.

[aleksandr.urakov]

Thank you!

lit/SymbolFile/PDB/Inputs/AstRestoreTest.cpp

private:
   };
 
   int PrivateFunc(const Inner &i) const { return i.z; }
 
   Inner m_inner{};
 };
 int Class::ClassStatic = 7;
 
-void foo() { Class::StaticFunc(Class(Enum_0)); }
+template<typename T>
+struct Template {
+  template<Enum E>
+  void TemplateFunc() {
+    T::StaticFunc(T(E));
+  }
+};
+
+void foo() { Template<Class>().TemplateFunc<Enum_0>(); }
 
 } // namespace N1
 } // namespace N0
 
 int main() {
   N0::N1::foo();
   return 0;
 }

lit/SymbolFile/PDB/ast-restore.test

 REQUIRES: windows
 RUN: cl /Zi /GS- /c %S/Inputs/AstRestoreTest.cpp /Fo%t.obj
 RUN: link /debug:full /nodefaultlib /entry:main %t.obj /out:%t.exe
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=ENUM %s
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=GLOBAL %s
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=BASE %s
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=CLASS %s
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=INNER %s
+RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=TEMPLATE %s
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=FOO %s
 RUN: lldb-test symbols -dump-ast %t.exe | FileCheck --check-prefix=MAIN %s
 
 ENUM: Module: {{.*}}
 ENUM: namespace N0 {
 ENUM:     namespace N1 {
 ENUM:         namespace  {
 ENUM:             enum Enum {

 INNER:                 char x;
 INNER:                 short y;
 INNER:                 int z;
 INNER:             };
 INNER:         };
 INNER:     }
 INNER: }
 
+TEMPLATE: Module: {{.*}}
+TEMPLATE: struct Template<N0::N1::Class> {
+TEMPLATE:     inline void TemplateFunc<1>();
+TEMPLATE: };
+
 FOO: Module: {{.*}}
 FOO: namespace N0 {
 FOO:     namespace N1 {
 FOO:         void foo();
 FOO:     }
 FOO: }
 
 MAIN: Module: {{.*}}
 MAIN: int main();

source/Plugins/Language/CPlusPlus/CMakeLists.txt

add_lldb_library(lldbPluginCPlusPlusLanguage PLUGIN
   LibCxxQueue.cpp
   LibCxxTuple.cpp
   LibCxxUnorderedMap.cpp
   LibCxxVariant.cpp
   LibCxxVector.cpp
   LibStdcpp.cpp
   LibStdcppTuple.cpp
   LibStdcppUniquePointer.cpp
+  MSVCUndecoratedNameParser.cpp
 
   LINK_LIBS
     lldbCore
     lldbDataFormatters
     lldbHost
     lldbSymbol
     lldbTarget
     lldbUtility
     lldbPluginClangCommon
 
   LINK_COMPONENTS
     Support
 )

source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

 
 #include "BlockPointer.h"
 #include "CPlusPlusNameParser.h"
 #include "CxxStringTypes.h"
 #include "LibCxx.h"
 #include "LibCxxAtomic.h"
 #include "LibCxxVariant.h"
 #include "LibStdcpp.h"
+#include "MSVCUndecoratedNameParser.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 void CPlusPlusLanguage::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), "C++ Language",
                                 CreateInstance);
bool CPlusPlusLanguage::IsCPPMangledName(const char *name) {
   if (name[0] == '?')
     return true;
 
   return (name[0] != '\0' && name[0] == '_' && name[1] == 'Z');
 }
 
 bool CPlusPlusLanguage::ExtractContextAndIdentifier(
     const char *name, llvm::StringRef &context, llvm::StringRef &identifier) {
+  if (MSVCUndecoratedNameParser::IsMSVCUndecoratedName(name))
+    return MSVCUndecoratedNameParser::ExtractContextAndIdentifier(name, context,
+                                                                  identifier);
+
   CPlusPlusNameParser parser(name);
   if (auto full_name = parser.ParseAsFullName()) {
     identifier = full_name.getValue().basename;
     context = full_name.getValue().context;
     return true;
   }
   return false;
 }

source/Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h

+//===-- MSVCUndecoratedNameParser.h -----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_MSVCUndecoratedNameParser_h_
+#define liblldb_MSVCUndecoratedNameParser_h_
+
+#include <vector>
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+
+class MSVCUndecoratedNameSpecifier {
+public:
+  MSVCUndecoratedNameSpecifier(llvm::StringRef full_name,
+                               llvm::StringRef base_name)
+      : m_full_name(full_name), m_base_name(base_name) {}
+
+  llvm::StringRef GetFullName() const { return m_full_name; }
+  llvm::StringRef GetBaseName() const { return m_base_name; }
+
+private:
+  llvm::StringRef m_full_name;
+  llvm::StringRef m_base_name;
+};
+
+class MSVCUndecoratedNameParser {
+public:
+  explicit MSVCUndecoratedNameParser(llvm::StringRef name);
+
+  llvm::ArrayRef<MSVCUndecoratedNameSpecifier> GetSpecifiers() const {
+    return m_specifiers;
+  }
+
+  static bool IsMSVCUndecoratedName(llvm::StringRef name);
+  static bool ExtractContextAndIdentifier(llvm::StringRef name,
+                                          llvm::StringRef &context,
+                                          llvm::StringRef &identifier);
+
+  static llvm::StringRef DropScope(llvm::StringRef name);
+
+private:
+  std::vector<MSVCUndecoratedNameSpecifier> m_specifiers;
+};
+
+#endif

source/Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.cpp

+//===-- MSVCUndecoratedNameParser.cpp ---------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "MSVCUndecoratedNameParser.h"
+
+#include <stack>
+
+MSVCUndecoratedNameParser::MSVCUndecoratedNameParser(llvm::StringRef name) {
+  std::size_t last_base_start = 0;
+
+  std::stack<std::size_t> stack;
+  unsigned int open_angle_brackets = 0;
+  for (size_t i = 0; i < name.size(); i++) {
+    switch (name[i]) {
+    case '<':
+      // Do not treat `operator<' and `operator<<' as templates
+      // (sometimes they represented as `<' and `<<' in the name).
+      if (i == last_base_start ||
+          i == last_base_start + 1 && name[last_base_start] == '<')
+        break;
+
+      stack.push(i);
+      open_angle_brackets++;
+
+      break;
+    case '>':
+      if (!stack.empty() && name[stack.top()] == '<') {
+        open_angle_brackets--;
+        stack.pop();
+      }
+
+      break;
+    case '`':
+      stack.push(i);
+
+      break;
+    case '\'':
+      while (!stack.empty()) {
+        std::size_t top = stack.top();
+        if (name[top] == '<')
+          open_angle_brackets--;
+
+        stack.pop();
+
+        if (name[top] == '`')
+          break;
+      }
+
+      break;
+    case ':':
+      if (open_angle_brackets)
+        break;
+      if (i == 0 || name[i - 1] != ':')
+        break;
+
+      m_specifiers.emplace_back(name.take_front(i - 1),
+                                name.slice(last_base_start, i - 1));
+
+      last_base_start = i + 1;
+    default:
+      break;
+    }
+  }
+
+  m_specifiers.emplace_back(name, name.drop_front(last_base_start));
+}
+
+bool MSVCUndecoratedNameParser::IsMSVCUndecoratedName(llvm::StringRef name) {
+  return name.find('`') != llvm::StringRef::npos;
+}
+
+bool MSVCUndecoratedNameParser::ExtractContextAndIdentifier(
+    llvm::StringRef name, llvm::StringRef &context,
+    llvm::StringRef &identifier) {
+  MSVCUndecoratedNameParser parser(name);
+  llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
+
+  std::size_t count = specs.size();
+  identifier = count > 0 ? specs[count - 1].GetBaseName() : "";
+  context = count > 1 ? specs[count - 2].GetFullName() : "";
+
+  return count;
+}
+
+llvm::StringRef MSVCUndecoratedNameParser::DropScope(llvm::StringRef name) {
+  MSVCUndecoratedNameParser parser(name);
+  llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
+  if (specs.empty())
+    return "";
+
+  return specs[specs.size() - 1].GetBaseName();
+}

source/Plugins/SymbolFile/PDB/PDBASTParser.h

public:
 
   clang::NamespaceDecl *FindNamespaceDecl(const clang::DeclContext *parent,
                                           llvm::StringRef name);
 
   lldb_private::ClangASTImporter &GetClangASTImporter() {
     return m_ast_importer;
   }
 
-  static std::string PDBNameDropScope(const std::string &name);
-
 private:
   typedef llvm::DenseMap<clang::CXXRecordDecl *, lldb::user_id_t>
       CXXRecordDeclToUidMap;
   typedef llvm::DenseMap<lldb::user_id_t, clang::Decl *> UidToDeclMap;
   typedef llvm::DenseMap<clang::DeclContext *, std::set<clang::NamespaceDecl *>>
       ParentToNamespacesMap;
   typedef llvm::DenseMap<clang::DeclContext *, lldb::user_id_t>
       DeclContextToUidMap;
private:
   void
   AddRecordBases(lldb_private::SymbolFile &symbol_file,
                  lldb_private::CompilerType &record_type, int record_kind,
                  PDBBaseClassSymbolEnumerator &bases_enum,
                  lldb_private::ClangASTImporter::LayoutInfo &layout_info) const;
   void AddRecordMethods(lldb_private::SymbolFile &symbol_file,
                         lldb_private::CompilerType &record_type,
                         PDBFuncSymbolEnumerator &methods_enum);
+  clang::CXXMethodDecl *
+  AddRecordMethod(lldb_private::SymbolFile &symbol_file,
+                  lldb_private::CompilerType &record_type,
+                  const llvm::pdb::PDBSymbolFunc &method) const;
 
   lldb_private::ClangASTContext &m_ast;
   lldb_private::ClangASTImporter m_ast_importer;
 
   CXXRecordDeclToUidMap m_forward_decl_to_uid;
   UidToDeclMap m_uid_to_decl;
   ParentToNamespacesMap m_parent_to_namespaces;
   DeclContextToUidMap m_decl_context_to_uid;
 };
 
 #endif // LLDB_PLUGINS_SYMBOLFILE_PDB_PDBASTPARSER_H

source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

 #include "llvm/DebugInfo/PDB/PDBSymbolTypeBuiltin.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionArg.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeFunctionSig.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypePointer.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
 
+#include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::pdb;
 
 static int TranslateUdtKind(PDB_UdtType pdb_kind) {
   switch (pdb_kind) {
   case PDB_UdtType::Class:
     return clang::TTK_Class;
GetDeclFromContextByName(const clang::ASTContext &ast,
   clang::DeclarationName decl_name = ast.DeclarationNames.getIdentifier(&ident);
   clang::DeclContext::lookup_result result = decl_context.lookup(decl_name);
   if (result.empty())
     return nullptr;
 
   return result[0];
 }
 
-static bool IsAnonymousNamespaceName(const std::string &name) {
+static bool IsAnonymousNamespaceName(llvm::StringRef name) {
   return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
 }
 
 static clang::CallingConv TranslateCallingConvention(PDB_CallingConv pdb_cc) {
   switch (pdb_cc) {
   case llvm::codeview::CallingConvention::NearC:
     return clang::CC_C;
   case llvm::codeview::CallingConvention::NearStdCall:
case PDB_SymType::UDT: {
     //    union Union { short Row; short Col; }
     // Such symbols will be handled here.
 
     // Some UDT with trival ctor has zero length. Just ignore.
     if (udt->getLength() == 0)
       return nullptr;
 
     // Ignore unnamed-tag UDTs.
-    auto name = PDBNameDropScope(udt->getName());
+    std::string name = MSVCUndecoratedNameParser::DropScope(udt->getName());
     if (name.empty())
       return nullptr;
 
     auto decl_context = GetDeclContextContainingSymbol(type);
 
     // Check if such an UDT already exists in the current context.
     // This may occur with const or volatile types. There are separate type
     // symbols in PDB for types with const or volatile modifiers, but we need
return std::make_shared<lldb_private::Type>(
         udt->getLength(), nullptr, LLDB_INVALID_UID,
         lldb_private::Type::eEncodingIsUID, decl, clang_type,
         type_resolve_state_tag);
   } break;
   case PDB_SymType::Enum: {
     auto enum_type = llvm::dyn_cast<PDBSymbolTypeEnum>(&type);
     assert(enum_type);
 
-    std::string name = PDBNameDropScope(enum_type->getName());
+    std::string name =
+        MSVCUndecoratedNameParser::DropScope(enum_type->getName());
     auto decl_context = GetDeclContextContainingSymbol(type);
     uint64_t bytes = enum_type->getLength();
 
     // Check if such an enum already exists in the current context
     CompilerType ast_enum = m_ast.GetTypeForIdentifier<clang::EnumDecl>(
         ConstString(name), decl_context);
     if (!ast_enum.IsValid()) {
       auto underlying_type_up = enum_type->getUnderlyingType();
case PDB_SymType::Typedef: {
     auto type_def = llvm::dyn_cast<PDBSymbolTypeTypedef>(&type);
     assert(type_def);
 
     lldb_private::Type *target_type =
         m_ast.GetSymbolFile()->ResolveTypeUID(type_def->getTypeId());
     if (!target_type)
       return nullptr;
 
-    std::string name = PDBNameDropScope(type_def->getName());
+    std::string name =
+        MSVCUndecoratedNameParser::DropScope(type_def->getName());
     auto decl_ctx = GetDeclContextContainingSymbol(type);
 
     // Check if such a typedef already exists in the current context
     CompilerType ast_typedef =
         m_ast.GetTypeForIdentifier<clang::TypedefNameDecl>(ConstString(name),
                                                            decl_ctx);
     if (!ast_typedef.IsValid()) {
       CompilerType target_ast_type = target_type->GetFullCompilerType();
if (auto pdb_func = llvm::dyn_cast<PDBSymbolFunc>(&type)) {
       if (pdb_func->isCompilerGenerated())
         return nullptr;
 
       auto sig = pdb_func->getSignature();
       if (!sig)
         return nullptr;
       func_sig = sig.release();
       // Function type is named.
-      name = PDBNameDropScope(pdb_func->getName());
+      name = MSVCUndecoratedNameParser::DropScope(pdb_func->getName());
     } else if (auto pdb_func_sig =
                    llvm::dyn_cast<PDBSymbolTypeFunctionSig>(&type)) {
       func_sig = const_cast<PDBSymbolTypeFunctionSig *>(pdb_func_sig);
     } else
       llvm_unreachable("Unexpected PDB symbol!");
 
     auto arg_enum = func_sig->getArguments();
     uint32_t num_args = arg_enum->getChildCount();
bool PDBASTParser::CompleteTypeFromPDB(
   }
   default:
     llvm_unreachable("not a forward clang type decl!");
   }
 }
 
 clang::Decl *
 PDBASTParser::GetDeclForSymbol(const llvm::pdb::PDBSymbol &symbol) {
-  auto it = m_uid_to_decl.find(symbol.getSymIndexId());
+  uint32_t sym_id = symbol.getSymIndexId();
+  auto it = m_uid_to_decl.find(sym_id);
   if (it != m_uid_to_decl.end())
     return it->second;
 
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
     return nullptr;
 
   // First of all, check if the symbol is a member of a class. Resolve the full
   // class type and return the declaration from the cache if so.
   auto tag = symbol.getSymTag();
   if (tag == PDB_SymType::Data || tag == PDB_SymType::Function) {
     const IPDBSession &session = symbol.getSession();
     const IPDBRawSymbol &raw = symbol.getRawSymbol();
 
     auto class_parent_id = raw.getClassParentId();
-    if (session.getSymbolById(class_parent_id)) {
+    if (std::unique_ptr<PDBSymbol> class_parent =
+            session.getSymbolById(class_parent_id)) {
       auto class_parent_type = symbol_file->ResolveTypeUID(class_parent_id);
       if (!class_parent_type)
         return nullptr;
 
-      class_parent_type->GetFullCompilerType();
+      CompilerType class_parent_ct = class_parent_type->GetFullCompilerType();
+
+      // Look a declaration up in the cache after completing the class
+      clang::Decl *decl = m_uid_to_decl.lookup(sym_id);
+      if (decl)
+        return decl;
 
-      return m_uid_to_decl.lookup(symbol.getSymIndexId());
+      // A declaration was not found in the cache. It means that the symbol
+      // has the class parent, but the class doesn't have the symbol in its
+      // children list.
+      if (auto func = llvm::dyn_cast_or_null<PDBSymbolFunc>(&symbol)) {
+        // Try to find a class child method with the same RVA and use its
+        // declaration if found.
+        if (uint32_t rva = func->getRelativeVirtualAddress()) {
+          if (std::unique_ptr<ConcreteSymbolEnumerator<PDBSymbolFunc>>
+                  methods_enum =
+                      class_parent->findAllChildren<PDBSymbolFunc>()) {
+            while (std::unique_ptr<PDBSymbolFunc> method =
+                       methods_enum->getNext()) {
+              if (method->getRelativeVirtualAddress() == rva) {
+                decl = m_uid_to_decl.lookup(method->getSymIndexId());
+                if (decl)
+                  break;
+              }
+            }
+          }
+        }
+
+        // If no class methods with the same RVA were found, then create a new
+        // method. It is possible for template methods.
+        if (!decl)
+          decl = AddRecordMethod(*symbol_file, class_parent_ct, *func);
+      }
+
+      if (decl)
+        m_uid_to_decl[sym_id] = decl;
+
+      return decl;
     }
   }
 
   // If we are here, then the symbol is not belonging to a class and is not
   // contained in the cache. So create a declaration for it.
   switch (symbol.getSymTag()) {
   case PDB_SymType::Data: {
     auto data = llvm::dyn_cast<PDBSymbolData>(&symbol);
     assert(data);
 
     auto decl_context = GetDeclContextContainingSymbol(symbol);
     assert(decl_context);
 
     // May be the current context is a class really, but we haven't found
     // any class parent. This happens e.g. in the case of class static
     // variables - they has two symbols, one is a child of the class when
     // another is a child of the exe. So always complete the parent and use
     // an existing declaration if possible.
     if (auto parent_decl = llvm::dyn_cast_or_null<clang::TagDecl>(decl_context))
       m_ast.GetCompleteDecl(parent_decl);
 
-    auto name = PDBNameDropScope(data->getName());
+    std::string name = MSVCUndecoratedNameParser::DropScope(data->getName());
 
     // Check if the current context already contains the symbol with the name.
     clang::Decl *decl =
         GetDeclFromContextByName(*m_ast.getASTContext(), *decl_context, name);
     if (!decl) {
       auto type = symbol_file->ResolveTypeUID(data->getTypeId());
       if (!type)
         return nullptr;
 
       decl = m_ast.CreateVariableDeclaration(
           decl_context, name.c_str(),
           ClangUtil::GetQualType(type->GetLayoutCompilerType()));
     }
 
-    m_uid_to_decl[data->getSymIndexId()] = decl;
+    m_uid_to_decl[sym_id] = decl;
 
     return decl;
   }
   case PDB_SymType::Function: {
     auto func = llvm::dyn_cast<PDBSymbolFunc>(&symbol);
     assert(func);
 
     auto decl_context = GetDeclContextContainingSymbol(symbol);
     assert(decl_context);
 
-    auto name = PDBNameDropScope(func->getName());
+    std::string name = MSVCUndecoratedNameParser::DropScope(func->getName());
 
-    auto type = symbol_file->ResolveTypeUID(func->getSymIndexId());
+    Type *type = symbol_file->ResolveTypeUID(sym_id);
     if (!type)
       return nullptr;
 
     auto storage = func->isStatic() ? clang::StorageClass::SC_Static
                                     : clang::StorageClass::SC_None;
 
     auto decl = m_ast.CreateFunctionDeclaration(
         decl_context, name.c_str(), type->GetForwardCompilerType(), storage,
         func->hasInlineAttribute());
 
-    m_uid_to_decl[func->getSymIndexId()] = decl;
+    m_uid_to_decl[sym_id] = decl;
 
     return decl;
   }
   default: {
     // It's not a variable and not a function, check if it's a type
-    auto type = symbol_file->ResolveTypeUID(symbol.getSymIndexId());
+    Type *type = symbol_file->ResolveTypeUID(sym_id);
     if (!type)
       return nullptr;
 
-    return m_uid_to_decl.lookup(symbol.getSymIndexId());
+    return m_uid_to_decl.lookup(sym_id);
   }
   }
 }
 
 clang::DeclContext *
 PDBASTParser::GetDeclContextForSymbol(const llvm::pdb::PDBSymbol &symbol) {
   if (symbol.getSymTag() == PDB_SymType::Function) {
     clang::DeclContext *result =
if (auto parent_context = GetDeclContextForSymbol(*parent))
       return parent_context;
 
     parent = GetClassOrFunctionParent(*parent);
   }
 
   // We can't find any class or function parent of the symbol. So analyze
   // the full symbol name. The symbol may be belonging to a namespace
   // or function (or even to a class if it's e.g. a static variable symbol).
-  // We do not use CPlusPlusNameParser because it fails on things like
-  // `anonymous namespace'.
 
   // TODO: Make clang to emit full names for variables in namespaces
   // (as MSVC does)
 
-  auto context = symbol.getRawSymbol().getName();
-  auto context_size = context.rfind("::");
-  if (context_size == std::string::npos)
-    context_size = 0;
-  context = context.substr(0, context_size);
-
-  // Check if there is a symbol with the name of the context.
+  std::string name(symbol.getRawSymbol().getName());
+  MSVCUndecoratedNameParser parser(name);
+  llvm::ArrayRef<MSVCUndecoratedNameSpecifier> specs = parser.GetSpecifiers();
+  if (specs.empty())
+    return m_ast.GetTranslationUnitDecl();
 
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
   if (!symbol_file)
     return m_ast.GetTranslationUnitDecl();
 
   auto global = symbol_file->GetPDBSession().getGlobalScope();
   if (!global)
     return m_ast.GetTranslationUnitDecl();
 
-  TypeMap types;
-  if (auto children_enum =
-          global->findChildren(PDB_SymType::None, context, NS_CaseSensitive))
-    while (auto child = children_enum->getNext())
-      if (auto child_context = GetDeclContextForSymbol(*child))
-        return child_context;
-
-  // Split context and retrieve nested namespaces
+  bool has_type_or_function_parent = false;
   auto curr_context = m_ast.GetTranslationUnitDecl();
-  std::string::size_type from = 0;
-  while (from < context_size) {
-    auto to = context.find("::", from);
-    if (to == std::string::npos)
-      to = context_size;
-
-    auto namespace_name = context.substr(from, to - from);
-    auto namespace_name_c_str = IsAnonymousNamespaceName(namespace_name)
-                                    ? nullptr
-                                    : namespace_name.c_str();
-    auto namespace_decl =
-        m_ast.GetUniqueNamespaceDeclaration(namespace_name_c_str, curr_context);
+  for (std::size_t i = 0; i < specs.size() - 1; i++) {
+    // Check if there is a function or a type with the current context's name.
+    if (std::unique_ptr<IPDBEnumSymbols> children_enum = global->findChildren(
+            PDB_SymType::None, specs[i].GetFullName(), NS_CaseSensitive)) {
+      while (IPDBEnumChildren<PDBSymbol>::ChildTypePtr child =
+                 children_enum->getNext()) {
+        if (clang::DeclContext *child_context =
+                GetDeclContextForSymbol(*child)) {
+          // Note that `GetDeclContextForSymbol' retrieves
+          // a declaration context for functions and types only,
+          // so if we are here then `child_context' is guaranteed
+          // a function or a type declaration context.
+          has_type_or_function_parent = true;
+          curr_context = child_context;
+        }
+      }
+    }
+
+    // If there were no functions or types above then retrieve a namespace with
+    // the current context's name. There can be no namespaces inside a function
+    // or a type. We check it to avoid fake namespaces such as `__l2':
+    // `N0::N1::CClass::PrivateFunc::__l2::InnerFuncStruct'
+    if (!has_type_or_function_parent) {
+      std::string namespace_name = specs[i].GetBaseName();
+      const char *namespace_name_c_str =
+          IsAnonymousNamespaceName(namespace_name) ? nullptr
+                                                   : namespace_name.data();
+      clang::NamespaceDecl *namespace_decl =
+          m_ast.GetUniqueNamespaceDeclaration(namespace_name_c_str,
+                                              curr_context);
 
       m_parent_to_namespaces[curr_context].insert(namespace_decl);
 
       curr_context = namespace_decl;
-    from = to + 2;
+    }
   }
 
   return curr_context;
 }
 
 void PDBASTParser::ParseDeclsForDeclContext(
     const clang::DeclContext *decl_context) {
   auto symbol_file = static_cast<SymbolFilePDB *>(m_ast.GetSymbolFile());
PDBASTParser::FindNamespaceDecl(const clang::DeclContext *parent,
 
   for (auto namespace_decl : it->second)
     if (namespace_decl->isAnonymousNamespace())
       return FindNamespaceDecl(namespace_decl, name);
 
   return nullptr;
 }
 
-std::string PDBASTParser::PDBNameDropScope(const std::string &name) {
-  // Not all PDB names can be parsed with CPlusPlusNameParser.
-  // E.g. it fails on names containing `anonymous namespace'.
-  // So we simply drop everything before '::'
-
-  auto offset = name.rfind("::");
-  if (offset == std::string::npos)
-    return name;
-  assert(offset + 2 <= name.size());
-
-  return name.substr(offset + 2);
-}
-
 bool PDBASTParser::AddEnumValue(CompilerType enum_type,
                                 const PDBSymbolData &enum_value) {
   Declaration decl;
   Variant v = enum_value.getValue();
-  std::string name = PDBNameDropScope(enum_value.getName());
+  std::string name = MSVCUndecoratedNameParser::DropScope(enum_value.getName());
   int64_t raw_value;
   switch (v.Type) {
   case PDB_VariantType::Int8:
     raw_value = v.Value.Int8;
     break;
   case PDB_VariantType::Int16:
     raw_value = v.Value.Int16;
     break;
void PDBASTParser::AddRecordBases(
 
   m_ast.TransferBaseClasses(record_type.GetOpaqueQualType(),
                             std::move(base_classes));
 }
 
 void PDBASTParser::AddRecordMethods(lldb_private::SymbolFile &symbol_file,
                                     lldb_private::CompilerType &record_type,
                                     PDBFuncSymbolEnumerator &methods_enum) {
-  while (auto method = methods_enum.getNext()) {
-    auto name = PDBNameDropScope(method->getName().c_str());
+  while (std::unique_ptr<PDBSymbolFunc> method = methods_enum.getNext())
+    if (clang::CXXMethodDecl *decl =
+            AddRecordMethod(symbol_file, record_type, *method))
+      m_uid_to_decl[method->getSymIndexId()] = decl;
+}
 
-    auto method_type = symbol_file.ResolveTypeUID(method->getSymIndexId());
-    // MSVC specific __vecDelDtor.
-    if (!method_type)
-      continue;
+clang::CXXMethodDecl *
+PDBASTParser::AddRecordMethod(lldb_private::SymbolFile &symbol_file,
+                              lldb_private::CompilerType &record_type,
+                              const llvm::pdb::PDBSymbolFunc &method) const {
+  std::string name = MSVCUndecoratedNameParser::DropScope(method.getName());
+
+  Type *method_type = symbol_file.ResolveTypeUID(method.getSymIndexId());
+    return nullptr;
 
-    auto method_comp_type = method_type->GetFullCompilerType();
-    if (!method_comp_type.GetCompleteType()) {
-      symbol_file.GetObjectFile()->GetModule()->ReportError(
-          ":: Class '%s' has a method '%s' whose type cannot be completed.",
-          record_type.GetTypeName().GetCString(),
-          method_comp_type.GetTypeName().GetCString());
-      if (ClangASTContext::StartTagDeclarationDefinition(method_comp_type))
-        ClangASTContext::CompleteTagDeclarationDefinition(method_comp_type);
-    }
+  CompilerType method_comp_type = method_type->GetFullCompilerType();
 
-    // TODO: get mangled name for the method.
-    auto decl = m_ast.AddMethodToCXXRecordType(
-        record_type.GetOpaqueQualType(), name.c_str(),
-        /*mangled_name*/ nullptr, method_comp_type,
-        TranslateMemberAccess(method->getAccess()), method->isVirtual(),
-        method->isStatic(), method->hasInlineAttribute(),
-        /*is_explicit*/ false, // FIXME: Need this field in CodeView.
-        /*is_attr_used*/ false,
-        /*is_artificial*/ method->isCompilerGenerated());
-    if (!decl)
-      continue;
-
-    m_uid_to_decl[method->getSymIndexId()] = decl;
-  }
+  AccessType access = TranslateMemberAccess(method.getAccess());
+  if (access == eAccessNone)
+    access = eAccessPublic;
+
+  return m_ast.AddMethodToCXXRecordType(
+      /*mangled_name*/ nullptr, method_comp_type, access, method.isVirtual(),
+      method.isStatic(), method.hasInlineAttribute(),
+      /*is_artificial*/ method.isCompilerGenerated());
 }

source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

private:
 
   bool ParseCompileUnitLineTable(const lldb_private::SymbolContext &sc,
                                  uint32_t match_line);
 
   void BuildSupportFileIdToSupportFileIndexMap(
       const llvm::pdb::PDBSymbolCompiland &pdb_compiland,
       llvm::DenseMap<uint32_t, uint32_t> &index_map) const;
 
-  void FindTypesByName(const std::string &name,
+  void FindTypesByName(llvm::StringRef name,
                        const lldb_private::CompilerDeclContext *parent_decl_ctx,
                        uint32_t max_matches, lldb_private::TypeMap &types);
 
   std::string GetMangledForPDBData(const llvm::pdb::PDBSymbolData &pdb_data);
 
   lldb::VariableSP
   ParseVariableForPDBData(const lldb_private::SymbolContext &sc,
                           const llvm::pdb::PDBSymbolData &pdb_data);

source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

 //===-- SymbolFilePDB.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFilePDB.h"
 
+#include "PDBASTParser.h"
+#include "PDBLocationToDWARFExpression.h"
+
 #include "clang/Lex/Lexer.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"

 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugEnd.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolFuncDebugStart.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolPublicSymbol.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeEnum.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeTypedef.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolTypeUDT.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h" // For IsCPPMangledName
+#include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
 #include "Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h"
-#include "Plugins/SymbolFile/PDB/PDBASTParser.h"
-#include "Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.h"
 
 #include <regex>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::pdb;
 
 namespace {
while (auto result = results->getNext()) {
     if (max_matches > 0 && matches >= max_matches)
       break;
 
     SymbolContext sc;
     sc.module_sp = m_obj_file->GetModule();
     lldbassert(sc.module_sp.get());
 
     if (!name.GetStringRef().equals(
-            PDBASTParser::PDBNameDropScope(pdb_data->getName())))
+            MSVCUndecoratedNameParser::DropScope(pdb_data->getName())))
       continue;
 
     sc.comp_unit = ParseCompileUnitForUID(GetCompilandId(*pdb_data)).get();
     // FIXME: We are not able to determine the compile unit.
     if (sc.comp_unit == nullptr)
       continue;
 
     auto actual_parent_decl_ctx =
while (auto pdb_func_up = results_up->getNext()) {
         addr_ids.insert(std::make_pair(pdb_func_up->getVirtualAddress(), uid));
 
       if (auto parent = pdb_func_up->getClassParent()) {
 
         // PDB have symbols for class/struct methods or static methods in Enum
         // Class. We won't bother to check if the parent is UDT or Enum here.
         m_func_method_names.Append(ConstString(name), uid);
 
-        ConstString cstr_name(name);
-
         // To search a method name, like NS::Class:MemberFunc, LLDB searches
         // its base name, i.e. MemberFunc by default. Since PDBSymbolFunc does
         // not have inforamtion of this, we extract base names and cache them
         // by our own effort.
-        llvm::StringRef basename;
-        CPlusPlusLanguage::MethodName cpp_method(cstr_name);
-        if (cpp_method.IsValid()) {
-          llvm::StringRef context;
-          basename = cpp_method.GetBasename();
-          if (basename.empty())
-            CPlusPlusLanguage::ExtractContextAndIdentifier(name.c_str(),
-                                                           context, basename);
-        }
-
+        llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
         if (!basename.empty())
           m_func_base_names.Append(ConstString(basename), uid);
         else {
           m_func_base_names.Append(ConstString(name), uid);
         }
 
         if (!demangled_name.empty())
           m_func_full_names.Append(ConstString(demangled_name), uid);
 
       } else {
         // Handle not-method symbols.
 
-        // The function name might contain namespace, or its lexical scope. It
-        // is not safe to get its base name by applying same scheme as we deal
-        // with the method names.
-        // FIXME: Remove namespace if function is static in a scope.
+        // The function name might contain namespace, or its lexical scope.
+        llvm::StringRef basename = MSVCUndecoratedNameParser::DropScope(name);
+        if (!basename.empty())
+          m_func_base_names.Append(ConstString(basename), uid);
+        else
           m_func_base_names.Append(ConstString(name), uid);
 
         if (name == "main") {
           m_func_full_names.Append(ConstString(name), uid);
 
           if (!demangled_name.empty() && name != demangled_name) {
             m_func_full_names.Append(ConstString(demangled_name), uid);
             m_func_base_names.Append(ConstString(demangled_name), uid);
           }
uint32_t SymbolFilePDB::FindTypes(
   if (!name)
     return 0;
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return 0;
 
   searched_symbol_files.clear();
   searched_symbol_files.insert(this);
 
-  std::string name_str = name.AsCString();
-
   // There is an assumption 'name' is not a regex
-  FindTypesByName(name_str, parent_decl_ctx, max_matches, types);
+  FindTypesByName(name.GetStringRef(), parent_decl_ctx, max_matches, types);
 
   return types.GetSize();
 }
 
 void SymbolFilePDB::FindTypesByRegex(
     const lldb_private::RegularExpression &regex, uint32_t max_matches,
     lldb_private::TypeMap &types) {
   // When searching by regex, we need to go out of our way to limit the search
while (auto result = results->getNext()) {
         continue;
       types.Insert(iter->second);
       ++matches;
     }
   }
 }
 
 void SymbolFilePDB::FindTypesByName(
-    const std::string &name,
+    llvm::StringRef name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx,
     uint32_t max_matches, lldb_private::TypeMap &types) {
   if (!parent_decl_ctx)
     parent_decl_ctx = m_tu_decl_ctx_up.get();
   std::unique_ptr<IPDBEnumSymbols> results;
   if (name.empty())
     return;
   results = m_global_scope_up->findAllChildren(PDB_SymType::None);
   if (!results)
     return;
 
   uint32_t matches = 0;
 
   while (auto result = results->getNext()) {
     if (max_matches > 0 && matches >= max_matches)
       break;
 
-    if (PDBASTParser::PDBNameDropScope(result->getRawSymbol().getName()) !=
-        name)
+    if (MSVCUndecoratedNameParser::DropScope(
+            result->getRawSymbol().getName()) != name)
       continue;
 
     switch (result->getSymTag()) {
     case PDB_SymType::Enum:
     case PDB_SymType::UDT:
     case PDB_SymType::Typedef:
       break;
     default:

unittests/Language/CPlusPlus/CPlusPlusLanguageTest.cpp

TestCase test_cases[] = {
       {"foo01::bar", "foo01", "bar"},
       {"foo::~bar", "foo", "~bar"},
       {"std::vector<int>::push_back", "std::vector<int>", "push_back"},
       {"operator<<(Cls, Cls)::Subclass::function",
        "operator<<(Cls, Cls)::Subclass", "function"},
       {"std::vector<Class, std::allocator<Class>>"
        "::_M_emplace_back_aux<Class const&>",
        "std::vector<Class, std::allocator<Class>>",
-       "_M_emplace_back_aux<Class const&>"}};
+       "_M_emplace_back_aux<Class const&>"},
+      {"`anonymous namespace'::foo", "`anonymous namespace'", "foo"},
+      {"`operator<<A>'::`2'::B<0>::operator>",
+       "`operator<<A>'::`2'::B<0>",
+       "operator>"},
+      {"`anonymous namespace'::S::<<::__l2::Foo",
+       "`anonymous namespace'::S::<<::__l2",
+       "Foo"}};
 
   llvm::StringRef context, basename;
   for (const auto &test : test_cases) {
     EXPECT_TRUE(CPlusPlusLanguage::ExtractContextAndIdentifier(
         test.input.c_str(), context, basename));
     EXPECT_EQ(test.context, context.str());
     EXPECT_EQ(test.basename, basename.str());
   }