DWZ 02/06: Refactor DWARFUnit::ExtractDIEsScoped

[jankratochvil]

Summary

Change the method of construction from:

DWARFUnit::ScopedExtractDIEs DWARFUnit::ExtractDIEsScoped()

to:

DWARFUnit::ScopedExtractDIEs::ScopedExtractDIEs(DWARFUnit *cu)

So that a later patch can implement:

std::unordered_map<const DWARFUnit *, DWARFUnit::ScopedExtractDIEs>
    .emplace(DWARFUnit *,DWARFUnit *)

so that if the map element already exists DWARFUnit::ScopedExtractDIEs is not temporarily constructed. If the caller called DWARFUnit::ExtractDIEsScoped() as an emplace parameter it would get constructed already in the caller.
Patch also contains what I considered as a general cleanup.

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

[jankratochvil]

This change is no longer needed.

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

 
 public:
   virtual ~DWARFUnit();
 
   void ExtractUnitDIEIfNeeded();
   void ExtractDIEsIfNeeded();
 
   class ScopedExtractDIEs {
-    DWARFUnit *m_cu;
   public:
-    bool m_clear_dies = false;
     ScopedExtractDIEs(DWARFUnit *cu);
+    void ClearDIEs() { assert(!m_clear_dies); m_clear_dies = true; }
+    // Do not touch m_cu anymore.
+    void Disable() { m_unlock = false; m_clear_dies = false; }
     ~ScopedExtractDIEs();
-    DISALLOW_COPY_AND_ASSIGN(ScopedExtractDIEs);
     ScopedExtractDIEs(ScopedExtractDIEs &&rhs);
     ScopedExtractDIEs &operator=(ScopedExtractDIEs &&rhs);
+  private:
+    DWARFUnit *m_cu;
+    bool m_clear_dies = false;
+    bool m_unlock;
+    DISALLOW_COPY_AND_ASSIGN(ScopedExtractDIEs);
   };
-  ScopedExtractDIEs ExtractDIEsScoped();
 
   DWARFDIE LookupAddress(const dw_addr_t address);
   size_t AppendDIEsWithTag(const dw_tag_t tag,
                            DWARFDIECollection &matching_dies,
                            uint32_t depth = UINT32_MAX) const;
   bool Verify(lldb_private::Stream *s) const;
   virtual void Dump(lldb_private::Stream *s) const = 0;
   //------------------------------------------------------------------
protected:
 
   // Offset of the initial length field.
   dw_offset_t m_offset;
 
 private:
   void ParseProducerInfo();
   void ExtractDIEsRWLocked();
   void ClearDIEsRWLocked();
