[WIP][LLDB] Parse the DW_AT_LLVM_lambda_name

[djtodoro]

Summary

See D77799.

$ cat basic.cpp
#include <iostream>
int main()
{
 auto printNum = [](int num) {
   std::cout << num << '\n';
 };
 for (int i = 0; i < 5; ++i)
   printNum(i);
 return 0;
}

After applying the set of patches and using the LLDB, debugging session on the test case looks:

$ clang++ -glldb -O2 basic.cpp
$ lldb a.out
..
(lldb) bt
* thread #1, name = ‘a.out’, stop reason = breakpoint 1.1
* frame #0: 0x0000000000401195 a.out `main [inlined] [lambda] printNum(this=<unavailable>, num=0) at basic.cpp:6:15 [opt]  //<== by adding this feature, I was able to add the [lambda] attribute and the name of lambda ‘printNum’//
frame #1: 0x0000000000401190 a.out `main at basic.cpp:10 [opt]
frame #2: 0x00007ffff7a961e3 libc.so.6`__libc_start_main + 243
frame #3: 0x00000000004010ce a.out _start + 46

lldb/include/lldb/Symbol/Block.h

public:
   ///     A optional pointer to declaration information for the
   ///     inlined function information. This value can be nullptr to
   ///     indicate that no declaration information is available.
   ///
   /// \param[in] call_decl_ptr
   ///     Optional calling location declaration information that
   ///     describes from where this inlined function was called.
   void SetInlinedFunctionInfo(const char *name, const char *mangled,
+                              const char *lambda_name,
                               const Declaration *decl_ptr,
                               const Declaration *call_decl_ptr);
 
   void SetParentScope(SymbolContextScope *parent_scope) {
     m_parent_scope = parent_scope;
   }
 
   /// Set accessor for the variable list.

lldb/include/lldb/Symbol/Function.h

public:
   /// \param[in] decl_ptr
   ///     Optional declaration information that describes where the
   ///     function was declared. This can be NULL.
   ///
   /// \param[in] call_decl_ptr
   ///     Optional calling location declaration information that
   ///     describes from where this inlined function was called.
   InlineFunctionInfo(const char *name, llvm::StringRef mangled,
+                     const char *lambda_name,
                      const Declaration *decl_ptr,
                      const Declaration *call_decl_ptr);
 
   /// Construct with the function method name, mangled name, and optional
   /// declaration information.
   ///
   /// \param[in] name
   ///     A name for the method name for this function. This value
   ///     should not be the mangled named, but the simple method name.
   ///
   /// \param[in] mangled
   ///     A name for the mangled name for this function. This value
   ///     can be empty if there is no mangled information.
   ///
   /// \param[in] decl_ptr
   ///     Optional declaration information that describes where the
   ///     function was declared. This can be NULL.
   ///
   /// \param[in] call_decl_ptr
   ///     Optional calling location declaration information that
   ///     describes from where this inlined function was called.
   InlineFunctionInfo(ConstString name, const Mangled &mangled,
+                     ConstString lambda_name,
                      const Declaration *decl_ptr,
                      const Declaration *call_decl_ptr);
 
   /// Destructor.
   ~InlineFunctionInfo() override;
 
   /// Compare two inlined function information objects.
   ///
public:
   void Dump(Stream *s, bool show_fullpaths) const;
 
   void DumpStopContext(Stream *s) const;
 
   ConstString GetName() const;
 
   ConstString GetDisplayName() const;
 
+  bool isLambda() const;
+
   /// Get accessor for the call site declaration information.
   ///
   /// \return
   ///     A reference to the declaration object.
   Declaration &GetCallSite();
 
   /// Get const accessor for the call site declaration information.
   ///
public:
   ///
   /// \see ConstString::StaticMemorySize ()
   size_t MemorySize() const override;
 
 private:
   // Member variables.
   Mangled m_mangled; ///< Mangled inlined function name (can be empty if there
                      ///is no mangled information).
