Structors Init

Author: Michael137

clang/lib/AST/Mangle.cpp

@@ -152,6 +152,13 @@ bool MangleContext::shouldMangleDeclName(const NamedDecl *D) {
   return shouldMangleCXXName(D);
 }
 
+static void tryEmitDebugStructorVariant(GlobalDecl GD, raw_ostream &Out) {
+  if (llvm::isa<clang::CXXConstructorDecl>(GD.getDecl()))
+    Out << "C" << GD.getCtorType();
+  else if (llvm::isa<clang::CXXDestructorDecl>(GD.getDecl()))
+    Out << "D" << GD.getDtorType();
+}
+
 void MangleContext::mangleName(GlobalDecl GD, raw_ostream &Out) {
   const ASTContext &ASTContext = getASTContext();
   const NamedDecl *D = cast<NamedDecl>(GD.getDecl());
@@ -165,6 +172,11 @@ void MangleContext::mangleName(GlobalDecl GD, raw_ostream &Out) {
     // do not add a "\01" prefix.
     if (!ALA->getIsLiteralLabel() || ALA->getLabel().starts_with("llvm.")) {
       Out << ALA->getLabel();
+
+      // TODO: ideally should have separate attribute for this?
+      if (ASTContext.getLangOpts().DebuggerSupport)
+        tryEmitDebugStructorVariant(GD, Out);
+
       return;
     }
 

libcxxabi/src/demangle/ItaniumDemangle.h

@@ -1766,6 +1766,8 @@ class CtorDtorName final : public Node {
 
   template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
 
+  int getVariant() const { return Variant; }
+
   void printLeft(OutputBuffer &OB) const override {
     if (IsDtor)
       OB += "~";

lldb/include/lldb/Expression/Expression.h

@@ -103,7 +103,7 @@ class Expression {
 ///
 /// The format being:
 ///
-///   <prefix>:<module uid>:<symbol uid>:<name>
+///   <prefix>:<module uid>:<symbol uid>:<discriminator>:<name>
 ///
 /// The label string needs to stay valid for the entire lifetime
 /// of this object.
@@ -126,14 +126,16 @@ struct FunctionCallLabel {
   /// ':' in the mangled name when parsing the label.
   llvm::StringRef lookup_name;
 
+  uint64_t discriminator = 0;
+
   /// Decodes the specified function \c label into a \c FunctionCallLabel.
   static llvm::Expected<FunctionCallLabel> fromString(llvm::StringRef label);
 
   /// Encode this FunctionCallLabel into its string representation.
   ///
   /// The representation roundtrips through \c fromString:
   /// \code{.cpp}
-  /// llvm::StringRef encoded = "$__lldb_func:0x0:0x0:_Z3foov";
+  /// llvm::StringRef encoded = "$__lldb_func:0x0:0x0:0x0:_Z3foov";
   /// FunctionCallLabel label = *fromString(label);
   ///
   /// assert (label.toString() == encoded);

lldb/source/Expression/Expression.cpp

@@ -34,10 +34,10 @@ Expression::Expression(ExecutionContextScope &exe_scope)
 
 llvm::Expected<FunctionCallLabel>
 lldb_private::FunctionCallLabel::fromString(llvm::StringRef label) {
-  llvm::SmallVector<llvm::StringRef, 4> components;
-  label.split(components, ":", /*MaxSplit=*/3);
+  llvm::SmallVector<llvm::StringRef, 5> components;
+  label.split(components, ":", /*MaxSplit=*/4);
 
-  if (components.size() != 4)
+  if (components.size() != 5)
     return llvm::createStringError("malformed function call label.");
 
   if (components[0] != FunctionCallLabelPrefix)
@@ -47,6 +47,8 @@ lldb_private::FunctionCallLabel::fromString(llvm::StringRef label) {
 
   llvm::StringRef module_label = components[1];
   llvm::StringRef die_label = components[2];
+  llvm::StringRef discriminator_label = components[3];
+  llvm::StringRef lookup_name = components[4];
 
   lldb::user_id_t module_id = 0;
   if (!llvm::to_integer(module_label, module_id))
@@ -58,20 +60,26 @@ lldb_private::FunctionCallLabel::fromString(llvm::StringRef label) {
     return llvm::createStringError(
         llvm::formatv("failed to parse symbol ID from '{0}'.", die_label));
 
+  uint64_t discriminator = 0;
+  if (!llvm::to_integer(discriminator_label, discriminator))
+    return llvm::createStringError(
+        llvm::formatv("failed to parse discriminator from '{0}'.", discriminator_label));
+
   return FunctionCallLabel{/*.module_id=*/module_id,
                            /*.symbol_id=*/die_id,
-                           /*.lookup_name=*/components[3]};
+                           /*.lookup_name=*/lookup_name,
+                           /*.discriminator=*/discriminator};
 }
 
 std::string lldb_private::FunctionCallLabel::toString() const {
-  return llvm::formatv("{0}:{1:x}:{2:x}:{3}", FunctionCallLabelPrefix,
+  return llvm::formatv("{0}:{1:x}:{2:x}:{3}:", FunctionCallLabelPrefix,
                        module_id, symbol_id, lookup_name)
       .str();
 }
 
 void llvm::format_provider<FunctionCallLabel>::format(
     const FunctionCallLabel &label, raw_ostream &OS, StringRef Style) {
   OS << llvm::formatv("FunctionCallLabel{ module_id: {0:x}, symbol_id: {1:x}, "
-                      "lookup_name: {2} }",
-                      label.module_id, label.symbol_id, label.lookup_name);
+                      "lookup_name: {3}, discriminator: {2} }",
+                      label.module_id, label.symbol_id, label.lookup_name, label.discriminator);
 }

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

@@ -250,8 +250,36 @@ static unsigned GetCXXMethodCVQuals(const DWARFDIE &subprogram,
   return cv_quals;
 }
 
+static const char *GetMangledOrStructorName(const DWARFDIE &die) {
+  const char *name = die.GetMangledName(/*substitute_name_allowed*/ false);
+  if (name)
+    return name;
+
+  name = die.GetName();
+  if (!name)
+    return nullptr;
+
+  DWARFDIE parent = die.GetParent();
+  if (!parent.IsStructUnionOrClass())
+    return nullptr;
+
+  const char *parent_name = parent.GetName();
+  if (!parent_name)
+    return nullptr;
+
+  // Constructor.
+  if (::strcmp(parent_name, name) == 0)
+    return name;
+
+  // Destructor.
+  if (name[0] == '~' && ::strcmp(parent_name, name + 1))
+    return name;
+
+  return nullptr;
+}
+
 static std::string MakeLLDBFuncAsmLabel(const DWARFDIE &die) {
-  char const *name = die.GetMangledName(/*substitute_name_allowed*/ false);
+  char const *name = GetMangledOrStructorName(die);
   if (!name)
     return {};
 

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

@@ -77,6 +77,7 @@
 
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugAbbrev.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 
@@ -2475,6 +2476,28 @@ bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
   return false;
 }
 
+static std::optional<uint8_t>
+GetItaniumCtorDtorVariant(uint16_t discriminator) {
+  const uint8_t kind_tag = discriminator >> 1;
+  const uint8_t variant_tag = discriminator & 0xf;
+  const bool is_ctor = kind_tag & 0x1;
+
+  if (!kind_tag && !(kind_tag & 0x2))
+    return std::nullopt;
+
+  if (is_ctor) {
+    if (variant_tag > clang::CXXCtorType::Ctor_DefaultClosure)
+      return std::nullopt;
+
+    return static_cast<clang::CXXCtorType>(variant_tag);
+  }
+
+  if (variant_tag > clang::CXXDtorType::Dtor_Deleting)
+    return std::nullopt;
+
+  return static_cast<clang::CXXDtorType>(variant_tag);
+}
+
 llvm::Expected<SymbolContext>
 SymbolFileDWARF::ResolveFunctionCallLabel(const FunctionCallLabel &label) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
@@ -2487,6 +2510,9 @@ SymbolFileDWARF::ResolveFunctionCallLabel(const FunctionCallLabel &label) {
   // Label was created using a declaration DIE. Need to fetch the definition
   // to resolve the function call.
   if (die.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0)) {
+    // eFunctionNameTypeFull for mangled name lookup.
+    // eFunctionNameTypeMethod is required for structor lookups (since we look
+    // those up by DW_AT_name).
     Module::LookupInfo info(ConstString(label.lookup_name),
                             lldb::eFunctionNameTypeFull,
                             lldb::eLanguageTypeUnknown);
@@ -2495,13 +2521,33 @@ SymbolFileDWARF::ResolveFunctionCallLabel(const FunctionCallLabel &label) {
       if (entry.GetAttributeValueAsUnsigned(llvm::dwarf::DW_AT_declaration, 0))
         return true;
 
-      // We don't check whether the specification DIE for this function
-      // corresponds to the declaration DIE because the declaration might be in
-      // a type-unit but the definition in the compile-unit (and it's
-      // specifcation would point to the declaration in the compile-unit). We
-      // rely on the mangled name within the module to be enough to find us the
-      // unique definition.
-      die = entry;
+      // TODO: this specification check doesn't work if declaration DIE was in a
+      // type-unit (we should only encode DIEs from .debug_info).
+      auto spec = entry.GetAttributeValueAsReferenceDIE(DW_AT_specification);
+      if (!spec)
+        return true;
+  
+      if (spec != die)
+        return true;
+  
+      // We're not picking a specific structor variant DIE, so we're done here.
+      if (!label.discriminator) {
+        die = entry;
+        return false;
+      }
+  
+      const char *mangled =
+          entry.GetMangledName(/*substitute_name_allowed=*/false);
+      if (!mangled)
+        return true;
+  
+      llvm::ItaniumPartialDemangler D;
+      if (D.partialDemangle(mangled))
+        return true;
+  
+      if (D.getCtorOrDtorVariant() != GetItaniumCtorDtorVariant(label.discriminator).value_or(-1))
+        return true;
+
       return false;
     });
 

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

@@ -10,6 +10,7 @@
 
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/ExprCXX.h"
+#include "clang/Basic/ABI.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/FormatAdapters.h"

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

@@ -18,6 +18,7 @@
 #include <set>
 #include <string>
 #include <utility>
+#include <variant>
 #include <vector>
 
 #include "clang/AST/ASTContext.h"
@@ -26,6 +27,7 @@
 #include "clang/AST/Decl.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/ABI.h"
 #include "clang/Basic/TargetInfo.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"

llvm/include/llvm/Demangle/Demangle.h

@@ -127,6 +127,9 @@ struct ItaniumPartialDemangler {
   /// If this symbol describes a constructor or destructor.
   DEMANGLE_ABI bool isCtorOrDtor() const;
 
+  /// If this symbol describes a constructor or destructor.
+  std::optional<int> getCtorOrDtorVariant() const;
+
   /// If this symbol describes a function.
   DEMANGLE_ABI bool isFunction() const;
 

llvm/include/llvm/Demangle/ItaniumDemangle.h

@@ -1766,6 +1766,8 @@ class CtorDtorName final : public Node {
 
   template<typename Fn> void match(Fn F) const { F(Basename, IsDtor, Variant); }
 
+  int getVariant() const { return Variant; }
+
   void printLeft(OutputBuffer &OB) const override {
     if (IsDtor)
       OB += "~";