1/3: DWARFDIE split out to DWARFBaseDIE

[jankratochvil]

Summary

As Pavel Labath said in D46810 this is new DWARFBasicDIE to be used for DWARFUnit::GetUnitDIEOnly(). This patch is only mechanical split without any use of it.

[clayborg]

Marked things that don't belong in DWARFBasicDIE.

Also DWARFBasicDIE doesn't really explain what it actually is. Maybe we should rename this DWARFUnitDIE? DWARFTopDIE? DWARFRootDIE?

source/Plugins/SymbolFile/DWARF/DWARFBasicDIE.h

49 ↗

(On Diff #148267)

This will never be true for DWARFBasicDIE. Remove?

115 ↗

(On Diff #148267)

This will never be useful for DWARFBasicDIE since it will represent the first DIE. Remove?

117 ↗

(On Diff #148267)

This will never be useful for DWARFBasicDIE since it will represent the first DIE. Remove?

119 ↗

(On Diff #148267)

This will never be useful for DWARFBasicDIE since it will represent the first DIE. Remove?

151–155 ↗

(On Diff #148267)

This will never be useful for DWARFBasicDIE since it will represent the first DIE. Remove?

[jankratochvil]

In D47275#1110065, @clayborg wrote:

Marked things that don't belong in DWARFBasicDIE.

OK, sorry, thanks for reviewing it.

Also DWARFBasicDIE doesn't really explain what it actually is. Maybe we should rename this DWARFUnitDIE? DWARFTopDIE? DWARFRootDIE?

I do not mind any name but if you do not like Pavel's DWARFBasicDIE and you are not sure with the name yourself I have chosen DWARFFirstDIE.

[labath]

I don't think a name like DWARFUnitDIE is a good one bacause it would make a weird is-a relationship (a DWARFDIE represetning a DW_TAG_variable is certainly not a "unit DIE" yet you could assign it to a DWARFUnitDIE&). We could have a DWARFUnitDIE type if we wanted to, but that would have to be a special type in addition to DWARFBasicDIE. However, I think that would be overkill.

That said, if everyone who is going to be calling IsStructOrClass and friends will see the type as DWARFDIE then keeping those methods on that class makes sense.

[labath]

Looks like we missed each other, but all I said about DWARFUnitDIE applies to DWARFFirstDIE as well. I doesn't have to be called "basic" die, but the reason I proposed that name is that it does not sound weird when you say that any die "is a" basic die. Other possibility would be to keep DWARFDIE as the "basic" die, and have a something like a "navigatable" die for those that allow you to access children and stuff.

[clayborg]

I like DWARFFirstDIE. Pavel should ok this too.

[labath]

In D47275#1111215, @clayborg wrote:

I like DWARFFirstDIE. Pavel should ok this too.

I said what I think of DWARFFirstDIE. I'd like to hear from you what you think about the is-a issue I mentioned.

[clayborg]

In D47275#1110772, @labath wrote:

I don't think a name like DWARFUnitDIE is a good one bacause it would make a weird is-a relationship (a DWARFDIE represetning a DW_TAG_variable is certainly not a "unit DIE" yet you could assign it to a DWARFUnitDIE&). We could have a DWARFUnitDIE type if we wanted to, but that would have to be a special type in addition to DWARFBasicDIE. However, I think that would be overkill.

Yeah, we just need to be able to tell the difference between the top level DIE we hand out with no children and the one that has all the abilities.

That said, if everyone who is going to be calling IsStructOrClass and friends will see the type as DWARFDIE then keeping those methods on that class makes sense.

Yes, that is the case. No top level DIE can be a struct, union or class. Only a compile unit, type unit or partial unit.

[labath]

In D47275#1111254, @clayborg wrote:

In D47275#1110772, @labath wrote:

I don't think a name like DWARFUnitDIE is a good one bacause it would make a weird is-a relationship (a DWARFDIE represetning a DW_TAG_variable is certainly not a "unit DIE" yet you could assign it to a DWARFUnitDIE&). We could have a DWARFUnitDIE type if we wanted to, but that would have to be a special type in addition to DWARFBasicDIE. However, I think that would be overkill.

Yeah, we just need to be able to tell the difference between the top level DIE we hand out with no children and the one that has all the abilities.

Yes, but this is not what this patch is doing. The class inheritance makes is such that any "die with all abilities" we hand out, also is-a "top level die with no children". This is where my problem comes from.

If I rephrase your comment a bit

we just need to be able to tell the difference between a DIE that has no ability to access children and the one that has all the abilities.

then it is fine because a "die which has all abilities" is also a "die which has only a certain smaller set of abilities". However in this case a name like DWARFUnitDIE is not appropriate.

If we wanted to have a type called DwarfUnitDIE die then it should be a special type inheriting from DWARFBasicDIE (or whatever it's called). Then again it would be fine, because then it would be a "DIE that has no ability to access children and is a root DIE", which is a refinement of "DIE that has no ability to access children".

[clayborg]

In D47275#1111285, @labath wrote:

In D47275#1111254, @clayborg wrote:

In D47275#1110772, @labath wrote:

I don't think a name like DWARFUnitDIE is a good one bacause it would make a weird is-a relationship (a DWARFDIE represetning a DW_TAG_variable is certainly not a "unit DIE" yet you could assign it to a DWARFUnitDIE&). We could have a DWARFUnitDIE type if we wanted to, but that would have to be a special type in addition to DWARFBasicDIE. However, I think that would be overkill.

Yeah, we just need to be able to tell the difference between the top level DIE we hand out with no children and the one that has all the abilities.

Yes, but this is not what this patch is doing. The class inheritance makes is such that any "die with all abilities" we hand out, also is-a "top level die with no children". This is where my problem comes from.

Yeah, I see where the name doesn't fit now. DWARFBaseDIE maybe?

If I rephrase your comment a bit

we just need to be able to tell the difference between a DIE that has no ability to access children and the one that has all the abilities.

then it is fine because a "die which has all abilities" is also a "die which has only a certain smaller set of abilities". However in this case a name like DWARFUnitDIE is not appropriate.

If we wanted to have a type called DwarfUnitDIE die then it should be a special type inheriting from DWARFBasicDIE (or whatever it's called). Then again it would be fine, because then it would be a "DIE that has no ability to access children and is a root DIE", which is a refinement of "DIE that has no ability to access children".

DWARFBaseDIE might work then. Name doesn't violate any of the assumptions you mention above. All of your issues revolve around the naming right?

[labath]

Yes, Base is fine. Thank you.

[clayborg]

ok, just rename DWARFFirstDIE to DWARFBaseDIE and this is good to go.

lldb/trunk/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   AppleDWARFIndex.cpp
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFASTParserGo.cpp
   DWARFASTParserJava.cpp
   DWARFASTParserOCaml.cpp
   DWARFAttribute.cpp
+  DWARFBaseDIE.cpp
   DWARFCompileUnit.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugAranges.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugInfo.cpp
   DWARFDebugInfoEntry.cpp
   DWARFDebugLine.cpp

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

+//===-- DWARFBaseDIE.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SymbolFileDWARF_DWARFBaseDIE_h_
+#define SymbolFileDWARF_DWARFBaseDIE_h_
+
+#include "lldb/Core/dwarf.h"
+#include "lldb/lldb-types.h"
+
+struct DIERef;
+class DWARFASTParser;
+class DWARFAttributes;
+class DWARFUnit;
+class DWARFDebugInfoEntry;
+class DWARFDeclContext;
+class DWARFDIECollection;
+class SymbolFileDWARF;
+
+class DWARFBaseDIE {
+public:
+  DWARFBaseDIE() : m_cu(nullptr), m_die(nullptr) {}
+
+  DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
+      : m_cu(cu), m_die(die) {}
+
+  DWARFBaseDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
+      : m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {}
+
+  DWARFBaseDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)
+      : m_cu(cu), m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
+
+  DWARFBaseDIE(const DWARFUnit *cu, const DWARFDebugInfoEntry *die)
+      : m_cu(const_cast<DWARFUnit *>(cu)),
+        m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
+
+  //----------------------------------------------------------------------
+  // Tests
+  //----------------------------------------------------------------------
+  explicit operator bool() const { return IsValid(); }
+
+  bool IsValid() const { return m_cu && m_die; }
+
+  bool HasChildren() const;
+
+  bool Supports_DW_AT_APPLE_objc_complete_type() const;
+
+  //----------------------------------------------------------------------
+  // Accessors
+  //----------------------------------------------------------------------
+  SymbolFileDWARF *GetDWARF() const;
+
+  DWARFUnit *GetCU() const { return m_cu; }
+
+  DWARFDebugInfoEntry *GetDIE() const { return m_die; }
+
+  DIERef GetDIERef() const;
+
+  lldb_private::TypeSystem *GetTypeSystem() const;
+
+  DWARFASTParser *GetDWARFParser() const;
+
+  void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
+    if (cu && die) {
+      m_cu = cu;
+      m_die = die;
+    } else {
+      Clear();
+    }
+  }
+
+  void Clear() {
+    m_cu = nullptr;
+    m_die = nullptr;
+  }
+
+  //----------------------------------------------------------------------
+  // Get the data that contains the attribute values for this DIE. Support
+  // for .debug_types means that any DIE can have its data either in the
+  // .debug_info or the .debug_types section; this method will return the
+  // correct section data.
+  //
+  // Clients must validate that this object is valid before calling this.
+  //----------------------------------------------------------------------
+  const lldb_private::DWARFDataExtractor &GetData() const;
+
+  //----------------------------------------------------------------------
+  // Accessing information about a DIE
+  //----------------------------------------------------------------------
+  dw_tag_t Tag() const;
+
+  const char *GetTagAsCString() const;
+
+  dw_offset_t GetOffset() const;
+
+  dw_offset_t GetCompileUnitRelativeOffset() const;
+
+  //----------------------------------------------------------------------
+  // Get the LLDB user ID for this DIE. This is often just the DIE offset,
+  // but it might have a SymbolFileDWARF::GetID() in the high 32 bits if
+  // we are doing Darwin DWARF in .o file, or DWARF stand alone debug
+  // info.
+  //----------------------------------------------------------------------
+  lldb::user_id_t GetID() const;
+
+  const char *GetName() const;
+
+  lldb::LanguageType GetLanguage() const;
+
+  lldb::ModuleSP GetModule() const;
+
+  lldb_private::CompileUnit *GetLLDBCompileUnit() const;
+
+  //----------------------------------------------------------------------
+  // Getting attribute values from the DIE.
+  //
+  // GetAttributeValueAsXXX() functions should only be used if you are
+  // looking for one or two attributes on a DIE. If you are trying to
+  // parse all attributes, use GetAttributes (...) instead
+  //----------------------------------------------------------------------
+  const char *GetAttributeValueAsString(const dw_attr_t attr,
+                                        const char *fail_value) const;
+
+  uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr,
+                                       uint64_t fail_value) const;
+
+  int64_t GetAttributeValueAsSigned(const dw_attr_t attr,
+                                    int64_t fail_value) const;
+
+  uint64_t GetAttributeValueAsReference(const dw_attr_t attr,
+                                        uint64_t fail_value) const;
+
+  uint64_t GetAttributeValueAsAddress(const dw_attr_t attr,
+                                      uint64_t fail_value) const;
+
+  size_t GetAttributes(DWARFAttributes &attributes, uint32_t depth = 0) const;
+
+  //----------------------------------------------------------------------
+  // Pretty printing
+  //----------------------------------------------------------------------
+
+  void Dump(lldb_private::Stream *s, const uint32_t recurse_depth) const;
+
+protected:
+  DWARFUnit *m_cu;
+  DWARFDebugInfoEntry *m_die;
+};
+
+bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
+bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs);
+
+#endif // SymbolFileDWARF_DWARFBaseDIE_h_

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

+//===-- DWARFBaseDIE.cpp ---------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DWARFBaseDIE.h"
+
+#include "DWARFUnit.h"
+#include "DWARFDebugInfoEntry.h"
+#include "SymbolFileDWARF.h"
+
+#include "lldb/Core/Module.h"
+#include "lldb/Symbol/ObjectFile.h"
+
+using namespace lldb_private;
+
+DIERef DWARFBaseDIE::GetDIERef() const {
+  if (!IsValid())
+    return DIERef();
+
+  dw_offset_t cu_offset = m_cu->GetOffset();
+  if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
+    cu_offset = m_cu->GetBaseObjOffset();
+  return DIERef(cu_offset, m_die->GetOffset());
+}
+
+dw_tag_t DWARFBaseDIE::Tag() const {
+  if (m_die)
+    return m_die->Tag();
+  else
+    return 0;
+}
+
+const char *DWARFBaseDIE::GetTagAsCString() const {
+  return lldb_private::DW_TAG_value_to_name(Tag());
+}
+
+const char *DWARFBaseDIE::GetAttributeValueAsString(const dw_attr_t attr,
+                                                const char *fail_value) const {
+  if (IsValid())
+    return m_die->GetAttributeValueAsString(GetDWARF(), GetCU(), attr,
+                                            fail_value);
+  else
+    return fail_value;
+}
+
+uint64_t DWARFBaseDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
+                                               uint64_t fail_value) const {
+  if (IsValid())
+    return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr,
+                                              fail_value);
+  else
+    return fail_value;
+}
+
+int64_t DWARFBaseDIE::GetAttributeValueAsSigned(const dw_attr_t attr,
+                                            int64_t fail_value) const {
+  if (IsValid())
+    return m_die->GetAttributeValueAsSigned(GetDWARF(), GetCU(), attr,
+                                            fail_value);
+  else
+    return fail_value;
+}
+
+uint64_t DWARFBaseDIE::GetAttributeValueAsReference(const dw_attr_t attr,
+                                                uint64_t fail_value) const {
+  if (IsValid())
+    return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr,
+                                               fail_value);
+  else
+    return fail_value;
+}
+
+uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
+                                              uint64_t fail_value) const {
+  if (IsValid())
+    return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
+                                             fail_value);
+  else
+    return fail_value;
+}
+
+lldb::user_id_t DWARFBaseDIE::GetID() const {
+  return GetDIERef().GetUID(GetDWARF());
+}
+
+const char *DWARFBaseDIE::GetName() const {
+  if (IsValid())
+    return m_die->GetName(GetDWARF(), m_cu);
+  else
+    return nullptr;
+}
+
+lldb::LanguageType DWARFBaseDIE::GetLanguage() const {
+  if (IsValid())
+    return m_cu->GetLanguageType();
+  else
+    return lldb::eLanguageTypeUnknown;
+}
+
+lldb::ModuleSP DWARFBaseDIE::GetModule() const {
+  SymbolFileDWARF *dwarf = GetDWARF();
+  if (dwarf)
+    return dwarf->GetObjectFile()->GetModule();
+  else
+    return lldb::ModuleSP();
+}
+
+lldb_private::CompileUnit *DWARFBaseDIE::GetLLDBCompileUnit() const {
+  if (IsValid())
+    return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU());
+  else
+    return nullptr;
+}
+
+dw_offset_t DWARFBaseDIE::GetOffset() const {
+  if (IsValid())
+    return m_die->GetOffset();
+  else
+    return DW_INVALID_OFFSET;
+}
+
+dw_offset_t DWARFBaseDIE::GetCompileUnitRelativeOffset() const {
+  if (IsValid())
+    return m_die->GetOffset() - m_cu->GetOffset();
+  else
+    return DW_INVALID_OFFSET;
+}
+
+SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
+  if (m_cu)
+    return m_cu->GetSymbolFileDWARF();
+  else
+    return nullptr;
+}
+
+lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const {
+  if (m_cu)
+    return m_cu->GetTypeSystem();
+  else
+    return nullptr;
+}
+
+DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const {
+  lldb_private::TypeSystem *type_system = GetTypeSystem();
+  if (type_system)
+    return type_system->GetDWARFParser();
+  else
+    return nullptr;
+}
+
+bool DWARFBaseDIE::HasChildren() const {
+  return m_die && m_die->HasChildren();
+}
+
+bool DWARFBaseDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
+  return IsValid() && GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
+}
+
+size_t DWARFBaseDIE::GetAttributes(DWARFAttributes &attributes,
+                               uint32_t depth) const {
+  if (IsValid()) {
+    return m_die->GetAttributes(m_cu, m_cu->GetFixedFormSizes(), attributes,
+                                depth);
+  }
+  if (depth == 0)
+    attributes.Clear();
+  return 0;
+}
+
+void DWARFBaseDIE::Dump(lldb_private::Stream *s,
+                    const uint32_t recurse_depth) const {
+  if (s && IsValid())
+    m_die->Dump(GetDWARF(), GetCU(), *s, recurse_depth);
+}
+
+bool operator==(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs) {
+  return lhs.GetDIE() == rhs.GetDIE() && lhs.GetCU() == rhs.GetCU();
+}
+
+bool operator!=(const DWARFBaseDIE &lhs, const DWARFBaseDIE &rhs) {
+  return !(lhs == rhs);
+}
+
+const DWARFDataExtractor &DWARFBaseDIE::GetData() const {
+  // Clients must check if this DIE is valid before calling this function.
+  assert(IsValid());
+  return m_cu->GetData();
+}

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

 //===-- DWARFDIE.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFDIE_h_
 #define SymbolFileDWARF_DWARFDIE_h_
 
