[lldb] Add support for D programming language

[ljmf00]

Summary

This is part of https://github.com/dlang/projects/issues/81 .

This patch enables support for D programming language demangler by using a
pretty printed stacktrace with demangled D symbols, when present.

Signed-off-by: Luís Ferreira <[e-mail]>

[JDevlieghere]

LGTM

[teemperor]

Do you have commit access or should someone land this for you?

lldb/include/lldb/Core/Mangled.h

48

Nit which can be fixed when landing (so no need to update this revision): Could we add a trailing comma here just to keep the (future) git blame a bit cleaner once we get patches that add E, F, G, etc. support.

[ljmf00]

In D110578#3027692, @teemperor wrote:

Do you have commit access or should someone land this for you?

I don't have commit access, although this is a stacked revision, so there are some dependent patches.

[teemperor]

In D110578#3027707, @ljmf00 wrote:

In D110578#3027692, @teemperor wrote:

Do you have commit access or should someone land this for you?

I don't have commit access, although this is a stacked revision, so there are some dependent patches.

Alright, feel free to ping then if this is ready to land (or maybe ping the person for the dependent patch to land this too). Thanks!

[ljmf00]

Since D111414 got merged, @teemperor can you land this?

[ljmf00]

@dblaikie Maybe you can land this?

[dblaikie]

In D110578#3123164, @ljmf00 wrote:

@dblaikie Maybe you can land this?

Nah, might need someone with more lldb context than me - I don't seem to have a clean check-lldb build right now (so don't have a good baseline to validate that the patch doesn't regress anything before I commit) & no idea why... :/

[teemperor]

I changed the commit name from "Add support for D programming language" to "[lldb] Add support for demangling D symbols" when landing (which is more accurate).

lldb/include/lldb/Core/Mangled.h

enum NamePreference {
     ePreferDemangled,
     ePreferDemangledWithoutArguments
   };
 
   enum ManglingScheme {
     eManglingSchemeNone = 0,
     eManglingSchemeMSVC,
     eManglingSchemeItanium,
-    eManglingSchemeRustV0
+    eManglingSchemeRustV0,
+    eManglingSchemeD
   };
 
   /// Default constructor.
   ///
   /// Initialize with both mangled and demangled names empty.
   Mangled() = default;
 
   /// Construct with name.

lldb/source/Core/Mangled.cpp

if (name.empty())
     return Mangled::eManglingSchemeNone;
 
   if (name.startswith("?"))
     return Mangled::eManglingSchemeMSVC;
 
   if (name.startswith("_R"))
     return Mangled::eManglingSchemeRustV0;
 
+  if (name.startswith("_D"))
+    return Mangled::eManglingSchemeD;
+
   if (name.startswith("_Z"))
     return Mangled::eManglingSchemeItanium;
 
   // ___Z is a clang extension of block invocations
   if (name.startswith("___Z"))
     return Mangled::eManglingSchemeItanium;
 
   return Mangled::eManglingSchemeNone;
if (demangled_cstr && demangled_cstr[0])
       LLDB_LOG(log, "demangled rustv0: {0} -> \"{1}\"", M, demangled_cstr);
     else
       LLDB_LOG(log, "demangled rustv0: {0} -> error: failed to demangle", M);
   }
 
   return demangled_cstr;
 }
 
+static char *GetDLangDemangledStr(const char *M) {
+  char *demangled_cstr = llvm::dlangDemangle(M);
+
+  if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE)) {
+    if (demangled_cstr && demangled_cstr[0])
+      LLDB_LOG(log, "demangled dlang: {0} -> \"{1}\"", M, demangled_cstr);
+    else
+      LLDB_LOG(log, "demangled dlang: {0} -> error: failed to demangle", M);
+  }
+
+  return demangled_cstr;
+}
+
 // Explicit demangling for scheduled requests during batch processing. This
 // makes use of ItaniumPartialDemangler's rich demangle info
 bool Mangled::DemangleWithRichManglingInfo(
     RichManglingContext &context, SkipMangledNameFn *skip_mangled_name) {
   // Others are not meant to arrive here. ObjC names or C's main() for example
   // have their names stored in m_demangled, while m_mangled is empty.
   assert(m_mangled);
 
case eManglingSchemeMSVC: {
     } else {
       // Demangled successfully, we can try and parse it with
       // CPlusPlusLanguage::MethodName.
       return context.FromCxxMethodName(m_demangled);
     }
   }
 
   case eManglingSchemeRustV0:
-    // Rich demangling scheme is not supported for Rust
+  case eManglingSchemeD:
+    // Rich demangling scheme is not supported
     return false;
   }
   llvm_unreachable("Fully covered switch above!");
 }
 
 // Generate the demangled name on demand using this accessor. Code in this
 // class will need to use this accessor if it wishes to decode the demangled
 // name. The result is cached and will be kept until a new string value is
if (mangling_scheme != eManglingSchemeNone &&
         break;
       case eManglingSchemeItanium: {
         demangled_name = GetItaniumDemangledStr(mangled_name);
         break;
       }
       case eManglingSchemeRustV0:
         demangled_name = GetRustV0DemangledStr(mangled_name);
         break;
+      case eManglingSchemeD:
+        demangled_name = GetDLangDemangledStr(mangled_name);
+        break;
       case eManglingSchemeNone:
         llvm_unreachable("eManglingSchemeNone was handled already");
       }
       if (demangled_name) {
         m_demangled.SetStringWithMangledCounterpart(
             llvm::StringRef(demangled_name), m_mangled);
         free(demangled_name);
       }

lldb/source/Symbol/Symtab.cpp

case Mangled::eManglingSchemeItanium: {
     }
 
     // Include this name in the index.
     return false;
   }
 
   // No filters for this scheme yet. Include all names in indexing.
   case Mangled::eManglingSchemeMSVC:
-    return false;
-
-  // No filters for this scheme yet. Include all names in indexing.
   case Mangled::eManglingSchemeRustV0:
+  case Mangled::eManglingSchemeD:
     return false;
 
   // Don't try and demangle things we can't categorize.
   case Mangled::eManglingSchemeNone:
     return true;
   }
   llvm_unreachable("unknown scheme!");
 }

lldb/unittests/Core/MangledTest.cpp

 TEST(MangledTest, EmptyForInvalidRustV0Name) {
   ConstString mangled_name("_RRR");
   Mangled the_mangled(mangled_name);
   ConstString the_demangled = the_mangled.GetDemangledName();
 
   EXPECT_STREQ("", the_demangled.GetCString());
 }
 
+TEST(MangledTest, ResultForValidDLangName) {
+  ConstString mangled_name("_Dmain");
+  Mangled the_mangled(mangled_name);
+  ConstString the_demangled = the_mangled.GetDemangledName();
+
+  ConstString expected_result("D main");
+  EXPECT_STREQ(expected_result.GetCString(), the_demangled.GetCString());
+}
+
+TEST(MangledTest, EmptyForInvalidDLangName) {
+  ConstString mangled_name("_DDD");
+  Mangled the_mangled(mangled_name);
+  ConstString the_demangled = the_mangled.GetDemangledName();
+
+  EXPECT_STREQ("", the_demangled.GetCString());
+}
+
+
 TEST(MangledTest, NameIndexes_FindFunctionSymbols) {
   SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab>
       subsystems;
 
   auto ExpectedFile = TestFile::fromYaml(R"(
 --- !ELF
 FileHeader:      
   Class:           ELFCLASS64