Add a UnitKind field to DWARFUnit so that we can discriminate the unit's origin section.

[friss]

Summary

There is no simple way to get the origin section of a DWARFUnit. It is necessary
to know from which section a Unit has been extracted to be able to resolve
cross-unit references (to find the right list to search fo the reference
target).

This patch adds a field and an accessor to the DWARFUnit that indicates where
it originated from. This information will be used in a subsequent patch to
implement a generic version of DWARFContext::getCompilationUnitForOffset()
that will work with arbitrary unit types.

Note that this is nearly implemented like the start of LLVM-style RTTI for
the DWARFUnit, but it seems that we don't need separate classes to represent
the DWO variants of Units as only their origin changes. Thus we only
introduce this discriminant field.

[aprantl]

I assume that there will be cross-unit reference testcase for llvm-dwarfdump in a subsequent patch that will exercise this code?
Otherwise this looks simple enough.

[friss]

Superseded by D5310

lib/DebugInfo/DWARFCompileUnit.h

 #define LLVM_LIB_DEBUGINFO_DWARFCOMPILEUNIT_H
 
 #include "DWARFUnit.h"
 
 namespace llvm {
 
 class DWARFCompileUnit : public DWARFUnit {
 public:
-  DWARFCompileUnit(DWARFContext& Context, const DWARFDebugAbbrev *DA,
+  DWARFCompileUnit(UnitKind Kind, DWARFContext& Context, const DWARFDebugAbbrev *DA,
                    StringRef IS, StringRef RS, StringRef SS, StringRef SOS,
                    StringRef AOS, const RelocAddrMap *M, bool LE)
-    : DWARFUnit(Context, DA, IS, RS, SS, SOS, AOS, M, LE) {}
+    : DWARFUnit(Kind, Context, DA, IS, RS, SS, SOS, AOS, M, LE) {}
   void dump(raw_ostream &OS);
   // VTable anchor.
   ~DWARFCompileUnit() override;
 };
 
 }
 
 #endif

lib/DebugInfo/DWARFContext.cpp

 
 void DWARFContext::parseCompileUnits() {
   if (!CUs.empty())
     return;
   uint32_t offset = 0;
   const DataExtractor &DIData = DataExtractor(getInfoSection().Data,
                                               isLittleEndian(), 0);
   while (DIData.isValidOffset(offset)) {
-    std::unique_ptr<DWARFCompileUnit> CU(new DWARFCompileUnit(*this,
-        getDebugAbbrev(), getInfoSection().Data, getRangeSection(),
+    std::unique_ptr<DWARFCompileUnit> CU(new DWARFCompileUnit(DWARFUnit::UK_Compile,
+        *this, getDebugAbbrev(), getInfoSection().Data, getRangeSection(),
         getStringSection(), StringRef(), getAddrSection(),
         &getInfoSection().Relocs, isLittleEndian()));
     if (!CU->extract(DIData, &offset)) {
       break;
     }
     CUs.push_back(std::move(CU));
     offset = CUs.back()->getNextUnitOffset();
   }
 }
 
 void DWARFContext::parseTypeUnits() {
   if (!TUs.empty())
     return;
   for (const auto &I : getTypesSections()) {
     uint32_t offset = 0;
     const DataExtractor &DIData =
         DataExtractor(I.second.Data, isLittleEndian(), 0);
     while (DIData.isValidOffset(offset)) {
-      std::unique_ptr<DWARFTypeUnit> TU(new DWARFTypeUnit(*this,
+      std::unique_ptr<DWARFTypeUnit> TU(new DWARFTypeUnit(DWARFUnit::UK_Type, *this,
            getDebugAbbrev(), I.second.Data, getRangeSection(),
            getStringSection(), StringRef(), getAddrSection(),
            &I.second.Relocs, isLittleEndian()));
       if (!TU->extract(DIData, &offset))
         break;
       TUs.push_back(std::move(TU));
       offset = TUs.back()->getNextUnitOffset();
     }
   }
 }
 
 void DWARFContext::parseDWOCompileUnits() {
   if (!DWOCUs.empty())
     return;
   uint32_t offset = 0;
   const DataExtractor &DIData =
       DataExtractor(getInfoDWOSection().Data, isLittleEndian(), 0);
   while (DIData.isValidOffset(offset)) {
-    std::unique_ptr<DWARFCompileUnit> DWOCU(new DWARFCompileUnit(*this,
-        getDebugAbbrevDWO(), getInfoDWOSection().Data, getRangeDWOSection(),
-        getStringDWOSection(), getStringOffsetDWOSection(), getAddrSection(),
-        &getInfoDWOSection().Relocs, isLittleEndian()));
+    std::unique_ptr<DWARFCompileUnit> DWOCU(new DWARFCompileUnit(
+        DWARFUnit::UK_DWOCompile, *this, getDebugAbbrevDWO(),
+        getInfoDWOSection().Data, getRangeDWOSection(), getStringDWOSection(),
+        getStringOffsetDWOSection(), getAddrSection(), &getInfoDWOSection().Relocs,
+        isLittleEndian()));
     if (!DWOCU->extract(DIData, &offset)) {
       break;
     }
     DWOCUs.push_back(std::move(DWOCU));
     offset = DWOCUs.back()->getNextUnitOffset();
   }
 }
 
 void DWARFContext::parseDWOTypeUnits() {
   if (!DWOTUs.empty())
     return;
   for (const auto &I : getTypesDWOSections()) {
     uint32_t offset = 0;
     const DataExtractor &DIData =
         DataExtractor(I.second.Data, isLittleEndian(), 0);
     while (DIData.isValidOffset(offset)) {
-      std::unique_ptr<DWARFTypeUnit> TU(new DWARFTypeUnit(*this,
-          getDebugAbbrevDWO(), I.second.Data, getRangeDWOSection(),
+      std::unique_ptr<DWARFTypeUnit> TU(new DWARFTypeUnit(DWARFUnit::UK_DWOType,
+          *this, getDebugAbbrevDWO(), I.second.Data, getRangeDWOSection(),
           getStringDWOSection(), getStringOffsetDWOSection(), getAddrSection(),
           &I.second.Relocs, isLittleEndian()));
       if (!TU->extract(DIData, &offset))
         break;
       DWOTUs.push_back(std::move(TU));
       offset = DWOTUs.back()->getNextUnitOffset();
     }
   }

lib/DebugInfo/DWARFTypeUnit.h

 
 namespace llvm {
 
 class DWARFTypeUnit : public DWARFUnit {
 private:
   uint64_t TypeHash;
   uint32_t TypeOffset;
 public:
-  DWARFTypeUnit(DWARFContext &Context, const DWARFDebugAbbrev *DA,
+  DWARFTypeUnit(UnitKind Kind, DWARFContext &Context, const DWARFDebugAbbrev *DA,
                 StringRef IS, StringRef RS, StringRef SS, StringRef SOS,
                 StringRef AOS, const RelocAddrMap *M, bool LE)
-    : DWARFUnit(Context, DA, IS, RS, SS, SOS, AOS, M, LE) {}
+    : DWARFUnit(Kind, Context, DA, IS, RS, SS, SOS, AOS, M, LE) {}
   uint32_t getHeaderSize() const override {
     return DWARFUnit::getHeaderSize() + 12;
   }
   void dump(raw_ostream &OS);
 protected:
   bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr) override;
 };
 
 }
 
 #endif
 

lib/DebugInfo/DWARFUnit.h

 }
 
 class DWARFContext;
 class DWARFDebugAbbrev;
 class StringRef;
 class raw_ostream;
 
 class DWARFUnit {
+public:
+  enum UnitKind {
+    UK_Compile,
+    UK_DWOCompile,
+    UK_Type,
+    UK_DWOType,
+  };
+
+private:
+  UnitKind Kind;
   DWARFContext &Context;
 
   const DWARFDebugAbbrev *Abbrev;
   StringRef InfoSection;
   StringRef RangeSection;
   uint32_t RangeSectionBase;
   StringRef StringSection;
   StringRef StringOffsetSection;
private:
   std::unique_ptr<DWOHolder> DWO;
 
 protected:
   virtual bool extractImpl(DataExtractor debug_info, uint32_t *offset_ptr);
   /// Size in bytes of the unit header.
   virtual uint32_t getHeaderSize() const { return 11; }
 
 public:
-  DWARFUnit(DWARFContext& Context, const DWARFDebugAbbrev *DA, StringRef IS,
-            StringRef RS, StringRef SS, StringRef SOS, StringRef AOS,
+  DWARFUnit(UnitKind Kind, DWARFContext& Context, const DWARFDebugAbbrev *DA,
+            StringRef IS, StringRef RS, StringRef SS, StringRef SOS, StringRef AOS,
             const RelocAddrMap *M, bool LE);
 
   virtual ~DWARFUnit();
 
+  UnitKind getKind() const { return Kind; }
   DWARFContext& getContext() const { return Context; }
 
   StringRef getStringSection() const { return StringSection; }
   StringRef getStringOffsetSection() const { return StringOffsetSection; }
   void setAddrOffsetSection(StringRef AOS, uint32_t Base) {
     AddrOffsetSection = AOS;
     AddrOffsetSectionBase = Base;
   }

lib/DebugInfo/DWARFUnit.cpp

 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Path.h"
 #include <cstdio>
 
 using namespace llvm;
 using namespace dwarf;
 
-DWARFUnit::DWARFUnit(DWARFContext &DC, const DWARFDebugAbbrev *DA,
+DWARFUnit::DWARFUnit(UnitKind Kind, DWARFContext &DC, const DWARFDebugAbbrev *DA,
                      StringRef IS, StringRef RS, StringRef SS, StringRef SOS,
                      StringRef AOS, const RelocAddrMap *M, bool LE)
-  : Context(DC), Abbrev(DA), InfoSection(IS), RangeSection(RS),
+  : Kind(Kind), Context(DC), Abbrev(DA), InfoSection(IS), RangeSection(RS),
     StringSection(SS), StringOffsetSection(SOS), AddrOffsetSection(AOS),
     RelocMap(M), isLittleEndian(LE) {
   clear();
 }
 
 DWARFUnit::~DWARFUnit() {
 }