-#include "lldb/Core/dwarf.h"
-#include "lldb/lldb-types.h"
+#include "DWARFBaseDIE.h"
 
-struct DIERef;
-class DWARFASTParser;
-class DWARFAttributes;
-class DWARFUnit;
-class DWARFDebugInfoEntry;
-class DWARFDeclContext;
-class DWARFDIECollection;
-class SymbolFileDWARF;
-
-class DWARFDIE {
+class DWARFDIE : public DWARFBaseDIE {
 public:
-  DWARFDIE() : m_cu(nullptr), m_die(nullptr) {}
-
-  DWARFDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
-      : m_cu(cu), m_die(die) {}
-
-  DWARFDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
-      : m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {}
-
-  DWARFDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)
-      : m_cu(cu), m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
-
-  DWARFDIE(const DWARFUnit *cu, const DWARFDebugInfoEntry *die)
-      : m_cu(const_cast<DWARFUnit *>(cu)),
-        m_die(const_cast<DWARFDebugInfoEntry *>(die)) {}
+  using DWARFBaseDIE::DWARFBaseDIE;
 
   //----------------------------------------------------------------------
   // Tests
   //----------------------------------------------------------------------
-  explicit operator bool() const { return IsValid(); }
-
-  bool IsValid() const { return m_cu && m_die; }
-
   bool IsStructOrClass() const;
 
-  bool HasChildren() const;
-
-  bool Supports_DW_AT_APPLE_objc_complete_type() const;
-
   //----------------------------------------------------------------------
   // Accessors
   //----------------------------------------------------------------------
-  SymbolFileDWARF *GetDWARF() const;
-
-  DWARFUnit *GetCU() const { return m_cu; }
-
-  DWARFDebugInfoEntry *GetDIE() const { return m_die; }
-
-  DIERef GetDIERef() const;
-
-  lldb_private::TypeSystem *GetTypeSystem() const;
-
-  DWARFASTParser *GetDWARFParser() const;
-
-  void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
-    if (cu && die) {
-      m_cu = cu;
-      m_die = die;
-    } else {
-      Clear();
-    }
-  }
-
-  void Clear() {
-    m_cu = nullptr;
-    m_die = nullptr;
-  }
-
   lldb::ModuleSP GetContainingDWOModule() const;
 
   DWARFDIE
   GetContainingDWOModuleDIE() const;
 
   //----------------------------------------------------------------------
