DWZ 02/07: Match also DW_TAG_partial_unit when DW_TAG_compile_unit is matched

[jankratochvil]

Summary

Code commonly checks if the parent DIE is DW_TAG_compile_unit. But DW_TAG_partial_unit also acts as DW_TAG_compile_unit for DWZ as DWZ is using DW_TAG_imported_unit only at the top unit level.

All DWZ patches are also applied in: git clone -b dwz git://git.jankratochvil.net/lldb

[clayborg]

Seems like it would be cleaner to leave DWARFDebugInfoEntry and DWARFDie alone and just make clients deal with accepting DW_TAG_partial_unit when and where they need to. I don't like the idea of not telling the truth.

[jankratochvil]

In D40469#936245, @clayborg wrote:

Seems like it would be cleaner to leave DWARFDebugInfoEntry and DWARFDie alone and just make clients deal with accepting DW_TAG_partial_unit when and where they need to. I don't like the idea of not telling the truth.

done

[jankratochvil]

It is now reworked without FileOffset and the remapping to unique DIE offsets for each DW_TAG_partial_unit inclusion by DW_TAG_imported_unit, as discussed in: https://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180409/040324.html

[labath]

Adding some debug info people, as I don't feel qualified to review this.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

       }
 
       if (type_sp.get()) {
         DWARFDIE sc_parent_die =
             SymbolFileDWARF::GetParentSymbolContextDIE(die);
         dw_tag_t sc_parent_tag = sc_parent_die.Tag();
 
         SymbolContextScope *symbol_context_scope = NULL;
-        if (sc_parent_tag == DW_TAG_compile_unit) {
+        if (sc_parent_tag == DW_TAG_compile_unit ||
+            sc_parent_tag == DW_TAG_partial_unit) {
           symbol_context_scope = sc.comp_unit;
         } else if (sc.function != NULL && sc_parent_die) {
           symbol_context_scope =
               sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
           if (symbol_context_scope == NULL)
             symbol_context_scope = sc.function;
         }
 
if (lowest_func_addr != LLDB_INVALID_ADDRESS &&
       if (func_range.GetBaseAddress().IsValid())
         func_range.SetByteSize(highest_func_addr - lowest_func_addr);
     }
 
     if (func_range.GetBaseAddress().IsValid()) {
       Mangled func_name;
       if (mangled)
         func_name.SetValue(ConstString(mangled), true);
-      else if (die.GetParent().Tag() == DW_TAG_compile_unit &&
+      else if ((die.GetParent().Tag() == DW_TAG_compile_unit ||
+                die.GetParent().Tag() == DW_TAG_partial_unit) &&
                Language::LanguageIsCPlusPlus(die.GetLanguage()) && name &&
                strcmp(name, "main") != 0) {
         // If the mangled name is not present in the DWARF, generate the
         // demangled name
         // using the decl context. We skip if the function is "main" as its name
         // is
         // never mangled.
         bool is_static = false;
DWARFASTParserClang::GetClangDeclContextForDIE(const DWARFDIE &die) {
   if (die) {
     clang::DeclContext *decl_ctx = GetCachedClangDeclContextForDIE(die);
     if (decl_ctx)
       return decl_ctx;
 
     bool try_parsing_type = true;
     switch (die.Tag()) {
     case DW_TAG_compile_unit:
+    case DW_TAG_partial_unit:
       decl_ctx = m_ast.GetTranslationUnitDecl();
       try_parsing_type = false;
       break;
 
     case DW_TAG_namespace:
       decl_ctx = ResolveNamespaceDIE(die);
       try_parsing_type = false;
       break;

source/Plugins/SymbolFile/DWARF/DWARFASTParserGo.cpp

if (type_ptr == NULL) {
       }
 
       if (type_sp.get()) {
         DWARFDIE sc_parent_die =
             SymbolFileDWARF::GetParentSymbolContextDIE(die);
         dw_tag_t sc_parent_tag = sc_parent_die.Tag();
 
         SymbolContextScope *symbol_context_scope = NULL;
-        if (sc_parent_tag == DW_TAG_compile_unit) {
+        if (sc_parent_tag == DW_TAG_compile_unit ||
+            sc_parent_tag == DW_TAG_partial_unit) {
           symbol_context_scope = sc.comp_unit;
         } else if (sc.function != NULL && sc_parent_die) {
           symbol_context_scope =
               sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
           if (symbol_context_scope == NULL)
             symbol_context_scope = sc.function;
         }
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserJava.cpp

lldb::TypeSP DWARFASTParserJava::ParseTypeFromDWARF(
 
   if (!type_sp)
     return nullptr;
 
   DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
   dw_tag_t sc_parent_tag = sc_parent_die.Tag();
 
   SymbolContextScope *symbol_context_scope = nullptr;
-  if (sc_parent_tag == DW_TAG_compile_unit) {
+  if (sc_parent_tag == DW_TAG_compile_unit ||
+      sc_parent_tag == DW_TAG_partial_unit) {
     symbol_context_scope = sc.comp_unit;
   } else if (sc.function != nullptr && sc_parent_die) {
     symbol_context_scope =
         sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
     if (symbol_context_scope == nullptr)
       symbol_context_scope = sc.function;
   }
 

source/Plugins/SymbolFile/DWARF/DWARFASTParserOCaml.cpp

lldb::TypeSP DWARFASTParserOCaml::ParseTypeFromDWARF(const SymbolContext &sc,
 
   if (!type_sp)
     return nullptr;
 
   DWARFDIE sc_parent_die = SymbolFileDWARF::GetParentSymbolContextDIE(die);
   dw_tag_t sc_parent_tag = sc_parent_die.Tag();
 
   SymbolContextScope *symbol_context_scope = nullptr;
-  if (sc_parent_tag == DW_TAG_compile_unit) {
+  if (sc_parent_tag == DW_TAG_compile_unit ||
+      sc_parent_tag == DW_TAG_partial_unit) {
     symbol_context_scope = sc.comp_unit;
   } else if (sc.function != nullptr && sc_parent_die) {
     symbol_context_scope =
         sc.function->GetBlock(true).FindBlockByID(sc_parent_die.GetID());
     if (symbol_context_scope == nullptr)
       symbol_context_scope = sc.function;
   }
 

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

if (IsValid()) {
     m_die->GetDWARFDeclContext(GetDWARF(), GetCU(), dwarf_decl_ctx);
   } else {
     dwarf_decl_ctx.Clear();
   }
 }
 
 void DWARFDIE::GetDWOContext(std::vector<CompilerContext> &context) const {
   const dw_tag_t tag = Tag();
-  if (tag == DW_TAG_compile_unit)
+  if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
     return;
   DWARFDIE parent = GetParent();
   if (parent)
     parent.GetDWOContext(context);
   switch (tag) {
   case DW_TAG_module:
     context.push_back(
         CompilerContext(CompilerContextKind::Module, ConstString(GetName())));
if (IsValid()) {
     DWARFDIE top_module_die;
     // Now make sure this DIE is scoped in a DW_TAG_module tag and return true
     // if so
     for (DWARFDIE parent = GetParent(); parent.IsValid();
          parent = parent.GetParent()) {
       const dw_tag_t tag = parent.Tag();
       if (tag == DW_TAG_module)
         top_module_die = parent;
-      else if (tag == DW_TAG_compile_unit)
+      else if (tag == DW_TAG_compile_unit || tag == DW_TAG_partial_unit)
         break;
     }
 
     return top_module_die;
   }
   return DWARFDIE();
 }
 

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

if ((offset < cu_end_offset) && debug_info_data.ValidOffset(offset)) {
     if (abbr_idx) {
       const DWARFAbbreviationDeclaration *abbrevDecl =
           cu->GetAbbreviations()->GetAbbreviationDeclaration(abbr_idx);
 
       if (abbrevDecl) {
         m_tag = abbrevDecl->Tag();
         m_has_children = abbrevDecl->HasChildren();
 
-        bool isCompileUnitTag = m_tag == DW_TAG_compile_unit;
+        bool isCompileUnitTag = (m_tag == DW_TAG_compile_unit ||
+                                 m_tag == DW_TAG_partial_unit);
         if (cu && isCompileUnitTag)
           const_cast<DWARFUnit *>(cu)->SetBaseAddress(0);
 
         // Skip all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
         uint32_t i;
         dw_attr_t attr;
         dw_form_t form;

 //----------------------------------------------------------------------
 size_t DWARFDebugInfoEntry::GetAttributes(
     const DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFAttributes &attributes, uint32_t curr_depth) const {
   SymbolFileDWARF *dwarf2Data = nullptr;
   const DWARFAbbreviationDeclaration *abbrevDecl = nullptr;
   lldb::offset_t offset = 0;
   if (cu) {
-    if (m_tag != DW_TAG_compile_unit) {
+    if (m_tag != DW_TAG_compile_unit && m_tag != DW_TAG_partial_unit) {
       SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
       if (dwo_symbol_file)
         return GetAttributes(dwo_symbol_file->GetCompileUnit(),
                              fixed_form_sizes, attributes, curr_depth);
     }
 
     dwarf2Data = cu->GetSymbolFileDWARF();
     abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);

 // would be a compile unit header).
 //----------------------------------------------------------------------
 dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
     const dw_attr_t attr, DWARFFormValue &form_value,
     dw_offset_t *end_attr_offset_ptr,
     bool check_specification_or_abstract_origin) const {
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
-  if (dwo_symbol_file && m_tag != DW_TAG_compile_unit)
+  if (dwo_symbol_file && m_tag != DW_TAG_compile_unit &&
+                         m_tag != DW_TAG_partial_unit)
     return GetAttributeValue(dwo_symbol_file, dwo_symbol_file->GetCompileUnit(),
                              attr, form_value, end_attr_offset_ptr,
                              check_specification_or_abstract_origin);
 
   lldb::offset_t offset;
   const DWARFAbbreviationDeclaration *abbrevDecl =
       GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
 
void DWARFDebugInfoEntry::GetDeclContextDIEs(
   DWARFDIE die(cu, const_cast<DWARFDebugInfoEntry *>(this));
   die.GetDeclContextDIEs(decl_context_dies);
 }
 
 void DWARFDebugInfoEntry::GetDWARFDeclContext(
     SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
     DWARFDeclContext &dwarf_decl_ctx) const {
   const dw_tag_t tag = Tag();
-  if (tag != DW_TAG_compile_unit) {
+  if (tag != DW_TAG_compile_unit && tag != DW_TAG_partial_unit) {
     dwarf_decl_ctx.AppendDeclContext(tag, GetName(dwarf2Data, cu));
     DWARFDIE parent_decl_ctx_die = GetParentDeclContextDIE(dwarf2Data, cu);
     if (parent_decl_ctx_die && parent_decl_ctx_die.GetDIE() != this) {
-      if (parent_decl_ctx_die.Tag() != DW_TAG_compile_unit)
+      if (parent_decl_ctx_die.Tag() != DW_TAG_compile_unit &&
+          parent_decl_ctx_die.Tag() != DW_TAG_partial_unit)
         parent_decl_ctx_die.GetDIE()->GetDWARFDeclContext(
             parent_decl_ctx_die.GetDWARF(), parent_decl_ctx_die.GetCU(),
             dwarf_decl_ctx);
     }
   }
 }
 
 bool DWARFDebugInfoEntry::MatchesDWARFDeclContext(
DWARFDebugInfoEntry::GetParentDeclContextDIE(
 
   while (die) {
     // If this is the original DIE that we are searching for a declaration
     // for, then don't look in the cache as we don't want our own decl
     // context to be our decl context...
     if (die.GetDIE() != this) {
       switch (die.Tag()) {
       case DW_TAG_compile_unit:
+      case DW_TAG_partial_unit:
       case DW_TAG_namespace:
       case DW_TAG_structure_type:
       case DW_TAG_union_type:
       case DW_TAG_class_type:
         return die;
 
       default:
         break;
if (m_tag) {
     case DW_TAG_namespace:
       check_children = true;
       break;
     case DW_TAG_imported_module:
       break;
     case DW_TAG_unspecified_type:
       break;
     case DW_TAG_partial_unit:
+      match_addr_range = true;
       break;
     case DW_TAG_imported_unit:
       break;
     case DW_TAG_shared_type:
       break;
     default:
       break;
     }
 
     if (match_addr_range) {
       dw_addr_t lo_pc = GetAttributeValueAsAddress(dwarf2Data, cu, DW_AT_low_pc,
                                                    LLDB_INVALID_ADDRESS);
       if (lo_pc != LLDB_INVALID_ADDRESS) {
         dw_addr_t hi_pc =
             GetAttributeHighPC(dwarf2Data, cu, lo_pc, LLDB_INVALID_ADDRESS);
         if (hi_pc != LLDB_INVALID_ADDRESS) {
           //  printf("\n0x%8.8x: %30s: address = 0x%8.8x  [0x%8.8x - 0x%8.8x) ",
           //  m_offset, DW_TAG_value_to_name(tag), address, lo_pc, hi_pc);
           if ((lo_pc <= address) && (address < hi_pc)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {
             case DW_TAG_compile_unit: // File
+            case DW_TAG_partial_unit: // File
               check_children = ((function_die != NULL) || (block_die != NULL));
               break;
 
             case DW_TAG_subprogram: // Function
               if (function_die)
                 *function_die = this;
               check_children = (block_die != NULL);
               break;
if (match_addr_range) {
             default:
               check_children = true;
               break;
             }
           }
         } else { // compile units may not have a valid high/low pc when there
           // are address gaps in subroutines so we must always search
           // if there is no valid high and low PC
-          check_children = (m_tag == DW_TAG_compile_unit) &&
+          check_children = (m_tag == DW_TAG_compile_unit ||
+                            m_tag == DW_TAG_partial_unit) &&
                            ((function_die != NULL) || (block_die != NULL));
         }
       } else {
         dw_offset_t debug_ranges_offset = GetAttributeValueAsUnsigned(
             dwarf2Data, cu, DW_AT_ranges, DW_INVALID_OFFSET);
         if (debug_ranges_offset != DW_INVALID_OFFSET) {
           DWARFRangeList ranges;
           DWARFDebugRanges *debug_ranges = dwarf2Data->DebugRanges();
           debug_ranges->FindRanges(cu->GetRangesBase(), debug_ranges_offset, ranges);
           // All DW_AT_ranges are relative to the base address of the
           // compile unit. We add the compile unit base address to make
           // sure all the addresses are properly fixed up.
           ranges.Slide(cu->GetBaseAddress());
           if (ranges.FindEntryThatContains(address)) {
             found_address = true;
             //  puts("***MATCH***");
             switch (m_tag) {
             case DW_TAG_compile_unit: // File
+            case DW_TAG_partial_unit: // File
               check_children = ((function_die != NULL) || (block_die != NULL));
               break;
 
             case DW_TAG_subprogram: // Function
               if (function_die)
                 *function_die = this;
               check_children = (block_die != NULL);
               break;

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

if (num_attributes > 0) {
                 //         add_die = true;
                 //     }
                 //   }
                 // }
                 parent_die = NULL; // Terminate the while loop.
                 break;
 
               case DW_TAG_compile_unit:
+              case DW_TAG_partial_unit:
                 is_global_or_static_variable = true;
                 parent_die = NULL; // Terminate the while loop.
                 break;
 
               default:
                 parent_die =
                     parent_die->GetParent(); // Keep going in the while loop.
                 break;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 DWARFDIE
 SymbolFileDWARF::GetParentSymbolContextDIE(const DWARFDIE &child_die) {
   DWARFDIE die;
   for (die = child_die.GetParent(); die; die = die.GetParent()) {
     dw_tag_t tag = die.Tag();
 
     switch (tag) {
     case DW_TAG_compile_unit:
+    case DW_TAG_partial_unit:
     case DW_TAG_subprogram:
     case DW_TAG_inlined_subroutine:
     case DW_TAG_lexical_block:
       return die;
     }
   }
   return DWARFDIE();
 }
if (orig_die) {
 
     while (die) {
       // If this is the original DIE that we are searching for a declaration
       // for, then don't look in the cache as we don't want our own decl
       // context to be our decl context...
       if (orig_die != die) {
         switch (die.Tag()) {
         case DW_TAG_compile_unit:
+        case DW_TAG_partial_unit:
         case DW_TAG_namespace:
         case DW_TAG_structure_type:
         case DW_TAG_union_type:
         case DW_TAG_class_type:
         case DW_TAG_lexical_block:
         case DW_TAG_subprogram:
           return die;
         case DW_TAG_inlined_subroutine: {
bool SymbolFileDWARF::DIEDeclContextsMatch(const DWARFDIE &die1,
   // DIEs all the way back to the compile unit. If a type "T" is
   // declared inside a class "B", and class "B" is declared inside
   // a class "A" and class "A" is in a namespace "lldb", and the
   // namespace is in a compile unit, there will be a stack of DIEs:
   //
   //   [0] DW_TAG_class_type for "B"
   //   [1] DW_TAG_class_type for "A"
   //   [2] DW_TAG_namespace  for "lldb"
-  //   [3] DW_TAG_compile_unit for the source file.
+  //   [3] DW_TAG_compile_unit or DW_TAG_partial_unit for the source file.
   //
   // We grab both contexts and make sure that everything matches
   // all the way back to the compiler unit.
 
   // First lets grab the decl contexts for both DIEs
   die1.GetDeclContextDIEs(decl_ctx_1);
   die2.GetDeclContextDIEs(decl_ctx_2);
   // Make sure the context arrays have the same size, otherwise
for (i = 0; i < count1; i++) {
     decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex(i);
     decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex(i);
     if (decl_ctx_die1.Tag() != decl_ctx_die2.Tag())
       return false;
   }
 #if defined LLDB_CONFIGURATION_DEBUG
 
   // Make sure the top item in the decl context die array is always
-  // DW_TAG_compile_unit. If it isn't then something went wrong in
-  // the DWARFDIE::GetDeclContextDIEs() function...
-  assert(decl_ctx_1.GetDIEAtIndex(count1 - 1).Tag() == DW_TAG_compile_unit);
+  // DW_TAG_compile_unit or DW_TAG_partial_unit. If it isn't then something
+  // went wrong in the DWARFDIE::GetDeclContextDIEs() function...
+  dw_tag_t cu_tag = decl_ctx_1.GetDIEAtIndex(count1 - 1).Tag();
+  UNUSED_IF_ASSERT_DISABLED(cu_tag);
+  assert(cu_tag == DW_TAG_compile_unit || cu_tag == DW_TAG_partial_unit);
 
 #endif
   // Always skip the compile unit when comparing by only iterating up to
   // "count - 1". Here we compare the names as we go.
   for (i = 0; i < count1 - 1; i++) {
     decl_ctx_die1 = decl_ctx_1.GetDIEAtIndex(i);
     decl_ctx_die2 = decl_ctx_2.GetDIEAtIndex(i);
     const char *name1 = decl_ctx_die1.GetName();
if (num_attributes > 0) {
             break;
           }
         }
       }
 
       const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
       const dw_tag_t parent_tag = die.GetParent().Tag();
       bool is_static_member =
-          parent_tag == DW_TAG_compile_unit &&
+          (parent_tag == DW_TAG_compile_unit ||
+           parent_tag == DW_TAG_partial_unit) &&
           (parent_context_die.Tag() == DW_TAG_class_type ||
            parent_context_die.Tag() == DW_TAG_structure_type);
 
       ValueType scope = eValueTypeInvalid;
 
       const DWARFDIE sc_parent_die = GetParentSymbolContextDIE(die);
       SymbolContextScope *symbol_context_scope = NULL;
 
       bool has_explicit_mangled = mangled != nullptr;
       if (!mangled) {
         // LLDB relies on the mangled name (DW_TAG_linkage_name or
         // DW_AT_MIPS_linkage_name) to
         // generate fully qualified names of global variables with commands like
         // "frame var j".
         // For example, if j were an int variable holding a value 4 and declared
         // in a namespace
         // B which in turn is contained in a namespace A, the command "frame var
         // j" returns
         // "(int) A::B::j = 4". If the compiler does not emit a linkage name, we
         // should be able
         // to generate a fully qualified name from the declaration context.
-        if (parent_tag == DW_TAG_compile_unit &&
+        if ((parent_tag == DW_TAG_compile_unit ||
+             parent_tag == DW_TAG_partial_unit) &&
             Language::LanguageIsCPlusPlus(die.GetLanguage())) {
           DWARFDeclContext decl_ctx;
 
           die.GetDWARFDeclContext(decl_ctx);
           mangled = decl_ctx.GetQualifiedNameAsConstString().GetCString();
         }
       }
 
if (var_sp) {
       // We haven't already parsed it, lets do that now.
       if ((tag == DW_TAG_variable) || (tag == DW_TAG_constant) ||
           (tag == DW_TAG_formal_parameter && sc.function)) {
         if (variable_list_sp.get() == NULL) {
           DWARFDIE sc_parent_die = GetParentSymbolContextDIE(orig_die);
           dw_tag_t parent_tag = sc_parent_die.Tag();
           switch (parent_tag) {
           case DW_TAG_compile_unit:
+          case DW_TAG_partial_unit:
             if (sc.comp_unit != NULL) {
               variable_list_sp = sc.comp_unit->GetVariableList(false);
               if (variable_list_sp.get() == NULL) {
                 variable_list_sp.reset(new VariableList());
                 sc.comp_unit->SetVariableList(variable_list_sp);
               }
             } else {
               GetObjectFile()->GetModule()->ReportError(

source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.cpp

if (udt.m_die.Tag() == die.Tag()) {
                   if (parent_pos_die_name == NULL ||
                       ((parent_arg_die_name != parent_pos_die_name) &&
                        strcmp(parent_arg_die_name, parent_pos_die_name)))
                     match = false;
                 }
               } break;
 
               case DW_TAG_compile_unit:
+              case DW_TAG_partial_unit:
                 done = true;
                 break;
               }
             }
             parent_arg_die = parent_arg_die.GetParent();
             parent_pos_die = parent_pos_die.GetParent();
           }