1/2: [nfc] [lldb] Unindent code

[jankratochvil]

Summary

It removes some needless deep indentation and some redundant statements.
It prepares the code for a more clean next patch - DWARF index callbacks D77327.

[kwk]

Overall looks good to me except for one larger logic change. Maybe a your comment can clarify this. The code was in a very bad shape before, given the countless amounts of shortcuts you could take.

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

2014

I assume this can be removed because you're iterating over num_matches == 0 when it's empty. But I cannot tell about the DWARFDebugInfo &debug_info = dwarf->DebugInfo(); and how costly this call is and if it makes sense to run when the offsets are empty.

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

524–525

Why is the if no longer needed?

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

2061

Nice shortcut.

2943

This looks like a logic change and I wonder if it should go in a separate patch, maybe?

[aprantl]

I am generally very okay with this change, though some changes look suspicious, as @kwk noted.

[jankratochvil]

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

2014

I did not put an attention to it, thanks for catching it. Personally I think it is OK but when it has been brought up I am fixing this possible performance regression. SymbolFileDWARF::DebugInfo() contains some llvm::call_once(m_info_once_flag which does have some cost.

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

524–525

It will now run DWARFMappedHash::ExtractDIEArray on empty array which is cheap, it does nothing.

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

2943

This should be NFC, do I miss something?
From:

if (a == b) {
  c;
}

The patch changes it to:

if (a != b)
  continue;
c;

[shafik]

I feel like this should have been split in two. It feels like there are straight forward obviously correct changes and a several others that require some thinking about but look correct.

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

524–525

If we stick with this change, please add a comment explaining this. It is not obvious and someone later on may come and change it back thinking this is a bug.

[aprantl]

In D77326#1958082, @shafik wrote:

I feel like this should have been split in two. It feels like there are straight forward obviously correct changes and a several others that require some thinking about but look correct.

That's a really good point. I agree. Can you split all changes of one kind into separate patches?

[kwk]

No need to split this into multiples revisions. It is just a rewrite of some odd nesting.

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

2943

Ah, now I see that it was previously a block on the right side of the diff :).

[jankratochvil]

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

524–525

I have rather dropped this part of this refactorization patch. It will look more logical together with changes of the next part D77327. Thanks for the comments.

[jankratochvil]

I have checked in the really obvious parts as rG80237523193d.
The remainder is left here - although I do not see there more problematic parts now.

[clayborg]

Does anyone know why harbormaster is useless?

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

2014

not costly at all. This will be fine.

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

70–71

This logic is easy to understand by reading the code.

70–82

This logic is harder to follow. Maybe:

if (!(die_tag == 0 || die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type))
  continue;

[jankratochvil]

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

70–82

OK, changed it.
I will follow this also IMO more readable form, I changed it since a 10 years old review but that does not matter anymore.

[labath]

Looks good to me, but let's wait for @shafik and @aprantl to take a look.

[aprantl]

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

2015

Can this be made into a range-based for loop in a separate commit?

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

2057–2063

same here (later)

2915

These two continues IMO are a bit confusing to read this way. Perhaps in this case an if (log) block with just one continue at the end is easier to read. Up to you.

2951

I think I'd prefer a return over a break, (iff they are equivalent!).

[shafik]

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

69–70

I also feel like the previous version was more readable. Is there another gain that I am missing?

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

2065–2071

This whole switch feels overly clever, how about:

if (die.Tag() != DW_TAG_variable)
  continue;

[jankratochvil]

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

2015

In D77327 it gets changed into a callback anyway so method_die_offsets no longer exists there.

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

69–70

I find both versions OK but this patch is going to revert my change in rG80237523193d so everyone should be happy.

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

2057–2063

In D77327 it gets changed into a callback anyway so die_offsets no longer exists there.

2915

OK, changed back to if (log) { ... }. I even was not sure with that.

[jankratochvil]

Implemented all the review comments.

[jankratochvil]

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

2935

This break cannot be changed to return as in D77327 it will become a callback lambda.

2951

Wrote above - This break cannot be changed to return as in D77327 it will become a callback lambda.

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