-  // Get the data that contains the attribute values for this DIE. Support
-  // for .debug_types means that any DIE can have its data either in the
-  // .debug_info or the .debug_types section; this method will return the
-  // correct section data.
-  //
-  // Clients must validate that this object is valid before calling this.
-  //----------------------------------------------------------------------
-  const lldb_private::DWARFDataExtractor &GetData() const;
-
-  //----------------------------------------------------------------------
   // Accessing information about a DIE
   //----------------------------------------------------------------------
-  dw_tag_t Tag() const;
-
-  const char *GetTagAsCString() const;
-
-  dw_offset_t GetOffset() const;
-
-  dw_offset_t GetCompileUnitRelativeOffset() const;
-
-  //----------------------------------------------------------------------
-  // Get the LLDB user ID for this DIE. This is often just the DIE offset,
-  // but it might have a SymbolFileDWARF::GetID() in the high 32 bits if
-  // we are doing Darwin DWARF in .o file, or DWARF stand alone debug
-  // info.
-  //----------------------------------------------------------------------
-  lldb::user_id_t GetID() const;
-
-  const char *GetName() const;
-
   const char *GetMangledName() const;
 
   const char *GetPubname() const;
 
   const char *GetQualifiedName(std::string &storage) const;
 
-  lldb::LanguageType GetLanguage() const;
-
-  lldb::ModuleSP GetModule() const;
-
-  lldb_private::CompileUnit *GetLLDBCompileUnit() const;
-
   lldb_private::Type *ResolveType() const;
 
   //----------------------------------------------------------------------
   // Resolve a type by UID using this DIE's DWARF file
   //----------------------------------------------------------------------
   lldb_private::Type *ResolveTypeUID(const DIERef &die_ref) const;
 
   //----------------------------------------------------------------------
