Fix infinite recursion in DWO file parsing

[labath]

Summary

Since r264316, clang started adding DW_AT_GNU_dwo_name attribute to dwo files (previously, this
attribute was only present in main object files), breaking pretty much every dwo test. The
problem was that we were treating the presence of said attribute as a signal that we should look
for information in an external object file, and caused us to enter an infinite loop. I fix this
by making sure we do not go looking for an external dwo file if we already *are* parsing a dwo
file.

[tberghammer]

Looks good

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

334 ↗

(On Diff #51896)

I would rename it to GetDwoSymbolFileForCompileUnit(....) as DWO in its own doesn't mean too much.

[labath]

@clayborg: I am going to put this in now, to stabilize the buildbot situation. I'll be happy to address any concerns in a follow-up commit.

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

//                        die.HasChildren() ? " *" : "");
     return m_die_array.size() + dwo_die_count - 1; // We have 2 CU die, but we waht to count it only as one
 }
 
 void
 DWARFCompileUnit::AddCompileUnitDIE(DWARFDebugInfoEntry& die)
 {
     assert (m_die_array.empty() && "Compile unit DIE already added");
     AddDIE(die);
-    
-    DWARFDebugInfoEntry& cu_die = m_die_array.front();
-
-    const char* dwo_name = cu_die.GetAttributeValueAsString(m_dwarf2Data,
-                                                            this,
-                                                            DW_AT_GNU_dwo_name,
-                                                            nullptr);
-    if (!dwo_name)
+    const DWARFDebugInfoEntry &cu_die = m_die_array.front();
+    std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file = m_dwarf2Data->GetDwoSymbolFileForCompileUnit(*this, cu_die);
+    if (!dwo_symbol_file)
         return;
 
-    FileSpec dwo_file(dwo_name, true);
-    if (dwo_file.IsRelative())
-    {
-        const char* comp_dir = cu_die.GetAttributeValueAsString(m_dwarf2Data,
-                                                                this,
-                                                                DW_AT_comp_dir,
-                                                                nullptr);
-        if (!comp_dir)
-            return;
-
-        dwo_file.SetFile(comp_dir, true);
-        dwo_file.AppendPathComponent(dwo_name);
-    }
-
-    if (!dwo_file.Exists())
-        return;
-
-    DataBufferSP dwo_file_data_sp;
-    lldb::offset_t dwo_file_data_offset = 0;
-    ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(m_dwarf2Data->GetObjectFile()->GetModule(),
-                                                       &dwo_file,
-                                                       0 /* file_offset */,
-                                                       dwo_file.GetByteSize(),
-                                                       dwo_file_data_sp,
-                                                       dwo_file_data_offset);
-    if (dwo_obj_file == nullptr)
-        return;
-
-    std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file(new SymbolFileDWARFDwo(dwo_obj_file, this));
-
     DWARFCompileUnit* dwo_cu = dwo_symbol_file->GetCompileUnit();
     if (!dwo_cu)
         return; // Can't fetch the compile unit from the dwo file.
 
     DWARFDIE dwo_cu_die = dwo_cu->GetCompileUnitDIEOnly();
     if (!dwo_cu_die.IsValid())
         return; // Can't fetch the compile unit DIE from the dwo file.
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 class DWARFDebugInfoEntry;
 class DWARFDebugLine;
 class DWARFDebugPubnames;
 class DWARFDebugRanges;
 class DWARFDeclContext;
 class DWARFDIECollection;
 class DWARFFormValue;
 class SymbolFileDWARFDebugMap;
+class SymbolFileDWARFDwo;
 
 #define DIE_IS_BEING_PARSED ((lldb_private::Type*)1)
 
 class SymbolFileDWARF : public lldb_private::SymbolFile, public lldb_private::UserID
 {
 public:
     friend class SymbolFileDWARFDebugMap;
     friend class SymbolFileDWARFDwo;
public:
     ParseCompileUnit (DWARFCompileUnit* dwarf_cu, uint32_t cu_idx);
 
     virtual lldb_private::DWARFExpression::LocationListFormat
     GetLocationListFormat() const;
 
     lldb::ModuleSP
     GetDWOModule (lldb_private::ConstString name);
 
+    virtual std::unique_ptr<SymbolFileDWARFDwo>
+    GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die);
+
 protected:
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb_private::Type *> DIEToTypePtr;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::VariableSP> DIEToVariableSP;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, lldb::opaque_compiler_type_t> DIEToClangType;
     typedef llvm::DenseMap<lldb::opaque_compiler_type_t, DIERef> ClangTypeToDIE;
 
     struct DWARFDataSegment
     {

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

SymbolFileDWARF::GetDWOModule (ConstString name)
     UpdateExternalModuleListIfNeeded();
     const auto &pos = m_external_type_modules.find(name);
     if (pos != m_external_type_modules.end())
         return pos->second;
     else
         return lldb::ModuleSP();
 }
 
+std::unique_ptr<SymbolFileDWARFDwo>
+SymbolFileDWARF::GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die)
+{
+    const char *dwo_name = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_GNU_dwo_name, nullptr);
+    if (!dwo_name)
+        return nullptr;
+
+    FileSpec dwo_file(dwo_name, true);
+    if (dwo_file.IsRelative())
+    {
+        const char *comp_dir = cu_die.GetAttributeValueAsString(this, &dwarf_cu, DW_AT_comp_dir, nullptr);
+        if (!comp_dir)
+            return nullptr;
+
+        dwo_file.SetFile(comp_dir, true);
+        dwo_file.AppendPathComponent(dwo_name);
+    }
+
+    if (!dwo_file.Exists())
+        return nullptr;
+
+    const lldb::offset_t file_offset = 0;
+    DataBufferSP dwo_file_data_sp;
+    lldb::offset_t dwo_file_data_offset = 0;
+    ObjectFileSP dwo_obj_file = ObjectFile::FindPlugin(GetObjectFile()->GetModule(), &dwo_file, file_offset,
+                                                       dwo_file.GetByteSize(), dwo_file_data_sp, dwo_file_data_offset);
+    if (dwo_obj_file == nullptr)
+        return nullptr;
+
+    return llvm::make_unique<SymbolFileDWARFDwo>(dwo_obj_file, &dwarf_cu);
+}
+
 void
 SymbolFileDWARF::UpdateExternalModuleListIfNeeded()
 {
     if (m_fetched_external_modules)
         return;
     m_fetched_external_modules = true;
     
     DWARFDebugInfo * debug_info = DebugInfo();

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

public:
     GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
 
     lldb_private::DWARFExpression::LocationListFormat
     GetLocationListFormat() const override;
 
     lldb_private::TypeSystem*
     GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
+    std::unique_ptr<SymbolFileDWARFDwo>
+    GetDwoSymbolFileForCompileUnit(DWARFCompileUnit &dwarf_cu, const DWARFDebugInfoEntry &cu_die) override
+    {
+        return nullptr;
+    }
+
 protected:
     void
     LoadSectionData (lldb::SectionType sect_type, lldb_private::DWARFDataExtractor& data) override;
 
     DIEToTypePtr&
     GetDIEToType() override;
 
     DIEToVariableSP&