return std::make_unique<AppleDWARFIndex>(
         module, std::move(apple_names_table_up),
         std::move(apple_namespaces_table_up), std::move(apple_types_table_up),
         std::move(apple_objc_table_up));
 
   return nullptr;
 }
 
 void AppleDWARFIndex::GetGlobalVariables(ConstString basename, DIEArray &offsets) {
-  if (m_apple_names_up)
-    m_apple_names_up->FindByName(basename.GetStringRef(), offsets);
+  if (!m_apple_names_up)
+    return;
 }
 
 void AppleDWARFIndex::GetGlobalVariables(const RegularExpression &regex,
                                          DIEArray &offsets) {
   if (!m_apple_names_up)
     return;
 
   DWARFMappedHash::DIEInfoArray hash_data;
void AppleDWARFIndex::GetGlobalVariables(const DWARFUnit &cu,
   DWARFMappedHash::DIEInfoArray hash_data;
   if (m_apple_names_up->AppendAllDIEsInRange(cu.GetOffset(),
                                              cu.GetNextUnitOffset(), hash_data))
     DWARFMappedHash::ExtractDIEArray(hash_data, offsets);
 }
 
 void AppleDWARFIndex::GetObjCMethods(ConstString class_name,
                                      DIEArray &offsets) {
-  if (m_apple_objc_up)
-    m_apple_objc_up->FindByName(class_name.GetStringRef(), offsets);
+  if (!m_apple_objc_up)
+    return;
 }
 
 void AppleDWARFIndex::GetCompleteObjCClass(ConstString class_name,
                                            bool must_be_implementation,
                                            DIEArray &offsets) {
-  if (m_apple_types_up) {
-    m_apple_types_up->FindCompleteObjCClassByName(
-        class_name.GetStringRef(), offsets, must_be_implementation);
-  }
-}
+  if (!m_apple_types_up)
+    return;
 
 void AppleDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
-  if (m_apple_types_up)
-    m_apple_types_up->FindByName(name.GetStringRef(), offsets);
+  if (!m_apple_types_up)
+    return;
 }
 
 void AppleDWARFIndex::GetTypes(const DWARFDeclContext &context,
                                DIEArray &offsets) {
   if (!m_apple_types_up)
     return;
 
   Log *log = LogChannelDWARF::GetLogIfAny(DWARF_LOG_TYPE_COMPLETION |
if (has_tag) {
     m_apple_types_up->FindByNameAndTag(type_name.GetStringRef(), tag, offsets);
     return;
   }
 
   m_apple_types_up->FindByName(type_name.GetStringRef(), offsets);
 }
 
 void AppleDWARFIndex::GetNamespaces(ConstString name, DIEArray &offsets) {
-  if (m_apple_namespaces_up)
-    m_apple_namespaces_up->FindByName(name.GetStringRef(), offsets);
+  if (!m_apple_namespaces_up)
+    return;
 }
 
 void AppleDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
                                    const CompilerDeclContext &parent_decl_ctx,
                                    uint32_t name_type_mask,
                                    std::vector<DWARFDIE> &dies) {
   DIEArray offsets;
   m_apple_names_up->FindByName(name.GetStringRef(), offsets);

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

for (const DWARFDIE &die : member_function_dies)
       dwarf->ResolveType(die);
 
     if (class_language == eLanguageTypeObjC) {
       ConstString class_name(clang_type.GetTypeName());
       if (class_name) {
         DIEArray method_die_offsets;
         dwarf->GetObjCMethodDIEOffsets(class_name, method_die_offsets);
 
-        if (!method_die_offsets.empty()) {
-          DWARFDebugInfo &debug_info = dwarf->DebugInfo();
+        DWARFDebugInfo *debug_infop = nullptr;
 
-          const size_t num_matches = method_die_offsets.size();
-          for (size_t i = 0; i < num_matches; ++i) {
-            const DIERef &die_ref = method_die_offsets[i];
-            DWARFDIE method_die = debug_info.GetDIE(die_ref);
+          if (!debug_infop)
+            debug_infop = &dwarf->DebugInfo();
+          DWARFDIE method_die = debug_infop->GetDIE(die_ref);
 
-            if (method_die)
-              method_die.ResolveType();
-          }
-        }
 
         for (DelayedPropertyList::iterator pi = delayed_properties.begin(),
                                            pe = delayed_properties.end();
              pi != pe; ++pi)
           pi->Finalize();
       }
     }
 

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

public:
 
   DWARFDeclContext() : m_entries(), m_language(lldb::eLanguageTypeUnknown) {}
 
   void AppendDeclContext(dw_tag_t tag, const char *name) {
     m_entries.push_back(Entry(tag, name));
   }
 
   bool operator==(const DWARFDeclContext &rhs) const;
+  bool operator!=(const DWARFDeclContext &rhs) const { return !(*this == rhs); }
 
   uint32_t GetSize() const { return m_entries.size(); }
 
   Entry &operator[](uint32_t idx) {
     // "idx" must be valid
     return m_entries[idx];
   }
 

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

for (const DebugNames::Entry &entry :
     DWARFDIE die = m_debug_info.GetDIE(*ref);
     if (!die)
       continue;
 
     if (die.GetAttributeValueAsUnsigned(DW_AT_APPLE_objc_complete_type, 0)) {
       // If we find the complete version we're done.
       offsets.push_back(*ref);
       return;
-    } else {
-      incomplete_types.push_back(*ref);
     }
+    incomplete_types.push_back(*ref);
   }
 
   offsets.insert(offsets.end(), incomplete_types.begin(),
                  incomplete_types.end());
 }
 
 void DebugNamesDWARFIndex::GetTypes(ConstString name, DIEArray &offsets) {
   m_fallback.GetTypes(name, offsets);

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

for (size_t i = 0; i < count; ++i)
     die_offsets.emplace_back(die_info_array[i]);
 }
 
 void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
                                       const dw_tag_t tag,
                                       DIEArray &die_offsets) {
   if (tag == 0) {
     ExtractDIEArray(die_info_array, die_offsets);
-  } else {
-    const size_t count = die_info_array.size();
-    for (size_t i = 0; i < count; ++i) {
-      const dw_tag_t die_tag = die_info_array[i].tag;
-      bool tag_matches = die_tag == 0 || tag == die_tag;
-      if (!tag_matches) {
-        if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
-          tag_matches =
-              tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
-      }
-      if (tag_matches)
-        die_offsets.emplace_back(die_info_array[i]);
-    }
-  }
-}
+    return;
+  }
+
+        tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
 
 void DWARFMappedHash::ExtractDIEArray(const DIEInfoArray &die_info_array,
                                       const dw_tag_t tag,
                                       const uint32_t qualified_name_hash,
                                       DIEArray &die_offsets) {
   if (tag == 0) {
     ExtractDIEArray(die_info_array, die_offsets);
-  } else {
-    const size_t count = die_info_array.size();
-    for (size_t i = 0; i < count; ++i) {
-      if (qualified_name_hash != die_info_array[i].qualified_name_hash)
-        continue;
-      const dw_tag_t die_tag = die_info_array[i].tag;
-      bool tag_matches = die_tag == 0 || tag == die_tag;
-      if (!tag_matches) {
-        if (die_tag == DW_TAG_class_type || die_tag == DW_TAG_structure_type)
-          tag_matches =
-              tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
-      }
-      if (tag_matches)
-        die_offsets.emplace_back(die_info_array[i]);
-    }
-  }
-}
+    return;
+  }
+
+        tag_matches = tag == DW_TAG_structure_type || tag == DW_TAG_class_type;
 
 void DWARFMappedHash::ExtractClassOrStructDIEArray(
     const DIEInfoArray &die_info_array,
     bool return_implementation_only_if_available, DIEArray &die_offsets) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     const dw_tag_t die_tag = die_info_array[i].tag;