public:
 
   //----------------------------------------------------------------------
   // Get a another DIE from the same DWARF file as this DIE. This will
   // check the current DIE's compile unit first to see if "die_offset" is
   // in the same compile unit, and fall back to checking the DWARF file.
   //----------------------------------------------------------------------
   DWARFDIE
   GetDIE(dw_offset_t die_offset) const;
+  using DWARFBaseDIE::GetDIE;
 
   DWARFDIE
   LookupDeepestBlock(lldb::addr_t file_addr) const;
 
   DWARFDIE
   GetParentDeclContextDIE() const;
 
   //----------------------------------------------------------------------
   // DeclContext related functions
   //----------------------------------------------------------------------
   void GetDeclContextDIEs(DWARFDIECollection &decl_context_dies) const;
 
   void GetDWARFDeclContext(DWARFDeclContext &dwarf_decl_ctx) const;
 
   void GetDWOContext(std::vector<lldb_private::CompilerContext> &context) const;
 
   //----------------------------------------------------------------------
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   //----------------------------------------------------------------------
-  const char *GetAttributeValueAsString(const dw_attr_t attr,
-                                        const char *fail_value) const;
-
-  uint64_t GetAttributeValueAsUnsigned(const dw_attr_t attr,
-                                       uint64_t fail_value) const;
-
-  int64_t GetAttributeValueAsSigned(const dw_attr_t attr,
-                                    int64_t fail_value) const;
-
-  uint64_t GetAttributeValueAsReference(const dw_attr_t attr,
-                                        uint64_t fail_value) const;
-
   DWARFDIE
   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
 
