2/3: Use DWARFBaseDIE as compile-time protection

[jankratochvil]

Summary

As suggested by Pavel Labath in D46810 DWARFUnit::GetUnitDIEOnly() returning a pointer to m_first_die should not permit using methods like GetFirstChild().

[clayborg]

Waiting for answers on renaming from patch 1/3 before commenting.

[clayborg]

Rename to DWARFBaseDIE and this is good to go.

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

if (debug_info_data.ValidOffset(offset)) {
     } else {
       s.Printf("NULL\n");
     }
   }
 }
 
 void DWARFDebugInfoEntry::DumpLocation(SymbolFileDWARF *dwarf2Data,
                                        DWARFUnit *cu, Stream &s) const {
-  const DWARFDIE cu_die = cu->GetUnitDIEOnly();
+  const DWARFFirstDIE cu_die = cu->GetUnitDIEOnly();
   const char *cu_name = NULL;
   if (cu_die)
     cu_name = cu_die.GetName();
   const char *obj_file_name = NULL;
   ObjectFile *obj_file = dwarf2Data->GetObjectFile();
   if (obj_file)
     obj_file_name =
         obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>");
dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
 
   if (!dwo_symbol_file)
     return 0;
 
   DWARFUnit *dwo_cu = dwo_symbol_file->GetCompileUnit();
   if (!dwo_cu)
     return 0;
 
-  DWARFDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
+  DWARFFirstDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return 0;
 
   return dwo_cu_die.GetDIE()->GetAttributeValue(
       dwo_symbol_file, dwo_cu, attr, form_value, end_attr_offset_ptr,
       check_specification_or_abstract_origin);
 }
 

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   lldb_private::TypeSystem *GetTypeSystem();
 
   const DWARFDebugAranges &GetFunctionAranges();
 
   DWARFFormValue::FixedFormSizes GetFixedFormSizes();
 
   void SetBaseAddress(dw_addr_t base_addr);
 
-  DWARFDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
+  DWARFFirstDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
 
   DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }
 
   bool HasDIEsParsed() const;
 
   DWARFDIE GetDIE(dw_offset_t die_offset);
 
   static uint8_t GetAddressByteSize(const DWARFUnit *cu);

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

std::unique_ptr<SymbolFileDWARFDwo> dwo_symbol_file =
       m_dwarf->GetDwoSymbolFileForCompileUnit(*this, cu_die);
   if (!dwo_symbol_file)
     return;
 
   DWARFUnit *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->GetUnitDIEOnly();
+  DWARFFirstDIE dwo_cu_die = dwo_cu->GetUnitDIEOnly();
   if (!dwo_cu_die.IsValid())
     return; // Can't fetch the compile unit DIE from the dwo file.
 
   uint64_t main_dwo_id =
       cu_die.GetAttributeValueAsUnsigned(m_dwarf, this, DW_AT_GNU_dwo_id, 0);
   uint64_t sub_dwo_id =
       dwo_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_dwo_id, 0);
   if (main_dwo_id != sub_dwo_id)

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (comp_unit) {
                                                                 cu_idx);
       } else if (dwarf_cu->GetOffset() == 0 && GetDebugMapSymfile()) {
         // Let the debug map create the compile unit
         cu_sp = m_debug_map_symfile->GetCompileUnit(this);
         dwarf_cu->SetUserData(cu_sp.get());
       } else {
         ModuleSP module_sp(m_obj_file->GetModule());
         if (module_sp) {
-          const DWARFDIE cu_die = dwarf_cu->GetUnitDIEOnly();
+          const DWARFDIE cu_die = dwarf_cu->DIE();
           if (cu_die) {
             FileSpec cu_file_spec{cu_die.GetName(), false};
             if (cu_file_spec) {
               // If we have a full path to the compile unit, we don't need to
               // resolve the file.  This can be expensive e.g. when the source
               // files are
               // NFS mounted.
               if (cu_file_spec.IsRelative()) {
size_t SymbolFileDWARF::ParseCompileUnitFunctions(const SymbolContext &sc) {
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseCompileUnitSupportFiles(
     const SymbolContext &sc, FileSpecList &support_files) {
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
-    const DWARFDIE cu_die = dwarf_cu->GetUnitDIEOnly();
+    const DWARFFirstDIE cu_die = dwarf_cu->GetUnitDIEOnly();
 
     if (cu_die) {
       FileSpec cu_comp_dir = resolveCompDir(
           cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
       const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
           DW_AT_stmt_list, DW_INVALID_OFFSET);
       if (stmt_list != DW_INVALID_OFFSET) {
         // All file indexes in DWARF are one based and a file of index zero is
bool SymbolFileDWARF::ParseImportedModules(
   assert(sc.comp_unit);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
     if (ClangModulesDeclVendor::LanguageSupportsClangModules(
             sc.comp_unit->GetLanguage())) {
       UpdateExternalModuleListIfNeeded();
 
       if (sc.comp_unit) {
-        const DWARFDIE die = dwarf_cu->GetUnitDIEOnly();
+        const DWARFDIE die = dwarf_cu->DIE();
 
         if (die) {
           for (DWARFDIE child_die = die.GetFirstChild(); child_die;
                child_die = child_die.GetSibling()) {
             if (child_die.Tag() == DW_TAG_imported_declaration) {
               if (DWARFDIE module_die =
                       child_die.GetReferencedDIE(DW_AT_import)) {
                 if (module_die.Tag() == DW_TAG_module) {

 
 bool SymbolFileDWARF::ParseCompileUnitLineTable(const SymbolContext &sc) {
   assert(sc.comp_unit);
   if (sc.comp_unit->GetLineTable() != NULL)
     return true;
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu) {
-    const DWARFDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
+    const DWARFFirstDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
     if (dwarf_cu_die) {
       const dw_offset_t cu_line_offset =
           dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
                                                    DW_INVALID_OFFSET);
       if (cu_line_offset != DW_INVALID_OFFSET) {
         std::unique_ptr<LineTable> line_table_ap(new LineTable(sc.comp_unit));
         if (line_table_ap.get()) {
           ParseDWARFLineTableCallbackInfo info;

 
 bool SymbolFileDWARF::ParseCompileUnitDebugMacros(const SymbolContext &sc) {
   assert(sc.comp_unit);
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(sc.comp_unit);
   if (dwarf_cu == nullptr)
     return false;
 
-  const DWARFDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
+  const DWARFFirstDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
   if (!dwarf_cu_die)
     return false;
 
   lldb::offset_t sect_offset =
       dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_macros, DW_INVALID_OFFSET);
   if (sect_offset == DW_INVALID_OFFSET)
     sect_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_GNU_macros,
                                                            DW_INVALID_OFFSET);
void SymbolFileDWARF::UpdateExternalModuleListIfNeeded() {
   m_fetched_external_modules = true;
 
   DWARFDebugInfo *debug_info = DebugInfo();
 
   const uint32_t num_compile_units = GetNumCompileUnits();
   for (uint32_t cu_idx = 0; cu_idx < num_compile_units; ++cu_idx) {
     DWARFUnit *dwarf_cu = debug_info->GetCompileUnitAtIndex(cu_idx);
 
-    const DWARFDIE die = dwarf_cu->GetUnitDIEOnly();
+    const DWARFFirstDIE die = dwarf_cu->GetUnitDIEOnly();
     if (die && die.HasChildren() == false) {
       const char *name = die.GetAttributeValueAsString(DW_AT_name, nullptr);
 
       if (name) {
         ConstString const_name(name);
         if (m_external_type_modules.find(const_name) ==
             m_external_type_modules.end()) {
           ModuleSP module_sp;