-    if (die_tag == 0 || die_tag == DW_TAG_class_type ||
-        die_tag == DW_TAG_structure_type) {
-      if (die_info_array[i].type_flags & eTypeFlagClassIsImplementation) {
-        if (return_implementation_only_if_available) {
-          // We found the one true definition for this class, so only return
-          // that
-          die_offsets.clear();
-          die_offsets.emplace_back(die_info_array[i]);
-          return;
-        } else {
-          // Put the one true definition as the first entry so it matches first
-          die_offsets.emplace(die_offsets.begin(), die_info_array[i]);
-        }
-      } else {
-        die_offsets.emplace_back(die_info_array[i]);
-      }
-    }
-  }
-}
+    if (die_tag != 0 && die_tag != DW_TAG_class_type &&
+        die_tag != DW_TAG_structure_type)
+      continue;
 
 void DWARFMappedHash::ExtractTypesFromDIEArray(
     const DIEInfoArray &die_info_array, uint32_t type_flag_mask,
     uint32_t type_flag_value, DIEArray &die_offsets) {
   const size_t count = die_info_array.size();
   for (size_t i = 0; i < count; ++i) {
     if ((die_info_array[i].type_flags & type_flag_mask) == type_flag_value)
       die_offsets.emplace_back(die_info_array[i]);

 }
 
 size_t DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
                                                 DIEArray &die_offsets) {
   if (name.empty())
     return 0;
 
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array))
-    DWARFMappedHash::ExtractDIEArray(die_info_array, die_offsets);
+  FindByName(name, die_info_array);
   return die_info_array.size();
 }
 
 size_t DWARFMappedHash::MemoryTable::FindByNameAndTag(llvm::StringRef name,
                                                       const dw_tag_t tag,
                                                       DIEArray &die_offsets) {
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array))
-    DWARFMappedHash::ExtractDIEArray(die_info_array, tag, die_offsets);
+  FindByName(name, die_info_array);
   return die_info_array.size();
 }
 
 size_t DWARFMappedHash::MemoryTable::FindByNameAndTagAndQualifiedNameHash(
     llvm::StringRef name, const dw_tag_t tag,
     const uint32_t qualified_name_hash, DIEArray &die_offsets) {
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array))
-    DWARFMappedHash::ExtractDIEArray(die_info_array, tag, qualified_name_hash,
-                                     die_offsets);
+  FindByName(name, die_info_array);
   return die_info_array.size();
 }
 
 size_t DWARFMappedHash::MemoryTable::FindCompleteObjCClassByName(
     llvm::StringRef name, DIEArray &die_offsets, bool must_be_implementation) {
   DIEInfoArray die_info_array;
-  if (FindByName(name, die_info_array)) {
-    if (must_be_implementation &&
-        GetHeader().header_data.ContainsAtom(eAtomTypeTypeFlags)) {
-      // If we have two atoms, then we have the DIE offset and the type flags
-      // so we can find the objective C class efficiently.
-      DWARFMappedHash::ExtractTypesFromDIEArray(die_info_array, UINT32_MAX,
-                                                eTypeFlagClassIsImplementation,
-                                                die_offsets);
-    } else {
-      // We don't only want the one true definition, so try and see what we can
-      // find, and only return class or struct DIEs. If we do have the full
-      // implementation, then return it alone, else return all possible
-      // matches.
-      const bool return_implementation_only_if_available = true;
-      DWARFMappedHash::ExtractClassOrStructDIEArray(
-          die_info_array, return_implementation_only_if_available, die_offsets);
-    }
-  }
+  FindByName(name, die_info_array);
+    return die_offsets.size();
+  }
   return die_offsets.size();
 }
 
 size_t DWARFMappedHash::MemoryTable::FindByName(llvm::StringRef name,
                                                 DIEInfoArray &die_info_array) {
   if (name.empty())
     return 0;
 
   Pair kv_pair;
   size_t old_size = die_info_array.size();
   if (Find(name, kv_pair)) {
     die_info_array.swap(kv_pair.value);
     return die_info_array.size() - old_size;
   }
   return 0;
 }

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