-  uint64_t GetAttributeValueAsAddress(const dw_attr_t attr,
-                                      uint64_t fail_value) const;
-
-  size_t GetAttributes(DWARFAttributes &attributes, uint32_t depth = 0) const;
-
   bool GetDIENamesAndRanges(const char *&name, const char *&mangled,
                             DWARFRangeList &ranges, int &decl_file,
                             int &decl_line, int &decl_column, int &call_file,
                             int &call_line, int &call_column,
                             lldb_private::DWARFExpression *frame_base) const;
 
   //----------------------------------------------------------------------
-  // Pretty printing
+  // CompilerDecl related functions
   //----------------------------------------------------------------------
 
-  void Dump(lldb_private::Stream *s, const uint32_t recurse_depth) const;
-
   lldb_private::CompilerDecl GetDecl() const;
 
   lldb_private::CompilerDeclContext GetDeclContext() const;
 
   lldb_private::CompilerDeclContext GetContainingDeclContext() const;
-
-protected:
-  DWARFUnit *m_cu;
-  DWARFDebugInfoEntry *m_die;
 };
 
-bool operator==(const DWARFDIE &lhs, const DWARFDIE &rhs);
-bool operator!=(const DWARFDIE &lhs, const DWARFDIE &rhs);
-
 #endif // SymbolFileDWARF_DWARFDIE_h_

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

 //===-- DWARFDIE.cpp --------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFDIE.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFUnit.h"
 #include "DWARFDIECollection.h"