+  void ExtractDIEsScoped(ScopedExtractDIEs &scoped);
 
   // Get the DWARF unit DWARF debug informration entry. Parse the single DIE
   // if needed.
   const DWARFDebugInfoEntry *GetUnitDIEPtrOnly() {
     ExtractUnitDIEIfNeeded();
     // m_first_die_mutex is not required as m_first_die is never cleared.
     if (!m_first_die)
       return NULL;

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

 
 //----------------------------------------------------------------------
 // Parses a compile unit and indexes its DIEs if it hasn't already been done.
 // It will clear this compile unit after returned instance gets out of scope,
 // no other ScopedExtractDIEs instance is running for this compile unit
 // and no ExtractDIEsIfNeeded() has been executed during this ScopedExtractDIEs
 // lifetime.
 //----------------------------------------------------------------------
-DWARFUnit::ScopedExtractDIEs DWARFUnit::ExtractDIEsScoped() {
-  ScopedExtractDIEs scoped(this);
-
+void DWARFUnit::ExtractDIEsScoped(ScopedExtractDIEs &scoped) {
   {
     llvm::sys::ScopedReader lock(m_die_array_mutex);
     if (!m_die_array.empty())
-      return scoped; // Already parsed
+      return; // Already parsed
   }
   llvm::sys::ScopedWriter lock(m_die_array_mutex);
   if (!m_die_array.empty())
-    return scoped; // Already parsed
-
-  // Otherwise m_die_array would be already populated.
-  lldbassert(!m_cancel_scopes);
+    return; // Already parsed
 
   ExtractDIEsRWLocked();
-  scoped.m_clear_dies = true;
-  return scoped;
+  scoped.ClearDIEs();
 }
 
 DWARFUnit::ScopedExtractDIEs::ScopedExtractDIEs(DWARFUnit *cu) : m_cu(cu) {
   lldbassert(m_cu);
   m_cu->m_die_array_scoped_mutex.lock_shared();
+  m_unlock = true;
+  m_cu->ExtractDIEsScoped(*this);
 }
 
 DWARFUnit::ScopedExtractDIEs::~ScopedExtractDIEs() {
-  if (!m_cu)
-    return;
+  if (m_unlock)
     m_cu->m_die_array_scoped_mutex.unlock_shared();
   if (!m_clear_dies || m_cu->m_cancel_scopes)
     return;
   // Be sure no other ScopedExtractDIEs is running anymore.
   llvm::sys::ScopedWriter lock_scoped(m_cu->m_die_array_scoped_mutex);
   llvm::sys::ScopedWriter lock(m_cu->m_die_array_mutex);
   if (m_cu->m_cancel_scopes)
     return;
   m_cu->ClearDIEsRWLocked();
 }
 
 DWARFUnit::ScopedExtractDIEs::ScopedExtractDIEs(ScopedExtractDIEs &&rhs)
     : m_cu(rhs.m_cu), m_clear_dies(rhs.m_clear_dies) {
-  rhs.m_cu = nullptr;
+  Disable();
 }
 
 DWARFUnit::ScopedExtractDIEs &DWARFUnit::ScopedExtractDIEs::operator=(
     DWARFUnit::ScopedExtractDIEs &&rhs) {
   m_cu = rhs.m_cu;
-  rhs.m_cu = nullptr;
   m_clear_dies = rhs.m_clear_dies;
+  rhs.Disable();
   return *this;
 }
 
 //----------------------------------------------------------------------
 // Parses a compile unit and indexes its DIEs, m_die_array_mutex must be
 // held R/W and m_die_array must be empty.
 //----------------------------------------------------------------------
 void DWARFUnit::ExtractDIEsRWLocked() {
if (num_ranges > 0) {
       return; // We got all of our ranges from the DW_AT_ranges attribute
     }
   }
   // We don't have a DW_AT_ranges attribute, so we need to parse the DWARF
 
   // If the DIEs weren't parsed, then we don't want all dies for all compile
   // units to stay loaded when they weren't needed. So we can end up parsing
   // the DWARF and then throwing them all away to keep memory usage down.
-  ScopedExtractDIEs clear_dies(ExtractDIEsScoped());
+  ScopedExtractDIEs clear_dies(this);
 
   die = DIEPtr();
   if (die)
     die->BuildAddressRangeTable(dwarf, this, debug_aranges);
 
   if (debug_aranges->GetNumRanges() == num_debug_aranges) {
     // We got nothing from the functions, maybe we have a line tables only
     // situation. Check the line tables and build the arange table from this.

source/Plugins/SymbolFile/DWARF/ManualDWARFIndex.cpp

void ManualDWARFIndex::Index() {
   //----------------------------------------------------------------------
   std::vector<llvm::Optional<DWARFUnit::ScopedExtractDIEs>> clear_cu_dies(
       units_to_index.size());
   auto parser_fn = [&](size_t cu_idx) {
     IndexUnit(*units_to_index[cu_idx], sets[cu_idx]);
   };
 
   auto extract_fn = [&units_to_index, &clear_cu_dies](size_t cu_idx) {
-    clear_cu_dies[cu_idx] = units_to_index[cu_idx]->ExtractDIEsScoped();
+    clear_cu_dies[cu_idx] =
+        DWARFUnit::ScopedExtractDIEs(units_to_index[cu_idx]);
   };
 
   // Create a task runner that extracts dies for each DWARF compile unit in a
   // separate thread
   //----------------------------------------------------------------------
   // First figure out which compile units didn't have their DIEs already
   // parsed and remember this.  If no DIEs were parsed prior to this index
   // function call, we are going to want to clear the CU dies after we are