Fix several issues around dwo symbol file handling

[tberghammer]

Summary

Fix several issues around dwo symbol file handling

This change all dwo related test failure on Linux x86_64

[clayborg]

Just can't check for zero in SymbolFileDWARF, other than that it looks good.

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2242–2248 ↗

(On Diff #34550)

This actually can be zero for functions in a .o file. So this must be removed or you must fix it in a different way.

[clayborg]

I meant can't check for zero function start address in DWARFASTParserClang.cpp.

[tberghammer]

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2242–2248 ↗

(On Diff #34550)

Is there any case when the code is executed from the object file directly and not from the shared library? On Linux I am pretty sure it can't happen, but I am not sure about OSX.

If the function is executed from the shared library then the lowest_func_addr should be already offsetted by the object file base address at this point

[clayborg]

I should clarify: mach-o files do have functions at zero and these are legal DWARF and we need to read this DWARF correctly. We might be able to ask the SymbolFile's ObjectFile about this address and if it can be a valid function address using:

AddressClass ObjectFile::GetAddressClass (lldb::addr_t file_addr);

source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

2243–2247 ↗

(On Diff #34550)

We might be able to ask the SymbolFile's ObjectFile if zero can be a valid code address. Then this could would become:

if (lowest_func_addr == 0 && objfile->FileAddressIsValidForCode(lowest_func_addr)
{
}

Or we might be able to ask the address class of an address:

const AddressClass addr_class = obj_file->GetAddressClass (lowest_func_addr);
if (addr_class != eAddressClassCode && addr_class != eAddressClassCodeAlternateISA)
    return nullptr;

We would need to make sure that an address of zero in a mach-o .o file returns eAddressClassCode or eAddressClassCodeAlternateISA type.

[tberghammer]

Thank you for the clarification. I will commit in this patch without the change we discussed (ignoring 0 file address) and I will address that issue later.

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

if (die_offset != DW_INVALID_OFFSET)
         SymbolFileDWARF *dwarf = GetDWARF();
         if (dwarf)
             id = dwarf->MakeUserID(die_offset);
         else
             id = die_offset;
 
         if (m_cu)
         {
-            assert ((id&0xffffffff00000000ull) == 0 || m_cu->GetOffset() == 0);
-            id |= ((lldb::user_id_t)m_cu->GetOffset()) << 32;
+            lldb::user_id_t cu_id = ((lldb::user_id_t)m_cu->GetID())<<32;
+            assert ((id&0xffffffff00000000ull) == 0 ||
+                    (cu_id&0xffffffff00000000ll) == 0 ||
+                    (id&0xffffffff00000000ull) == (cu_id&0xffffffff00000000ll));
+            id |= cu_id;
         }
         return id;
     }
     return LLDB_INVALID_UID;
 }
 
 const char *
 DWARFDIE::GetName () const

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

FindFunctions (const lldb_private::RegularExpression &regex,
                    lldb_private::SymbolContextList& sc_list);
 
     void
     FindFunctions (const lldb_private::RegularExpression &regex,
                    const DWARFMappedHash::MemoryTable &memory_table,
                    bool include_inlines,
                    lldb_private::SymbolContextList& sc_list);
 
-    lldb::TypeSP
+    virtual lldb::TypeSP
     FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &die_decl_ctx);
 
     lldb::TypeSP
     FindCompleteObjCDefinitionTypeForDIE (const DWARFDIE &die,
                                           const lldb_private::ConstString &type_name,
                                           bool must_be_implementation);
 
     lldb::TypeSP

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

protected:
     GetDIEToVariable() override;
     
     DIEToClangType&
     GetForwardDeclDieToClangType() override;
 
     ClangTypeToDIE&
     GetForwardDeclClangTypeToDie() override;
 
+    lldb::TypeSP
+    FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &die_decl_ctx) override;
+
+    SymbolFileDWARF*
+    GetBaseSymbolFile();
+
     lldb::ObjectFileSP m_obj_file_sp;
     DWARFCompileUnit* m_base_dwarf_cu;
 };
 
 #endif  // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_

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

 using namespace lldb;
 using namespace lldb_private;
 
 SymbolFileDWARFDwo::SymbolFileDWARFDwo(ObjectFileSP objfile, DWARFCompileUnit* dwarf_cu) :
     SymbolFileDWARF(objfile.get()),
     m_obj_file_sp(objfile),
     m_base_dwarf_cu(dwarf_cu)
 {
+    SetID(((lldb::user_id_t)dwarf_cu->GetOffset())<<32);
 }
 
 const lldb_private::DWARFDataExtractor&
 SymbolFileDWARFDwo::GetCachedSectionData(uint32_t got_flag,
                                          lldb::SectionType sect_type,
                                          lldb_private::DWARFDataExtractor &data)
 {
     if (!m_flags.IsClear (got_flag))
SymbolFileDWARFDwo::GetCachedSectionData(uint32_t got_flag,
     }
     return SymbolFileDWARF::GetCachedSectionData(got_flag, sect_type, data);
 }
 
 lldb::CompUnitSP
 SymbolFileDWARFDwo::ParseCompileUnit(DWARFCompileUnit* dwarf_cu, uint32_t cu_idx)
 {
     assert(GetCompileUnit() == dwarf_cu && "SymbolFileDWARFDwo::ParseCompileUnit called with incompatible compile unit");
-    return m_base_dwarf_cu->GetSymbolFileDWARF()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
+    return GetBaseSymbolFile()->ParseCompileUnit(m_base_dwarf_cu, UINT32_MAX);
 }
 
 DWARFCompileUnit*
 SymbolFileDWARFDwo::GetCompileUnit()
 {
     // Only dwo files with 1 compile unit is supported
     if (GetNumCompileUnits() == 1)
         return DebugInfo()->GetCompileUnitAtIndex(0);
     else
         return nullptr;
 }
 
 DWARFCompileUnit*
 SymbolFileDWARFDwo::GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit)
 {
     return GetCompileUnit();
 }
 
 SymbolFileDWARF::DIEToTypePtr&
 SymbolFileDWARFDwo::GetDIEToType()
 {
-    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetDIEToType();
+    return GetBaseSymbolFile()->GetDIEToType();
 }
 
 SymbolFileDWARF::DIEToVariableSP&
 SymbolFileDWARFDwo::GetDIEToVariable()
 {
-    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetDIEToVariable();
+    return GetBaseSymbolFile()->GetDIEToVariable();
 }
 
 SymbolFileDWARF::DIEToClangType&
 SymbolFileDWARFDwo::GetForwardDeclDieToClangType()
 {
-    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetForwardDeclDieToClangType();
+    return GetBaseSymbolFile()->GetForwardDeclDieToClangType();
 }
 
 SymbolFileDWARF::ClangTypeToDIE&
 SymbolFileDWARFDwo::GetForwardDeclClangTypeToDie()
 {
-    return m_base_dwarf_cu->GetSymbolFileDWARF()->GetForwardDeclClangTypeToDie();
+    return GetBaseSymbolFile()->GetForwardDeclClangTypeToDie();
+}
+
+lldb::TypeSP
+SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext (const DWARFDeclContext &die_decl_ctx)
+{
+    return GetBaseSymbolFile()->FindDefinitionTypeForDWARFDeclContext(die_decl_ctx);
+}
+
+SymbolFileDWARF*
+SymbolFileDWARFDwo::GetBaseSymbolFile()
+{
+    return m_base_dwarf_cu->GetSymbolFileDWARF();
 }