-#include "DWARFDebugAbbrev.h"
-#include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
-#include "DWARFDebugInfoEntry.h"
-#include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
-#include "DWARFFormValue.h"
-#include "SymbolFileDWARF.h"
 
-#include "lldb/Core/Module.h"
-#include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/Type.h"
-#include "lldb/Symbol/TypeSystem.h"
+#include "DWARFDebugInfoEntry.h"
 
 using namespace lldb_private;
 
-DIERef DWARFDIE::GetDIERef() const {
-  if (!IsValid())
-    return DIERef();
-
-  dw_offset_t cu_offset = m_cu->GetOffset();
-  if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
-    cu_offset = m_cu->GetBaseObjOffset();
-  return DIERef(cu_offset, m_die->GetOffset());
-}
-
-dw_tag_t DWARFDIE::Tag() const {
-  if (m_die)
-    return m_die->Tag();
-  else
-    return 0;
-}
-
-const char *DWARFDIE::GetTagAsCString() const {
-  return lldb_private::DW_TAG_value_to_name(Tag());
-}
-
 DWARFDIE
 DWARFDIE::GetParent() const {
   if (IsValid())
     return DWARFDIE(m_cu, m_die->GetParent());
   else
     return DWARFDIE();
 }
 

 DWARFDIE
 DWARFDIE::GetDIE(dw_offset_t die_offset) const {
   if (IsValid())
     return m_cu->GetDIE(die_offset);
   else
     return DWARFDIE();
 }
 
