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

@@ -112,6 +112,11 @@ struct FunctionCallLabel {
 
   /// Mostly for debuggability.
   lldb::user_id_t m_die_id;
+
+  virtual ~FunctionCallLabel() = default;
+  virtual std::optional<uint8_t> getItaniumStructorVariant() const {
+    return std::nullopt;
+  }
 };
 
 /// LLDB attaches this prefix to mangled names of functions that it get called

lldb/include/lldb/Symbol/SymbolFile.h

@@ -337,8 +337,10 @@ class SymbolFile : public PluginInterface {
   ///
   /// \param[in] lookup_name The UID of the function DIE to resolve.
   ///
-  virtual llvm::Error FindAndResolveFunction(SymbolContextList &sc_list,
-                                             llvm::StringRef lookup_name) {
+  virtual llvm::Error
+  FindAndResolveFunction(SymbolContextList &sc_list,
+                         llvm::StringRef lookup_name, lldb::user_id_t spec,
+                         std::optional<uint8_t> structor_variant) {
     return llvm::createStringError("Not implemented");
   }
 

lldb/include/lldb/Symbol/TypeSystem.h

@@ -559,7 +559,7 @@ class TypeSystem : public PluginInterface,
   }
 
   // Decodes the function label into a \c FunctionCallLabel.
-  virtual llvm::Expected<FunctionCallLabel>
+  virtual llvm::Expected<std::unique_ptr<FunctionCallLabel>>
   makeFunctionCallLabel(llvm::StringRef label) const {
     return llvm::createStringError("Not implemented.");
   }

lldb/source/Expression/IRExecutionUnit.cpp

@@ -801,13 +801,13 @@ ResolveFunctionCallLabel(llvm::StringRef name,
   auto ts_sp = *ts_or_err;
 
   auto label_or_err = ts_sp->makeFunctionCallLabel(name);
-  if (!label_or_err)
+  if (!label_or_err || !*label_or_err)
     return llvm::joinErrors(
         llvm::createStringError("failed to create FunctionCallLabel from: %s",
                                 name.data()),
         label_or_err.takeError());
 
-  const auto &label = *label_or_err;
+  const auto &label = **label_or_err;
 
   Module *module = Module::GetAllocatedModuleWithUID(label.m_module_id);
 
@@ -821,8 +821,9 @@ ResolveFunctionCallLabel(llvm::StringRef name,
         llvm::formatv("no SymbolFile found on module {0:x}.", module));
 
   SymbolContextList sc_list;
-  if (auto err =
-          symbol_file->FindAndResolveFunction(sc_list, label.m_lookup_name))
+  if (auto err = symbol_file->FindAndResolveFunction(
+          sc_list, label.m_lookup_name, label.m_die_id,
+          label.getItaniumStructorVariant()))
     return llvm::joinErrors(
         llvm::createStringError("failed to resolve function by UID"),
         std::move(err));

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::optional<std::string> MakeLLDBFuncAsmLabel(const DWARFDIE &die) {
-  char const *name = die.GetMangledName(/*substitute_name_allowed*/ false);
+  const char *name = GetMangledOrStructorName(die);
   if (!name)
     return std::nullopt;
 
@@ -267,7 +295,7 @@ static std::optional<std::string> MakeLLDBFuncAsmLabel(const DWARFDIE &die) {
   if (die_id == LLDB_INVALID_UID)
     return std::nullopt;
 
-  return llvm::formatv("{0}:{1}:{2:x}:{3:x}", FunctionCallLabelPrefix, name,
+  return llvm::formatv("{0}:{1}:{2:x}:{3:x}:", FunctionCallLabelPrefix, name,
                        module_id, die_id)
       .str();
 }

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

@@ -76,6 +76,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"
 
@@ -2471,32 +2472,63 @@ bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
   return false;
 }
 
-llvm::Error
-SymbolFileDWARF::FindAndResolveFunction(SymbolContextList &sc_list,
-                                        llvm::StringRef lookup_name) {
+llvm::Error SymbolFileDWARF::FindAndResolveFunction(
+    SymbolContextList &sc_list, llvm::StringRef lookup_name,
+    lldb::user_id_t die_id, std::optional<uint8_t> structor_variant) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-
-  DWARFDIE die;
-  Module::LookupInfo info(ConstString(lookup_name), lldb::eFunctionNameTypeFull,
+  DWARFDIE die = GetDIE(die_id);
+  if (!die.IsValid())
+    return llvm::createStringError("invalid DIE for UID: %" PRIu64, die_id);
+
+  // eFunctionNameTypeFull for mangled name lookup.
+  // eFunctionNameTypeMethod is required for structor lookups (since we look
+  // those up by DW_AT_name).
+  Module::LookupInfo info(ConstString(lookup_name),
+                          lldb::eFunctionNameTypeFull |
+                              lldb::eFunctionNameTypeMethod,
                           lldb::eLanguageTypeUnknown);
 
   m_index->GetFunctions(info, *this, {}, [&](DWARFDIE entry) {
     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.
+    // 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 (!structor_variant) {
+      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() != structor_variant)
+      return true;
+
     die = entry;
+
     return false;
   });
 
   if (!die.IsValid())
     return llvm::createStringError(
-        llvm::formatv("failed to find definition DIE for '{0}'", lookup_name));
+        llvm::formatv("failed to find definition DIE for [lookup_name={0}] "
+                      "[DIE ID={1:x}] [structor={2}]",
+                      lookup_name, die_id, structor_variant.value_or(-1)));
 
   if (!ResolveFunction(die, false, sc_list))
     return llvm::createStringError("failed to resolve function DIE");

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

@@ -434,8 +434,10 @@ class SymbolFileDWARF : public SymbolFileCommon {
   DIEArray MergeBlockAbstractParameters(const DWARFDIE &block_die,
                                         DIEArray &&variable_dies);
 
-  llvm::Error FindAndResolveFunction(SymbolContextList &sc_list,
-                                     llvm::StringRef lookup_name) override;
+  llvm::Error
+  FindAndResolveFunction(SymbolContextList &sc_list,
+                         llvm::StringRef lookup_name, lldb::user_id_t spec,
+                         std::optional<uint8_t> structor_variant) override;
 
   // Given a die_offset, figure out the symbol context representing that die.
   bool ResolveFunction(const DWARFDIE &die, bool include_inlines,

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"
@@ -9783,8 +9784,40 @@ void TypeSystemClang::LogCreation() const {
              &getASTContext(), getDisplayName());
 }
 
+static llvm::Expected<
+    std::variant<std::monostate, clang::CXXCtorType, clang::CXXDtorType>>
+ParseStructorType(llvm::StringRef label) {
+  if (label.empty())
+    return std::monostate{};
+
+  bool is_ctor = label.consume_front("C");
+  if (!is_ctor && label.starts_with("D"))
+    return llvm::createStringError("invalid structor type prefix in %s",
+                                   label.data());
+
+  uint8_t type;
+  if (label.consumeInteger(0, type))
+    return llvm::createStringError("failed to parse structor type value %s",
+                                   label.data());
+
+  if (is_ctor) {
+    if (type > clang::CXXCtorType::Ctor_DefaultClosure)
+      return llvm::createStringError("C++ constructor type %d out of range",
+                                     type);
+
+    return static_cast<CXXCtorType>(type);
+  }
+
+  if (type > clang::CXXDtorType::Dtor_Deleting)
+    return llvm::createStringError("C++ destructor type %d out of range", type);
+
+  return static_cast<CXXDtorType>(type);
+}
+
+// clang-format off
 // Expected format is:
-// $__lldb_func:<mangled name>:<module id>:<definition/declaration DIE id>
+// $__lldb_func:<mangled name>:<module id>:<definition/declaration DIE id>:[<structor variant>]
+// clang-format on
 llvm::Expected<llvm::SmallVector<llvm::StringRef, 3>>
 TypeSystemClang::splitFunctionCallLabel(llvm::StringRef label) const {
   if (!consumeFunctionCallLabelPrefix(label))
@@ -9794,17 +9827,17 @@ TypeSystemClang::splitFunctionCallLabel(llvm::StringRef label) const {
     return llvm::createStringError(
         "incorrect format: expected ':' as the first character.");
 
-  llvm::SmallVector<llvm::StringRef, 3> components;
+  llvm::SmallVector<llvm::StringRef, 4> components;
   label.split(components, ":");
 
-  if (components.size() != 3)
+  if (components.size() != 4)
     return llvm::createStringError(
         "incorrect format: too many label subcomponents.");
 
   return components;
 }
 
-llvm::Expected<FunctionCallLabel>
+llvm::Expected<std::unique_ptr<FunctionCallLabel>>
 TypeSystemClang::makeFunctionCallLabel(llvm::StringRef label) const {
   auto components_or_err = splitFunctionCallLabel(label);
   if (!components_or_err)
@@ -9816,6 +9849,7 @@ TypeSystemClang::makeFunctionCallLabel(llvm::StringRef label) const {
 
   llvm::StringRef module_label = components[1];
   llvm::StringRef die_label = components[2];
+  llvm::StringRef structor_variant = components[3];
 
   lldb::user_id_t module_id = 0;
   if (module_label.consumeInteger(0, module_id))
@@ -9827,6 +9861,52 @@ TypeSystemClang::makeFunctionCallLabel(llvm::StringRef label) const {
     return llvm::createStringError(
         llvm::formatv("failed to parse DIE ID from '{0}'.", components[2]));
 
-  return FunctionCallLabel{/*.m_lookup_name =*/components[0],
-                           /*.m_module_id =*/module_id, /*.m_die_id =*/die_id};
+  auto structor_type_or_err = ParseStructorType(structor_variant);
+  if (!structor_type_or_err)
+    return llvm::joinErrors(
+        llvm::createStringError(llvm::formatv(
+            "failed to parse structor kind from '{0}'.", components[2])),
+        structor_type_or_err.takeError());
+
+  auto ret = std::make_unique<ClangFunctionCallLabel>();
+  ret->m_lookup_name = components[0];
+  ret->m_module_id = module_id;
+  ret->m_die_id = die_id;
+  ret->m_structor_type = std::move(*structor_type_or_err);
+
+  return ret;
+}
+
+std::optional<uint8_t>
+TypeSystemClang::ClangFunctionCallLabel::getItaniumStructorVariant() const {
+  if (m_structor_type.index() == 0)
+    return std::nullopt;
+
+  if (auto *ctor = std::get_if<clang::CXXCtorType>(&m_structor_type)) {
+    switch (*ctor) {
+    case clang::CXXCtorType::Ctor_Complete:
+      return 1;
+    case clang::CXXCtorType::Ctor_Base:
+      return 2;
+    case clang::CXXCtorType::Ctor_Comdat:
+    case clang::CXXCtorType::Ctor_CopyingClosure:
+    case clang::CXXCtorType::Ctor_DefaultClosure:
+      // No Itanium equivalent
+      return std::nullopt;
+    }
+  } else if (auto *dtor = std::get_if<clang::CXXDtorType>(&m_structor_type)) {
+    switch (*dtor) {
+    case clang::CXXDtorType::Dtor_Deleting:
+      return 0;
+    case clang::CXXDtorType::Dtor_Complete:
+      return 1;
+    case clang::CXXDtorType::Dtor_Base:
+      return 2;
+    case clang::CXXDtorType::Dtor_Comdat:
+      // No Itanium equivalent
+      return std::nullopt;
+    }
+  }
+
+  return std::nullopt;
 }