void ManualDWARFIndex::GetFunctions(ConstString name, SymbolFileDWARF &dwarf,
 
   if (name_type_mask & eFunctionNameTypeFull) {
     DIEArray offsets;
     m_set.function_fullnames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
       DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-        dies.push_back(die);
+      if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
+        continue;
     }
   }
   if (name_type_mask & eFunctionNameTypeBase) {
     DIEArray offsets;
     m_set.function_basenames.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
       DWARFDIE die = dwarf.GetDIE(die_ref);
       if (!die)
         continue;
-      if (SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
-        dies.push_back(die);
+      if (!SymbolFileDWARF::DIEInDeclContext(parent_decl_ctx, die))
+        continue;
     }
-    offsets.clear();
   }
 
   if (name_type_mask & eFunctionNameTypeMethod && !parent_decl_ctx.IsValid()) {
     DIEArray offsets;
     m_set.function_methods.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
-      if (DWARFDIE die = dwarf.GetDIE(die_ref))
-        dies.push_back(die);
+      DWARFDIE die = dwarf.GetDIE(die_ref);
+      if (!die)
+        continue;
     }
   }
 
   if (name_type_mask & eFunctionNameTypeSelector &&
       !parent_decl_ctx.IsValid()) {
     DIEArray offsets;
     m_set.function_selectors.Find(name, offsets);
     for (const DIERef &die_ref: offsets) {
-      if (DWARFDIE die = dwarf.GetDIE(die_ref))
-        dies.push_back(die);
+      DWARFDIE die = dwarf.GetDIE(die_ref);
+      if (!die)
+        continue;
     }
   }
 }
 
 void ManualDWARFIndex::GetFunctions(const RegularExpression &regex,
                                     DIEArray &offsets) {
   Index();
 

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

void SymbolFileDWARF::FindGlobalVariables(
 
   if (!CPlusPlusLanguage::ExtractContextAndIdentifier(name.GetCString(),
                                                       context, basename))
     basename = name.GetStringRef();
 
   DIEArray die_offsets;
   m_index->GetGlobalVariables(ConstString(basename), die_offsets);
   const size_t num_die_matches = die_offsets.size();
-  if (num_die_matches) {
-    SymbolContext sc;
-    sc.module_sp = m_objfile_sp->GetModule();
-    assert(sc.module_sp);
+
 
-    // Loop invariant: Variables up to this index have been checked for context
-    // matches.
-    uint32_t pruned_idx = original_size;
 
-    bool done = false;
-    for (size_t i = 0; i < num_die_matches && !done; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE die = GetDIE(die_ref);
+  for (size_t i = 0; i < num_die_matches; ++i) {
+    if (!die) {
+      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+      continue;
+    }
 
-      if (die) {
-        switch (die.Tag()) {
-        default:
-        case DW_TAG_subprogram:
-        case DW_TAG_inlined_subroutine:
-        case DW_TAG_try_block:
-        case DW_TAG_catch_block:
-          break;
+      continue;
 
-        case DW_TAG_variable: {
-          auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
-          if (!dwarf_cu)
-            continue;
-          sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
+    case DW_TAG_variable:
+      break;
+    }
 
-          if (parent_decl_ctx) {
-            if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
-              CompilerDeclContext actual_parent_decl_ctx =
-                  dwarf_ast->GetDeclContextContainingUIDFromDWARF(die);
-              if (!actual_parent_decl_ctx ||
-                  actual_parent_decl_ctx != parent_decl_ctx)
-                continue;
-            }
-          }
 
-          ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false,
-                         &variables);
-          while (pruned_idx < variables.GetSize()) {
-            VariableSP var_sp = variables.GetVariableAtIndex(pruned_idx);
-            if (name_is_mangled ||
-                var_sp->GetName().GetStringRef().contains(name.GetStringRef()))
-              ++pruned_idx;
-            else
-              variables.RemoveVariableAtIndex(pruned_idx);
-          }
+    ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
-          if (variables.GetSize() - original_size >= max_matches)
-            done = true;
-        } break;
-        }
-      } else {
-        m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      }
-    }
+      break;
   }
 
   // Return the number of variable that were appended to the list
   const uint32_t num_matches = variables.GetSize() - original_size;
   if (log && num_matches > 0) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