-const char *DWARFDIE::GetAttributeValueAsString(const dw_attr_t attr,
-                                                const char *fail_value) const {
-  if (IsValid())
-    return m_die->GetAttributeValueAsString(GetDWARF(), GetCU(), attr,
-                                            fail_value);
-  else
-    return fail_value;
-}
-
-uint64_t DWARFDIE::GetAttributeValueAsUnsigned(const dw_attr_t attr,
-                                               uint64_t fail_value) const {
-  if (IsValid())
-    return m_die->GetAttributeValueAsUnsigned(GetDWARF(), GetCU(), attr,
-                                              fail_value);
-  else
-    return fail_value;
-}
-
-int64_t DWARFDIE::GetAttributeValueAsSigned(const dw_attr_t attr,
-                                            int64_t fail_value) const {
-  if (IsValid())
-    return m_die->GetAttributeValueAsSigned(GetDWARF(), GetCU(), attr,
-                                            fail_value);
-  else
-    return fail_value;
-}
-
 DWARFDIE
 DWARFDIE::GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const {
   if (IsValid()) {
     DWARFUnit *cu = GetCU();
     SymbolFileDWARF *dwarf = cu->GetSymbolFileDWARF();
     const bool check_specification_or_abstract_origin = true;
     DWARFFormValue form_value;
     if (m_die->GetAttributeValue(dwarf, cu, attr, form_value, nullptr,
                                  check_specification_or_abstract_origin))
       return dwarf->GetDIE(DIERef(form_value));
   }
   return DWARFDIE();
 }
 
-uint64_t DWARFDIE::GetAttributeValueAsReference(const dw_attr_t attr,
-                                                uint64_t fail_value) const {
-  if (IsValid())
-    return m_die->GetAttributeValueAsReference(GetDWARF(), GetCU(), attr,
-                                               fail_value);
-  else
-    return fail_value;
-}
-
-uint64_t DWARFDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
-                                              uint64_t fail_value) const {
-  if (IsValid())
-    return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
-                                             fail_value);
-  else
-    return fail_value;
-}
-
 DWARFDIE
 DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
   if (IsValid()) {
     SymbolFileDWARF *dwarf = GetDWARF();
     DWARFUnit *cu = GetCU();
     DWARFDebugInfoEntry *function_die = nullptr;
     DWARFDebugInfoEntry *block_die = nullptr;
     if (m_die->LookupAddress(file_addr, dwarf, cu, &function_die, &block_die)) {
       if (block_die && block_die != function_die) {
         if (cu->ContainsDIEOffset(block_die->GetOffset()))
           return DWARFDIE(cu, block_die);
         else
           return DWARFDIE(dwarf->DebugInfo()->GetCompileUnit(
                               DIERef(cu->GetOffset(), block_die->GetOffset())),
                           block_die);
       }
     }
   }
   return DWARFDIE();
 }
 
-lldb::user_id_t DWARFDIE::GetID() const {
-  return GetDIERef().GetUID(GetDWARF());
-}
-
-const char *DWARFDIE::GetName() const {
-  if (IsValid())
-    return m_die->GetName(GetDWARF(), m_cu);
-  else
-    return nullptr;
-}
-
 const char *DWARFDIE::GetMangledName() const {
   if (IsValid())
     return m_die->GetMangledName(GetDWARF(), m_cu);
   else
     return nullptr;
 }
 
 const char *DWARFDIE::GetPubname() const {
   if (IsValid())
     return m_die->GetPubname(GetDWARF(), m_cu);
   else
     return nullptr;
 }
 
 const char *DWARFDIE::GetQualifiedName(std::string &storage) const {
   if (IsValid())
     return m_die->GetQualifiedName(GetDWARF(), m_cu, storage);
   else
     return nullptr;
 }
 
