DebugInfo: Factor out parsing compile unit DIEs to a separate function. Improve code style and comments.

No functionality change.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@186315 91177308-0d34-0410-b5e6-96231b3b80d8

lib/DebugInfo/DWARFCompileUnit.cpp

@@ -147,89 +147,95 @@ void DWARFCompileUnit::setDIERelations() {
     curr_die->setParent(die_array_begin);
 }
 
-size_t DWARFCompileUnit::extractDIEsIfNeeded(bool cu_die_only) {
+void DWARFCompileUnit::extractDIEsToVector(
-  const size_t initial_die_array_size = DieArray.size();
+    bool AppendCUDie, bool AppendNonCUDies,
-  if ((cu_die_only && initial_die_array_size > 0) ||
+    std::vector<DWARFDebugInfoEntryMinimal> &Dies) const {
-      initial_die_array_size > 1)
+  if (!AppendCUDie && !AppendNonCUDies)
-    return 0; // Already parsed
+    return;
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
-  uint32_t offset = getFirstDIEOffset();
+  uint32_t Offset = getFirstDIEOffset();
-  uint32_t next_cu_offset = getNextCompileUnitOffset();
+  uint32_t NextCUOffset = getNextCompileUnitOffset();
-
+  DWARFDebugInfoEntryMinimal DIE;
-  DWARFDebugInfoEntryMinimal die;
+  uint32_t Depth = 0;
-  // Keep a flat array of the DIE for binary lookup by DIE offset
+  const uint8_t *FixedFormSizes =
-  uint32_t depth = 0;
-  // We are in our compile unit, parse starting at the offset
-  // we were told to parse
-
-  const uint8_t *fixed_form_sizes =
     DWARFFormValue::getFixedFormSizes(getAddressByteSize(), getVersion());
+  bool IsCUDie = true;
 
-  while (offset < next_cu_offset &&
+  while (Offset < NextCUOffset &&
-         die.extractFast(this, fixed_form_sizes, &offset)) {
+         DIE.extractFast(this, FixedFormSizes, &Offset)) {
-
+    if (IsCUDie) {
-    if (depth == 0) {
+      if (AppendCUDie)
-      uint64_t base_addr =
+        Dies.push_back(DIE);
-        die.getAttributeValueAsUnsigned(this, DW_AT_low_pc, -1U);
+      if (!AppendNonCUDies)
-      if (base_addr == -1U)
+        break;
-        base_addr = die.getAttributeValueAsUnsigned(this, DW_AT_entry_pc, 0);
+      // The average bytes per DIE entry has been seen to be
-      setBaseAddress(base_addr);
+      // around 14-20 so let's pre-reserve the needed memory for
+      // our DIE entries accordingly.
+      Dies.reserve(Dies.size() + getDebugInfoSize() / 14);
+      IsCUDie = false;
+    } else {
+      Dies.push_back(DIE);
     }
 
-    if (cu_die_only) {
+    const DWARFAbbreviationDeclaration *AbbrDecl =
-      addDIE(die);
+      DIE.getAbbreviationDeclarationPtr();
-      return 1;
+    if (AbbrDecl) {
-    }
-    else if (depth == 0 && initial_die_array_size == 1)
-      // Don't append the CU die as we already did that
-      ;
-    else
-      addDIE(die);
-
-    const DWARFAbbreviationDeclaration *abbrDecl =
-      die.getAbbreviationDeclarationPtr();
-    if (abbrDecl) {
       // Normal DIE
-      if (abbrDecl->hasChildren())
+      if (AbbrDecl->hasChildren())
-        ++depth;
+        ++Depth;
     } else {
       // NULL DIE.
-      if (depth > 0)
+      if (Depth > 0)
-        --depth;
+        --Depth;
-      if (depth == 0)
+      if (Depth == 0)
         break;  // We are done with this compile unit!
     }
-
   }
 
   // Give a little bit of info if we encounter corrupt DWARF (our offset
   // should always terminate at or before the start of the next compilation
   // unit header).
-  if (offset > next_cu_offset)
+  if (Offset > NextCUOffset)
     fprintf(stderr, "warning: DWARF compile unit extends beyond its "
-                    "bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), offset);
+                    "bounds cu 0x%8.8x at 0x%8.8x'\n", getOffset(), Offset);
+}
+
+size_t DWARFCompileUnit::extractDIEsIfNeeded(bool CUDieOnly) {
+  if ((CUDieOnly && DieArray.size() > 0) ||
+      DieArray.size() > 1)
+    return 0; // Already parsed.
+
+  extractDIEsToVector(DieArray.empty(), !CUDieOnly, DieArray);
+
+  // Set the base address of current compile unit.
+  if (!DieArray.empty()) {
+    uint64_t BaseAddr =
+      DieArray[0].getAttributeValueAsUnsigned(this, DW_AT_low_pc, -1U);
+    if (BaseAddr == -1U)
+      BaseAddr = DieArray[0].getAttributeValueAsUnsigned(this, DW_AT_entry_pc, 0);
+    setBaseAddress(BaseAddr);
+  }
 
   setDIERelations();
   return DieArray.size();
 }
 
-void DWARFCompileUnit::clearDIEs(bool keep_compile_unit_die) {
+void DWARFCompileUnit::clearDIEs(bool KeepCUDie) {
-  if (DieArray.size() > (unsigned)keep_compile_unit_die) {
+  if (DieArray.size() > (unsigned)KeepCUDie) {
     // std::vectors never get any smaller when resized to a smaller size,
     // or when clear() or erase() are called, the size will report that it
     // is smaller, but the memory allocated remains intact (call capacity()
     // to see this). So we need to create a temporary vector and swap the
     // contents which will cause just the internal pointers to be swapped
-    // so that when "tmp_array" goes out of scope, it will destroy the
+    // so that when temporary vector goes out of scope, it will destroy the
     // contents.
-
+    std::vector<DWARFDebugInfoEntryMinimal> TmpArray;
+    DieArray.swap(TmpArray);
     // Save at least the compile unit DIE
-    std::vector<DWARFDebugInfoEntryMinimal> tmpArray;
+    if (KeepCUDie)
-    DieArray.swap(tmpArray);
+      DieArray.push_back(TmpArray.front());
-    if (keep_compile_unit_die)
-      DieArray.push_back(tmpArray.front());
   }
 }
 

lib/DebugInfo/DWARFCompileUnit.h

@@ -39,7 +39,7 @@ class DWARFCompileUnit {
   const DWARFAbbreviationDeclarationSet *Abbrevs;
   uint8_t AddrSize;
   uint64_t BaseAddr;
-  // The compile unit debug information entry item.
+  // The compile unit debug information entry items.
   std::vector<DWARFDebugInfoEntryMinimal> DieArray;
 public:
 
@@ -64,7 +64,7 @@ public:
 
   /// extractDIEsIfNeeded - Parses a compile unit and indexes its DIEs if it
   /// hasn't already been done. Returns the number of DIEs parsed at this call.
-  size_t extractDIEsIfNeeded(bool cu_die_only);
+  size_t extractDIEsIfNeeded(bool CUDieOnly);
   /// extractRangeList - extracts the range list referenced by this compile
   /// unit from .debug_ranges section. Returns true on success.
   /// Requires that compile unit is already extracted.
@@ -98,9 +98,7 @@ public:
   const DWARFDebugInfoEntryMinimal *
   getCompileUnitDIE(bool extract_cu_die_only = true) {
     extractDIEsIfNeeded(extract_cu_die_only);
-    if (DieArray.empty())
+    return DieArray.empty() ? NULL : &DieArray[0];
-      return NULL;
-    return &DieArray[0];
   }
 
   const char *getCompilationDir();
@@ -110,25 +108,6 @@ public:
   /// parent, sibling and child pointers for quick DIE navigation.
   void setDIERelations();
 
-  void addDIE(DWARFDebugInfoEntryMinimal &die) {
-    // The average bytes per DIE entry has been seen to be
-    // around 14-20 so lets pre-reserve the needed memory for
-    // our DIE entries accordingly. Search forward for "Compute
-    // average bytes per DIE" to see #if'ed out code that does
-    // that determination.
-
-    // Only reserve the memory if we are adding children of
-    // the main compile unit DIE. The compile unit DIE is always
-    // the first entry, so if our size is 1, then we are adding
-    // the first compile unit child DIE and should reserve
-    // the memory.
-    if (DieArray.empty())
-      DieArray.reserve(getDebugInfoSize() / 14);
-    DieArray.push_back(die);
-  }
-
-  void clearDIEs(bool keep_compile_unit_die);
-
   void buildAddressRangeTable(DWARFDebugAranges *debug_aranges,
                               bool clear_dies_if_already_not_parsed);
 
@@ -136,6 +115,13 @@ public:
   /// Returns empty chain if there is no subprogram containing address.
   DWARFDebugInfoEntryMinimal::InlinedChain getInlinedChainForAddress(
       uint64_t Address);
+
+private:
+  /// extractDIEsToVector - Appends all parsed DIEs to a vector.
+  void extractDIEsToVector(bool AppendCUDie, bool AppendNonCUDIEs,
+                           std::vector<DWARFDebugInfoEntryMinimal> &DIEs) const;
+  /// clearDIEs - Clear parsed DIEs to keep memory usage low.
+  void clearDIEs(bool KeepCUDie);
 };
 
 }