[lldb] Add method Language::IsMangledName

[xiaobai]

Summary

Instead of asking each of the language plugins directly if a symbol is a
possible manghled name for that language, we can generalize this
pattern. By adding a method IsMangledName and iterating over each
loaded language plugin, we can avoid referencing any language plugin
directly.

[xiaobai]

I uploaded this patch primarily to get some feedback on possible alternatives because I'm not happy creating a dependency from Core to Target here. Suggestions welcome!

lldb/source/Core/Mangled.cpp

12

Not happy about introducing this dependency. Maybe I can remove the GuessLanguage method from Mangled and add one to Language... something like Language::GuessMangledSymbolLanguage(Mangled mangled)?

[friss]

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

96–98

The original code was calling IsPossibleObjCMethodName and it looks like you completely lose this codepath with this rewrite. Unclear to me if it's the right thing to return here, but that's definitely a change in behavior.

[xiaobai]

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

96–98

If I understand correctly, Objective-C names aren't mangled in general, and are usually stored in the m_demangled name of Mangled, so that code path should have been bogus to begin with. Maybe I'm missing a detail though?

I can add a comment to this to clarify that Objective-C names aren't mangled (if I am correct in my understanding).

[shafik]

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

96–98

I believe this is true, I have not verified it myself. I believe what happens is that m_mangled is just set directly in the Objective-C but it probably would be nice to verify this via a test in MangledTest.cpp I actually though @mib had added a test here for Objective-C the other day.

[friss]

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

96–98

If I understand correctly, Objective-C names aren't mangled in general, and are usually stored in the m_demangled name of Mangled, so that code path should have been bogus to begin with. Maybe I'm missing a detail though?

I'm just pointing out a change in behavior. If a Mangled object had m_mangled set to an Obj-C method name, GuessLanguage() would have returned eLanguageTypeObjC before your patch. It won't do it after. I don't actually know whether we ever put a method name in m_mangled, but I bet we do.

Whether Obj-C symbols are actually mangled or not is debatable too. The name of the method symbol tells you whether it is a class or instance method and the number and names of arguments. Looks pretty close to the information the C++ mangling gives you for a symbol.

[mib]

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

96–98

In D71237, I only added a test for the function.mangled-name frame-format entity with a C++ example.

[kwk]

I agree with @friss that there is a change in behavior. I'm not sure it is fixable with what I wrote but I think so.

lldb/include/lldb/Target/Language.h

191

In Mangled::GuessLanguage() you call this function with if (lang->IsMangledName(mangled.GetCString())). mangled in that case is a ConstString. I wonder why you don't pass that to IsMangledName? Is a StringRef faster? I'm asking because I see GetMethodNameVariants below and that also must be called with a ConstString.

lldb/source/Core/Mangled.cpp

416

In the ObjCLanguage's implementation of IsMangledName() I hope to see a call to sPossibleObjCMethodName. I think that is what @friss is aiming for with D74187#1865342.

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

97

Essentially, just return ObjCLanguage::IsPossibleObjCMethodName(name), no? It is defined only a few lines further down below.

@friss is that what you mean in order to restore the original behavior?

lldb/include/lldb/Target/Language.h

public:
   virtual lldb_private::formatters::StringPrinter::EscapingHelper
       GetStringPrinterEscapingHelper(
           lldb_private::formatters::StringPrinter::GetPrintableElementType);
 
   virtual std::unique_ptr<TypeScavenger> GetTypeScavenger();
 
   virtual const char *GetLanguageSpecificTypeLookupHelp();
 
+  virtual bool IsMangledName(llvm::StringRef name) const = 0;
+
   // If a language can have more than one possible name for a method, this
   // function can be used to enumerate them. This is useful when doing name
   // lookups.
   virtual std::vector<ConstString>
   GetMethodNameVariants(ConstString method_name) const {
     return std::vector<ConstString>();
   };
 

lldb/source/Core/Mangled.cpp

 //===-- Mangled.cpp -------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/Mangled.h"
 
 #include "lldb/Core/RichManglingContext.h"