+  ConstString m_lambda; ///< Empty if it's not a lambda.
   Declaration m_call_decl;
 };
 
 class Function;
 
 /// \class CallSiteParameter Function.h "lldb/Symbol/Function.h"
 ///
 /// Represent the locations of a parameter at a call site, both in the caller

lldb/source/Core/FormatEntity.cpp

if (language_plugin_handled) {
 
         if (sc->block) {
           Block *inline_block = sc->block->GetContainingInlinedBlock();
           if (inline_block) {
             const InlineFunctionInfo *inline_info =
                 sc->block->GetInlinedFunctionInfo();
             if (inline_info) {
               s.PutCString(" [inlined] ");
+              if (inline_info->isLambda())
+                s.PutCString("[lambda] ");
               inline_info->GetName().Dump(&s);
             }
           }
         }
         return true;
       }
     }
   }
if (language_plugin_handled) {
           if (get_function_vars) {
             variable_list_sp =
                 sc->function->GetBlock(true).GetBlockVariableList(true);
           }
 
           if (inline_info) {
             s.PutCString(cstr);
             s.PutCString(" [inlined] ");
+            if (inline_info->isLambda())
+              s.PutCString("[lambda] ");
             cstr = inline_info->GetName().GetCString();
           }
 
           VariableList args;
           if (variable_list_sp)
             variable_list_sp->AppendVariablesWithScope(
                 eValueTypeVariableArgument, args);
           if (args.GetSize() > 0) {

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

struct ParsedDWARFTypeAttributes {
   bool is_forward_declaration = false;
   bool is_inline = false;
   bool is_scoped_enum = false;
   bool is_vector = false;
   bool is_virtual = false;
   bool is_objc_direct_call = false;
   bool exports_symbols = false;
   clang::StorageClass storage = clang::SC_None;
+  const char *lambda_name = nullptr;
   const char *mangled_name = nullptr;
   lldb_private::ConstString name;
   lldb_private::Declaration decl;
   DWARFDIE object_pointer;
   DWARFFormValue abstract_origin;
   DWARFFormValue containing_type;
   DWARFFormValue signature;
   DWARFFormValue specification;

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

case DW_AT_external:
       if (form_value.Unsigned())
         storage = clang::SC_Extern;
       break;
 
     case DW_AT_inline:
       is_inline = form_value.Boolean();
       break;
 
+    case DW_AT_LLVM_lambda_name:
+      lambda_name = form_value.AsCString();
+      break;
+
     case DW_AT_linkage_name:
     case DW_AT_MIPS_linkage_name:
       mangled_name = form_value.AsCString();
       break;
 
     case DW_AT_name:
       name.SetCString(form_value.AsCString());
       break;
size_t DWARFASTParserClang::ParseChildEnumerators(
   return enumerators_added;
 }
 
 Function *DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
                                                       const DWARFDIE &die) {
   DWARFRangeList func_ranges;
   const char *name = nullptr;
   const char *mangled = nullptr;
+  const char *lambda_name = nullptr;
   int decl_file = 0;
   int decl_line = 0;
   int decl_column = 0;
   int call_file = 0;
   int call_line = 0;
   int call_column = 0;
   DWARFExpression frame_base;
 
   const dw_tag_t tag = die.Tag();
 
   if (tag != DW_TAG_subprogram)
     return nullptr;
 
-  if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
+  if (die.GetDIENamesAndRanges(name, mangled, lambda_name, func_ranges, decl_file, decl_line,
                                decl_column, call_file, call_line, call_column,
                                &frame_base)) {
-
     // Union of all ranges in the function DIE (if the function is
     // discontiguous)
     AddressRange func_range;
     lldb::addr_t lowest_func_addr = func_ranges.GetMinRangeBase(0);
     lldb::addr_t highest_func_addr = func_ranges.GetMaxRangeEnd(0);
     if (lowest_func_addr != LLDB_INVALID_ADDRESS &&
         lowest_func_addr <= highest_func_addr) {
       ModuleSP module_sp(die.GetModule());
       func_range.GetBaseAddress().ResolveAddressUsingFileSections(
           lowest_func_addr, module_sp->GetSectionList());
       if (func_range.GetBaseAddress().IsValid())
         func_range.SetByteSize(highest_func_addr - lowest_func_addr);
     }
 
     if (func_range.GetBaseAddress().IsValid()) {
       Mangled func_name;
-      if (mangled)
+      if (lambda_name)
+        func_name.SetValue(ConstString(lambda_name, false));
+      else if (mangled)
         func_name.SetValue(ConstString(mangled), true);
       else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
                 die.GetParent().Tag() == DW_TAG_partial_unit) &&
                Language::LanguageIsCPlusPlus(
                    SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
                !Language::LanguageIsObjC(
                    SymbolFileDWARF::GetLanguage(*die.GetCU())) &&
                name && strcmp(name, "main") != 0) {

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

public:
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   DWARFDIE
   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
 
-  bool GetDIENamesAndRanges(const char *&name, const char *&mangled,
+  bool GetDIENamesAndRanges(const char *&name, const char *&mangled, const char *&lamda_name,
                             DWARFRangeList &ranges, int &decl_file,
                             int &decl_line, int &decl_column, int &call_file,
                             int &call_line, int &call_column,
                             lldb_private::DWARFExpression *frame_base) const;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DWARFDIE_H

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

 bool DWARFDIE::IsMethod() const {
   for (DWARFDIE d : elaborating_dies(*this))
     if (d.GetParent().IsStructUnionOrClass())
       return true;
   return false;
 }
 
 bool DWARFDIE::GetDIENamesAndRanges(
-    const char *&name, const char *&mangled, DWARFRangeList &ranges,
+    const char *&name, const char *&mangled, const char *&lamda_name, DWARFRangeList &ranges,
     int &decl_file, int &decl_line, int &decl_column, int &call_file,
     int &call_line, int &call_column,
     lldb_private::DWARFExpression *frame_base) const {
   if (IsValid()) {
     return m_die->GetDIENamesAndRanges(
-        GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
+        GetCU(), name, mangled, lamda_name, ranges, decl_file, decl_line, decl_column,
         call_file, call_line, call_column, frame_base);
   } else
     return false;
 }

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

public:
 
   static void
   DumpAttribute(const DWARFUnit *cu,
                 const lldb_private::DWARFDataExtractor &data,
                 lldb::offset_t *offset_ptr, lldb_private::Stream &s,
                 dw_attr_t attr, DWARFFormValue &form_value);
 
   bool GetDIENamesAndRanges(
-      DWARFUnit *cu, const char *&name, const char *&mangled,
+      DWARFUnit *cu, const char *&name, const char *&mangled, const char *&lambda_name,
       DWARFRangeList &rangeList, int &decl_file, int &decl_line,
       int &decl_column, int &call_file, int &call_line, int &call_column,
       lldb_private::DWARFExpression *frame_base = nullptr) const;
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclarationPtr(const DWARFUnit *cu) const;
 
   lldb::offset_t GetFirstAttributeOffset() const;

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

static DWARFRangeList GetRangesOrReportError(DWARFUnit &unit,
   return DWARFRangeList();
 }
 
 // GetDIENamesAndRanges
 //
 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges attributes.
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
-    DWARFUnit *cu, const char *&name, const char *&mangled,
+    DWARFUnit *cu, const char *&name, const char *&mangled, const char *&lambda_name,
     DWARFRangeList &ranges, int &decl_file, int &decl_line, int &decl_column,
     int &call_file, int &call_line, int &call_column,
     DWARFExpression *frame_base) const {
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
   std::vector<DWARFDIE> dies;
   bool set_frame_base_loclist_addr = false;
 
for (uint32_t i = 0; i < numAttributes; ++i) {
                               // on relocations
           }
           break;
 
         case DW_AT_ranges:
           ranges = GetRangesOrReportError(*cu, *this, form_value);
           break;
 
+        case DW_AT_LLVM_lambda_name:
+          if (lambda_name == nullptr)
+            lambda_name = form_value.AsCString();
+          break;
+
         case DW_AT_name:
           if (name == nullptr)
             name = form_value.AsCString();
           break;
 
         case DW_AT_MIPS_linkage_name:
         case DW_AT_linkage_name:
           if (mangled == nullptr)
if (set_frame_base_loclist_addr) {
     dw_addr_t lowest_range_pc = ranges.GetMinRangeBase(0);
     assert(lowest_range_pc >= cu->GetBaseAddress());
     frame_base->SetLocationListAddresses(cu->GetBaseAddress(), lowest_range_pc);
   }
 
   if (ranges.IsEmpty() || name == nullptr || mangled == nullptr) {
     for (const DWARFDIE &die : dies) {
       if (die) {
-        die.GetDIE()->GetDIENamesAndRanges(die.GetCU(), name, mangled, ranges,
+        die.GetDIE()->GetDIENamesAndRanges(die.GetCU(), name, mangled, lambda_name, ranges,
                                            decl_file, decl_line, decl_column,
                                            call_file, call_line, call_column);
       }
     }
   }
   return !ranges.IsEmpty();
 }
 

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

case DW_TAG_lexical_block: {
       } else {
         BlockSP block_sp(new Block(die.GetID()));
         parent_block->AddChild(block_sp);
         block = block_sp.get();
       }
       DWARFRangeList ranges;
       const char *name = nullptr;
       const char *mangled_name = nullptr;
+      const char *lambda_name = nullptr;
 
       int decl_file = 0;
       int decl_line = 0;
       int decl_column = 0;
       int call_file = 0;
       int call_line = 0;
       int call_column = 0;
-      if (die.GetDIENamesAndRanges(name, mangled_name, ranges, decl_file,
+      if (die.GetDIENamesAndRanges(name, mangled_name, lambda_name, ranges, decl_file,
                                    decl_line, decl_column, call_file, call_line,
                                    call_column, nullptr)) {
         if (tag == DW_TAG_subprogram) {
           assert(subprogram_low_pc == LLDB_INVALID_ADDRESS);
           subprogram_low_pc = ranges.GetMinRangeBase(0);
         } else if (tag == DW_TAG_inlined_subroutine) {
           // We get called here for inlined subroutines in two ways. The first
           // time is when we are making the Function object for this inlined
case DW_TAG_lexical_block: {
                 "start of this error message",
                 block->GetID(), range_base, range.GetRangeEnd(),
                 subprogram_low_pc);
           }
         }
         block->FinalizeRanges();
 
         if (tag != DW_TAG_subprogram &&
-            (name != nullptr || mangled_name != nullptr)) {
+            (name != nullptr || mangled_name != nullptr ||
+             lambda_name != nullptr)) {
           std::unique_ptr<Declaration> decl_up;
           if (decl_file != 0 || decl_line != 0 || decl_column != 0)
             decl_up.reset(new Declaration(
                 comp_unit.GetSupportFiles().GetFileSpecAtIndex(decl_file),
                 decl_line, decl_column));
 
           std::unique_ptr<Declaration> call_up;
           if (call_file != 0 || call_line != 0 || call_column != 0)
             call_up.reset(new Declaration(
                 comp_unit.GetSupportFiles().GetFileSpecAtIndex(call_file),
                 call_line, call_column));
 
-          block->SetInlinedFunctionInfo(name, mangled_name, decl_up.get(),
-                                        call_up.get());
+          block->SetInlinedFunctionInfo(name, mangled_name, lambda_name,
+                                        decl_up.get(), call_up.get());
         }
 
         ++blocks_added;
 
         if (die.HasChildren()) {
           blocks_added +=
               ParseBlocksRecursive(comp_unit, block, die.GetFirstChild(),
                                    subprogram_low_pc, depth + 1);

lldb/source/Symbol/Block.cpp

 void Block::AddChild(const BlockSP &child_block_sp) {
   if (child_block_sp) {
     child_block_sp->SetParentScope(this);
     m_children.push_back(child_block_sp);
   }
 }
 
 void Block::SetInlinedFunctionInfo(const char *name, const char *mangled,
+                                   const char *lambda_name,
                                    const Declaration *decl_ptr,
                                    const Declaration *call_decl_ptr) {
-  m_inlineInfoSP = std::make_shared<InlineFunctionInfo>(name, mangled, decl_ptr,
-                                                        call_decl_ptr);
+  m_inlineInfoSP = std::make_shared<InlineFunctionInfo>(name, mangled, lambda_name,
+                                                        decl_ptr, call_decl_ptr);
 }
 
 VariableListSP Block::GetBlockVariableList(bool can_create) {
   if (!m_parsed_block_variables) {
     if (m_variable_list_sp.get() == nullptr && can_create) {
       m_parsed_block_variables = true;
       SymbolContext sc;
       CalculateSymbolContext(&sc);

lldb/source/Symbol/Function.cpp

 ConstString FunctionInfo::GetName() const { return m_name; }
 
 size_t FunctionInfo::MemorySize() const {
   return m_name.MemorySize() + m_declaration.MemorySize();
 }
 
 InlineFunctionInfo::InlineFunctionInfo(const char *name,
                                        llvm::StringRef mangled,
+                                       const char *lambda_name,
                                        const Declaration *decl_ptr,
                                        const Declaration *call_decl_ptr)
-    : FunctionInfo(name, decl_ptr), m_mangled(mangled),
+    : FunctionInfo(name, decl_ptr), m_mangled(mangled), m_lambda(lambda_name),
       m_call_decl(call_decl_ptr) {}
 
 InlineFunctionInfo::InlineFunctionInfo(ConstString name,
                                        const Mangled &mangled,
+                                       ConstString lambda_name,
                                        const Declaration *decl_ptr,
                                        const Declaration *call_decl_ptr)
-    : FunctionInfo(name, decl_ptr), m_mangled(mangled),
+    : FunctionInfo(name, decl_ptr), m_mangled(mangled), m_lambda(lambda_name),
       m_call_decl(call_decl_ptr) {}
 
 InlineFunctionInfo::~InlineFunctionInfo() {}
 
 void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
   FunctionInfo::Dump(s, show_fullpaths);
-  if (m_mangled)
+  if (m_lambda)
+    *s << ", name = \"" << m_lambda << "\"";
+  else if (m_mangled)
     m_mangled.Dump(s);
 }
 
 void InlineFunctionInfo::DumpStopContext(Stream *s) const {
   //    s->Indent("[inlined] ");
   s->Indent();
-  if (m_mangled)
+  if (m_lambda)
+    s->PutCString(m_lambda.AsCString());
+  else if (m_mangled)
     s->PutCString(m_mangled.GetName().AsCString());
   else
     s->PutCString(m_name.AsCString());
 }
 
 ConstString InlineFunctionInfo::GetName() const {
-  if (m_mangled)
+  if (m_lambda)
+    return m_lambda;
+  else if (m_mangled)
     return m_mangled.GetName();
   return m_name;
 }
 
 ConstString InlineFunctionInfo::GetDisplayName() const {
-  if (m_mangled)
+  if (m_lambda)
+    return m_lambda;
+  else if (m_mangled)
     return m_mangled.GetDisplayDemangledName();
   return m_name;
 }
 
+bool InlineFunctionInfo::isLambda() const {
+  return m_lambda ? true : false;
+}
+
 Declaration &InlineFunctionInfo::GetCallSite() { return m_call_decl; }
 
 const Declaration &InlineFunctionInfo::GetCallSite() const {
   return m_call_decl;
 }
 
 Mangled &InlineFunctionInfo::GetMangled() { return m_mangled; }