void SymbolFileDWARF::FindGlobalVariables(const RegularExpression &regex,
   DIEArray die_offsets;
   m_index->GetGlobalVariables(regex, die_offsets);
 
   SymbolContext sc;
   sc.module_sp = m_objfile_sp->GetModule();
   assert(sc.module_sp);
 
   const size_t num_matches = die_offsets.size();
-  if (num_matches) {
-    for (size_t i = 0; i < num_matches; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE die = GetDIE(die_ref);
+    if (!die) {
+      m_index->ReportInvalidDIERef(die_ref, regex.GetText());
+      continue;
+    }
 
-      if (die) {
-        DWARFCompileUnit *dwarf_cu =
-            llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
-        if (!dwarf_cu)
-          continue;
-        sc.comp_unit = GetCompUnitForDWARFCompUnit(*dwarf_cu);
+    DWARFCompileUnit *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(die.GetCU());
 
-        ParseVariables(sc, die, LLDB_INVALID_ADDRESS, false, false, &variables);
 
-        if (variables.GetSize() - original_size >= max_matches)
-          break;
-      } else
-        m_index->ReportInvalidDIERef(die_ref, regex.GetText());
-    }
   }
 }
 
 bool SymbolFileDWARF::ResolveFunction(const DWARFDIE &orig_die,
                                       bool include_inlines,
                                       SymbolContextList &sc_list) {
   SymbolContext sc;
 
if (name.IsEmpty())
     return;
 
   // Remember how many sc_list are in the list before we search in case we are
   // appending the results to a variable list.
 
   const uint32_t original_size = sc_list.GetSize();
 
   llvm::DenseSet<const DWARFDebugInfoEntry *> resolved_dies;
-  DIEArray offsets;
 
   std::vector<DWARFDIE> dies;
   m_index->GetFunctions(name, *this, parent_decl_ctx, name_type_mask, dies);
   for (const DWARFDIE &die : dies) {
     if (resolved_dies.insert(die.GetDIE()).second)
       ResolveFunction(die, include_inlines, sc_list);
   }
 
void SymbolFileDWARF::FindTypes(
 
   DIEArray die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   for (size_t i = 0; i < num_die_matches; ++i) {
     const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
-    if (die) {
-      if (!DIEInDeclContext(parent_decl_ctx, die))
-        continue; // The containing decl contexts don't match
+    if (!die) {
+      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+      continue;
+    }
+
 
-      Type *matching_type = ResolveType(die, true, true);
-      if (matching_type) {
-        // We found a type pointer, now find the shared pointer form our type
-        // list
-        types.InsertUnique(matching_type->shared_from_this());
-        if (types.GetSize() >= max_matches)
-          break;
-      }
-    } else {
-      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-    }
-  }
+    if (!matching_type)
+      continue;
+
 
   // Next search through the reachable Clang modules. This only applies for
   // DWARF objects compiled with -gmodules that haven't been processed by
   // dsymutil.
   if (num_die_matches < max_matches) {
     UpdateExternalModuleListIfNeeded();
 
     for (const auto &pair : m_external_type_modules)
void SymbolFileDWARF::FindTypes(
 
   DIEArray die_offsets;
   m_index->GetTypes(name, die_offsets);
   const size_t num_die_matches = die_offsets.size();
 
   for (size_t i = 0; i < num_die_matches; ++i) {
     const DIERef &die_ref = die_offsets[i];
     DWARFDIE die = GetDIE(die_ref);
-
     if (!die) {
       m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
       continue;
     }
+
     if (!languages[GetLanguage(*die.GetCU())])
       continue;
 
     llvm::SmallVector<CompilerContext, 4> die_context;
     die.GetDeclContext(die_context);
     if (!contextMatches(die_context, pattern))
       continue;
 
SymbolFileDWARF::FindNamespace(ConstString name,
   CompilerDeclContext namespace_decl_ctx;
 
   if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
     return namespace_decl_ctx;
 
   DIEArray die_offsets;
   m_index->GetNamespaces(name, die_offsets);
   const size_t num_matches = die_offsets.size();
-  if (num_matches) {
-    for (size_t i = 0; i < num_matches; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE die = GetDIE(die_ref);
+    if (!die) {
+      m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
+      continue;
+    }
 
-      if (die) {
-        if (!DIEInDeclContext(parent_decl_ctx, die))
-          continue; // The containing decl contexts don't match
 
-        if (DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU())) {
-          namespace_decl_ctx = dwarf_ast->GetDeclContextForUIDFromDWARF(die);
-          if (namespace_decl_ctx)
-            break;
-        }
-      } else {
-        m_index->ReportInvalidDIERef(die_ref, name.GetStringRef());
-      }
-    }
-  }
+    DWARFASTParser *dwarf_ast = GetDWARFParser(*die.GetCU());
+    if (!dwarf_ast)
+      continue;
+
   if (log && namespace_decl_ctx) {
     GetObjectFile()->GetModule()->LogMessage(
         log,
         "SymbolFileDWARF::FindNamespace (sc, name=\"%s\") => "
         "CompilerDeclContext(%p/%p) \"%s\"",
         name.GetCString(),
         static_cast<const void *>(namespace_decl_ctx.GetTypeSystem()),
         static_cast<const void *>(namespace_decl_ctx.GetOpaqueDeclContext()),
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
   if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
     return type_sp;
 
   DIEArray die_offsets;
   m_index->GetCompleteObjCClass(type_name, must_be_implementation, die_offsets);
 
   const size_t num_matches = die_offsets.size();
 
-  if (num_matches) {
-    for (size_t i = 0; i < num_matches; ++i) {
-      const DIERef &die_ref = die_offsets[i];
-      DWARFDIE type_die = GetDIE(die_ref);
+    if (!type_die) {
+      m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
+      continue;
+    }
 
-      if (type_die) {
-        bool try_resolving_type = false;
 
-        // Don't try and resolve the DIE we are looking for with the DIE
-        // itself!
-        if (type_die != die) {
-          switch (type_die.Tag()) {
-          case DW_TAG_class_type:
-          case DW_TAG_structure_type:
-            try_resolving_type = true;
-            break;
-          default:
-            break;
-          }
-        }
+    if (!try_resolving_type)
+      continue;
 
-        if (try_resolving_type) {
-          if (must_be_implementation &&
-              type_die.Supports_DW_AT_APPLE_objc_complete_type())
-            try_resolving_type = type_die.GetAttributeValueAsUnsigned(
-                DW_AT_APPLE_objc_complete_type, 0);
+    if (!try_resolving_type)
+      continue;
 
-          if (try_resolving_type) {
-            Type *resolved_type = ResolveType(type_die, false, true);
-            if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
-              DEBUG_PRINTF("resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
-                           " (cu 0x%8.8" PRIx64 ")\n",
-                           die.GetID(),
-                           m_objfile_sp->GetFileSpec().GetFilename().AsCString(
-                               "<Unknown>"),
-                           type_die.GetID(), type_cu->GetID());
+    if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
+      continue;
+
+    DEBUG_PRINTF(
+        "resolved 0x%8.8" PRIx64 " from %s to 0x%8.8" PRIx64
+        m_objfile_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
 
-              if (die)
-                GetDIEToType()[die.GetDIE()] = resolved_type;
-              type_sp = resolved_type->shared_from_this();
-              break;
-            }
-          }
-        }
-      } else {
-        m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
-      }
-    }
-  }
   return type_sp;
 }
 
 // This function helps to ensure that the declaration contexts match for two
 // different DIEs. Often times debug information will refer to a forward
 // declaration of a type (the equivalent of "struct my_struct;". There will
 // often be a declaration of that type elsewhere that has the full definition.
 // When we go looking for the full type "my_struct", we will find one or more
if (type_name) {
           LLDB_LOG_ERROR(
               lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
               std::move(err), "Cannot get TypeSystem for language {}",
               Language::GetNameForLanguageType(language));
         } else {
           type_system = &type_system_or_err.get();
         }
       }
-      if (num_matches) {
-        for (size_t i = 0; i < num_matches; ++i) {
-          const DIERef &die_ref = die_offsets[i];
-          DWARFDIE type_die = GetDIE(die_ref);
+        if (!type_die) {
+          m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
+          continue;
+        }
 
-          if (type_die) {
-            // Make sure type_die's langauge matches the type system we are
-            // looking for. We don't want to find a "Foo" type from Java if we
-            // are looking for a "Foo" type for C, C++, ObjC, or ObjC++.
-            if (type_system &&
-                !type_system->SupportsLanguage(GetLanguage(*type_die.GetCU())))
-              continue;
-            bool try_resolving_type = false;
 
-            // Don't try and resolve the DIE we are looking for with the DIE
-            // itself!
-            const dw_tag_t type_tag = type_die.Tag();
-            // Make sure the tags match
-            if (type_tag == tag) {
-              // The tags match, lets try resolving this type
-              try_resolving_type = true;
-            } else {
-              // The tags don't match, but we need to watch our for a forward
-              // declaration for a struct and ("struct foo") ends up being a
-              // class ("class foo { ... };") or vice versa.
-              switch (type_tag) {
-              case DW_TAG_class_type:
-                // We had a "class foo", see if we ended up with a "struct foo
-                // { ... };"
-                try_resolving_type = (tag == DW_TAG_structure_type);
-                break;
-              case DW_TAG_structure_type:
-                // We had a "struct foo", see if we ended up with a "class foo
-                // { ... };"
-                try_resolving_type = (tag == DW_TAG_class_type);
-                break;
-              default:
-                // Tags don't match, don't event try to resolve using this type
-                // whose name matches....
-                break;
-              }
-            }
 
-            if (try_resolving_type) {
-              DWARFDeclContext type_dwarf_decl_ctx =
-                  GetDWARFDeclContext(type_die);
-
-              if (log) {
-                GetObjectFile()->GetModule()->LogMessage(
-                    log,
-                    "SymbolFileDWARF::"
-                    "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
-                    "qualified-name='%s') trying die=0x%8.8x (%s)",
-                    DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
-                    dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
-                    type_dwarf_decl_ctx.GetQualifiedName());
-              }
+        if (!try_resolving_type) {
+          if (!log)
+            continue;
+          std::string qualified_name;
+          type_die.GetQualifiedName(qualified_name);
+              "qualified-name='%s') ignoring die=0x%8.8x (%s)",
+              qualified_name.c_str());
+          continue;
 
-              // Make sure the decl contexts match all the way up
-              if (dwarf_decl_ctx == type_dwarf_decl_ctx) {
-                Type *resolved_type = ResolveType(type_die, false);
-                if (resolved_type && resolved_type != DIE_IS_BEING_PARSED) {
-                  type_sp = resolved_type->shared_from_this();
-                  break;
-                }
-              }
-            } else {
-              if (log) {
-                std::string qualified_name;
-                type_die.GetQualifiedName(qualified_name);
-                GetObjectFile()->GetModule()->LogMessage(
-                    log,
-                    "SymbolFileDWARF::"
-                    "FindDefinitionTypeForDWARFDeclContext(tag=%s, "
-                    "qualified-name='%s') ignoring die=0x%8.8x (%s)",
-                    DW_TAG_value_to_name(dwarf_decl_ctx[0].tag),
-                    dwarf_decl_ctx.GetQualifiedName(), type_die.GetOffset(),
-                    qualified_name.c_str());
-              }
-            }
-          } else {
-            m_index->ReportInvalidDIERef(die_ref, type_name.GetStringRef());
-          }
+        DWARFDeclContext type_dwarf_decl_ctx = GetDWARFDeclContext(type_die);
+
+              "qualified-name='%s') trying die=0x%8.8x (%s)",
+              type_dwarf_decl_ctx.GetQualifiedName());
         }
+
+        // Make sure the decl contexts match all the way up
+        if (dwarf_decl_ctx != type_dwarf_decl_ctx)
+          continue;
+
+        Type *resolved_type = ResolveType(type_die, false);
+        if (!resolved_type || resolved_type == DIE_IS_BEING_PARSED)
+          continue;
+
+        type_sp = resolved_type->shared_from_this();
+        break;
       }
     }
   }
   return type_sp;
 }
 
 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
                                   bool *type_is_new_ptr) {
if (sc.function) {
       if (variables.get() == nullptr) {
         variables = std::make_shared<VariableList>();
         sc.comp_unit->SetVariableList(variables);
 
         DIEArray die_offsets;
         m_index->GetGlobalVariables(dwarf_cu->GetNonSkeletonUnit(),
                                     die_offsets);
         const size_t num_matches = die_offsets.size();
-        if (num_matches) {
-          for (size_t i = 0; i < num_matches; ++i) {
-            const DIERef &die_ref = die_offsets[i];
-            DWARFDIE die = GetDIE(die_ref);
-            if (die) {
-              VariableSP var_sp(
-                  ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
-              if (var_sp) {
-                variables->AddVariableIfUnique(var_sp);
-                ++vars_added;
-              }
-            } else
-              m_index->ReportInvalidDIERef(die_ref, "");
-          }
+          if (!die) {
+            m_index->ReportInvalidDIERef(die_ref, "");
+            continue;
+          }
+
+          VariableSP var_sp(ParseVariableDIE(sc, die, LLDB_INVALID_ADDRESS));
         }
       }
       return vars_added;
     }
   }
   return 0;
 }