+#include "lldb/Target/Language.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/lldb-enumerations.h"
 

 // Itanium scheme, and defined in a compilation unit within the same module as
 // other C++ units.  In addition, different targets could have different ways
 // of mangling names from a given language, likewise the compilation units
 // within those targets.
 lldb::LanguageType Mangled::GuessLanguage() const {
   ConstString mangled = GetMangledName();
 
   if (mangled) {
-    const char *mangled_name = mangled.GetCString();
-    if (CPlusPlusLanguage::IsCPPMangledName(mangled_name))
-      return lldb::eLanguageTypeC_plus_plus;
-    else if (ObjCLanguage::IsPossibleObjCMethodName(mangled_name))
-      return lldb::eLanguageTypeObjC;
+    lldb::LanguageType lang_type = lldb::eLanguageTypeUnknown;
+    Language::ForEach([&lang_type, &mangled](Language *lang) {
+      if (lang->IsMangledName(mangled.GetCString())) {
+        lang_type = lang->GetLanguageType();
+        return false; // Break out of ForEach early
+      }
+      return true;
+    });
+    return lang_type;
   } else {
     // ObjC names aren't really mangled, so they won't necessarily be in the
     // mangled name slot.
     ConstString demangled_name = GetDemangledName();
     if (demangled_name 
         && ObjCLanguage::IsPossibleObjCMethodName(demangled_name.GetCString()))
       return lldb::eLanguageTypeObjC;
   

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

public:
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);
 
   static lldb_private::ConstString GetPluginNameStatic();
 
+  bool IsMangledName(llvm::StringRef name) const override;
+
   static bool IsCPPMangledName(llvm::StringRef name);
 
   // Extract C++ context and identifier from a string using heuristic matching
   // (as opposed to
   // CPlusPlusLanguage::MethodName which has to have a fully qualified C++ name
   // with parens and arguments.
   // If the name is a lone C identifier (e.g. C) or a qualified C identifier
   // (e.g. A::B::C) it will return true,

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

std::string CPlusPlusLanguage::MethodName::GetScopeQualifiedName() {
 
   std::string res;
   res += m_context;
   res += "::";
   res += m_basename;
   return res;
 }
 
+bool CPlusPlusLanguage::IsMangledName(llvm::StringRef name) const {
+  return IsCPPMangledName(name);
+}
+
 bool CPlusPlusLanguage::IsCPPMangledName(llvm::StringRef name) {
   // FIXME!! we should really run through all the known C++ Language plugins
   // and ask each one if this is a C++ mangled name
 
   Mangled::ManglingScheme scheme = Mangled::GetManglingScheme(name);
 
   if (scheme == Mangled::eManglingSchemeNone)
     return false;

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

public:
   ObjCLanguage() = default;
 
   ~ObjCLanguage() override = default;
 
   lldb::LanguageType GetLanguageType() const override {
     return lldb::eLanguageTypeObjC;
   }
 
+  bool IsMangledName(llvm::StringRef name) const override {
+    return false;
+  }
+
   // Get all possible names for a method. Examples:
   // If method_name is "+[NSString(my_additions) myStringWithCString:]"
   //   variant_names[0] => "+[NSString myStringWithCString:]"
   // If name is specified without the leading '+' or '-' like
   // "[NSString(my_additions) myStringWithCString:]"
   //  variant_names[0] => "+[NSString(my_additions) myStringWithCString:]"
   //  variant_names[1] => "-[NSString(my_additions) myStringWithCString:]"
   //  variant_names[2] => "+[NSString myStringWithCString:]"

lldb/source/Plugins/Language/ObjCPlusPlus/ObjCPlusPlusLanguage.h

public:
   lldb::LanguageType GetLanguageType() const override {
     return lldb::eLanguageTypeObjC_plus_plus;
   }
 
   bool IsSourceFile(llvm::StringRef file_path) const override;
 
   const Highlighter *GetHighlighter() const override { return &m_highlighter; }
 
+  bool IsMangledName(llvm::StringRef name) const override {
+    // Let the CPlusPlusLanguage plugin answer this
+    return false;
+  }
+
   // Static Functions
   static void Initialize();
 
   static void Terminate();
 
   static lldb_private::Language *CreateInstance(lldb::LanguageType language);
 
   static lldb_private::ConstString GetPluginNameStatic();