-lldb::LanguageType DWARFDIE::GetLanguage() const {
-  if (IsValid())
-    return m_cu->GetLanguageType();
-  else
-    return lldb::eLanguageTypeUnknown;
-}
-
-lldb::ModuleSP DWARFDIE::GetModule() const {
-  SymbolFileDWARF *dwarf = GetDWARF();
-  if (dwarf)
-    return dwarf->GetObjectFile()->GetModule();
-  else
-    return lldb::ModuleSP();
-}
-
-lldb_private::CompileUnit *DWARFDIE::GetLLDBCompileUnit() const {
-  if (IsValid())
-    return GetDWARF()->GetCompUnitForDWARFCompUnit(GetCU());
-  else
-    return nullptr;
-}
-
 lldb_private::Type *DWARFDIE::ResolveType() const {
   if (IsValid())
     return GetDWARF()->ResolveType(*this, true);
   else
     return nullptr;
 }
 
 lldb_private::Type *DWARFDIE::ResolveTypeUID(const DIERef &die_ref) const {

 DWARFDIE
 DWARFDIE::GetParentDeclContextDIE() const {
   if (IsValid())
     return m_die->GetParentDeclContextDIE(GetDWARF(), m_cu);
   else
     return DWARFDIE();
 }
 
-dw_offset_t DWARFDIE::GetOffset() const {
-  if (IsValid())
-    return m_die->GetOffset();
-  else
-    return DW_INVALID_OFFSET;
-}
-
-dw_offset_t DWARFDIE::GetCompileUnitRelativeOffset() const {
-  if (IsValid())
-    return m_die->GetOffset() - m_cu->GetOffset();
-  else
-    return DW_INVALID_OFFSET;
-}
-
-SymbolFileDWARF *DWARFDIE::GetDWARF() const {
-  if (m_cu)
-    return m_cu->GetSymbolFileDWARF();
-  else
-    return nullptr;
-}
-
-lldb_private::TypeSystem *DWARFDIE::GetTypeSystem() const {
-  if (m_cu)
-    return m_cu->GetTypeSystem();
-  else
-    return nullptr;
-}
-
-DWARFASTParser *DWARFDIE::GetDWARFParser() const {
-  lldb_private::TypeSystem *type_system = GetTypeSystem();
-  if (type_system)
-    return type_system->GetDWARFParser();
-  else
-    return nullptr;
-}
-
 bool DWARFDIE::IsStructOrClass() const {
   const dw_tag_t tag = Tag();
   return tag == DW_TAG_class_type || tag == DW_TAG_structure_type;
 }
 
 DWARFDIE
 DWARFDIE::GetContainingDWOModuleDIE() const {
   if (IsValid()) {
if (dwo_module_die) {
       const char *module_name = dwo_module_die.GetName();
       if (module_name)
         return GetDWARF()->GetDWOModule(lldb_private::ConstString(module_name));
     }
   }
   return lldb::ModuleSP();
 }
 
-bool DWARFDIE::HasChildren() const {
-  return m_die && m_die->HasChildren();
-}
-
-bool DWARFDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
-  return IsValid() && GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
-}
-
-size_t DWARFDIE::GetAttributes(DWARFAttributes &attributes,
-                               uint32_t depth) const {
-  if (IsValid()) {
-    return m_die->GetAttributes(m_cu, m_cu->GetFixedFormSizes(), attributes,
-                                depth);
-  }
-  if (depth == 0)
-    attributes.Clear();
-  return 0;
-}
-
 bool DWARFDIE::GetDIENamesAndRanges(
     const char *&name, const char *&mangled, DWARFRangeList &ranges,
     int &decl_file, int &decl_line, int &decl_column, int &call_file,
     int &call_line, int &call_column,
     lldb_private::DWARFExpression *frame_base) const {
   if (IsValid()) {
     return m_die->GetDIENamesAndRanges(
         GetDWARF(), GetCU(), name, mangled, ranges, decl_file, decl_line,
         decl_column, call_file, call_line, call_column, frame_base);
   } else
     return false;
 }
 
-void DWARFDIE::Dump(lldb_private::Stream *s,
-                    const uint32_t recurse_depth) const {
-  if (s && IsValid())
-    m_die->Dump(GetDWARF(), GetCU(), *s, recurse_depth);
-}
-
 CompilerDecl DWARFDIE::GetDecl() const {
   DWARFASTParser *dwarf_ast = GetDWARFParser();
   if (dwarf_ast)
     return dwarf_ast->GetDeclForUIDFromDWARF(*this);
   else
     return CompilerDecl();
 }
 
 CompilerDeclContext DWARFDIE::GetDeclContext() const {
   DWARFASTParser *dwarf_ast = GetDWARFParser();
   if (dwarf_ast)
     return dwarf_ast->GetDeclContextForUIDFromDWARF(*this);
   else
     return CompilerDeclContext();
 }
 
 CompilerDeclContext DWARFDIE::GetContainingDeclContext() const {
   DWARFASTParser *dwarf_ast = GetDWARFParser();
   if (dwarf_ast)
     return dwarf_ast->GetDeclContextContainingUIDFromDWARF(*this);
   else
     return CompilerDeclContext();
 }
-
-bool operator==(const DWARFDIE &lhs, const DWARFDIE &rhs) {
-  return lhs.GetDIE() == rhs.GetDIE() && lhs.GetCU() == rhs.GetCU();
-}
-
-bool operator!=(const DWARFDIE &lhs, const DWARFDIE &rhs) {
-  return !(lhs == rhs);
-}
-
-const DWARFDataExtractor &DWARFDIE::GetData() const {
-  // Clients must check if this DIE is valid before calling this function.
-  assert(IsValid());
-  return m_cu->GetData();
-}