[DebugInfo] Clean up DIEUnit. NFC.

[ikudrin]

Summary

This removes members of the DIEUnit class which were used only in unit tests.

Note also that child classes shadowed some of these methods, namely, getDwarfVersion() was overridden in DwartfUnit and getLength() was overridden in DwarfCompileUnit.

[dblaikie]

Sounds good

llvm/include/llvm/CodeGen/DIE.h

class DIEUnit {
   /// parent backchain and getting the Unit DIE, and then casting itself to a
   /// DIEUnit. This allows us to be able to find the DIEUnit for any DIE without
   /// having to store a pointer to the DIEUnit in each DIE instance.
   DIE Die;
   /// The section this unit will be emitted in. This may or may not be set to
   /// a valid section depending on the client that is emitting DWARF.
   MCSection *Section;
   uint64_t Offset; /// .debug_info or .debug_types absolute section offset.
-  uint32_t Length; /// The length in bytes of all of the DIEs in this unit.
-  const uint16_t Version; /// The Dwarf version number for this unit.
-  const uint8_t AddrSize; /// The size in bytes of an address for this unit.
 protected:
   virtual ~DIEUnit() = default;
 
 public:
-  DIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag);
+  explicit DIEUnit(dwarf::Tag UnitTag);
   DIEUnit(const DIEUnit &RHS) = delete;
   DIEUnit(DIEUnit &&RHS) = delete;
   void operator=(const DIEUnit &RHS) = delete;
   void operator=(const DIEUnit &&RHS) = delete;
   /// Set the section that this DIEUnit will be emitted into.
   ///
   /// This function is used by some clients to set the section. Not all clients
   /// that emit DWARF use this section variable.
   void setSection(MCSection *Section) {
     assert(!this->Section);
     this->Section = Section;
   }
 
   virtual const MCSymbol *getCrossSectionRelativeBaseAddress() const {
     return nullptr;
   }
 
   /// Return the section that this DIEUnit will be emitted into.
   ///
   /// \returns Section pointer which can be NULL.
   MCSection *getSection() const { return Section; }
   void setDebugSectionOffset(unsigned O) { Offset = O; }
   unsigned getDebugSectionOffset() const { return Offset; }
-  void setLength(uint64_t L) { Length = L; }
-  uint64_t getLength() const { return Length; }
-  uint16_t getDwarfVersion() const { return Version; }
-  uint16_t getAddressSize() const { return AddrSize; }
   DIE &getUnitDie() { return Die; }
   const DIE &getUnitDie() const { return Die; }
 };
 
 struct BasicDIEUnit final : DIEUnit {
-  BasicDIEUnit(uint16_t Version, uint8_t AddrSize, dwarf::Tag UnitTag)
-      : DIEUnit(Version, AddrSize, UnitTag) {}
+  explicit BasicDIEUnit(dwarf::Tag UnitTag) : DIEUnit(UnitTag) {}
 };
 
 //===--------------------------------------------------------------------===//
 /// DIELoc - Represents an expression location.
 //
 class DIELoc : public DIEValueList {
   mutable unsigned Size = 0; // Size in bytes excluding size header.
 

llvm/include/llvm/DWARFLinker/DWARFLinkerCompileUnit.h

CompileUnit(DWARFUnit &OrigUnit, unsigned ID, bool CanUseODR,
     else
       HasODR = false;
   }
 
   DWARFUnit &getOrigUnit() const { return OrigUnit; }
 
   unsigned getUniqueID() const { return ID; }
 
-  void createOutputDIE() {
-    NewUnit.emplace(OrigUnit.getVersion(), OrigUnit.getAddressByteSize(),
-                    OrigUnit.getUnitDIE().getTag());
-  }
+  void createOutputDIE() { NewUnit.emplace(OrigUnit.getUnitDIE().getTag()); }
 
   DIE *getOutputUnitDIE() const {
     if (NewUnit)
       return &const_cast<BasicDIEUnit &>(*NewUnit).getUnitDie();
     return nullptr;
   }
 
   bool hasODR() const { return HasODR; }

llvm/lib/CodeGen/AsmPrinter/DIE.cpp

unsigned DIE::computeOffsetsAndAbbrevs(const AsmPrinter *AP,
   // correctly.
   setSize(CUOffset - getOffset());
   return CUOffset;
 }
 
 //===----------------------------------------------------------------------===//
 // DIEUnit Implementation
 //===----------------------------------------------------------------------===//
-DIEUnit::DIEUnit(uint16_t V, uint8_t A, dwarf::Tag UnitTag)
-    : Die(UnitTag), Section(nullptr), Offset(0), Length(0), Version(V),
-      AddrSize(A)
-{
+DIEUnit::DIEUnit(dwarf::Tag UnitTag)
+    : Die(UnitTag), Section(nullptr), Offset(0) {
   Die.Owner = this;
   assert((UnitTag == dwarf::DW_TAG_compile_unit ||
           UnitTag == dwarf::DW_TAG_skeleton_unit ||
           UnitTag == dwarf::DW_TAG_type_unit ||
           UnitTag == dwarf::DW_TAG_partial_unit) &&
          "expected a unit TAG");
 }
 

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

 
 bool DIEDwarfExpression::isFrameRegister(const TargetRegisterInfo &TRI,
                                          unsigned MachineReg) {
   return MachineReg == TRI.getFrameRegister(*AP.MF);
 }
 
 DwarfUnit::DwarfUnit(dwarf::Tag UnitTag, const DICompileUnit *Node,
                      AsmPrinter *A, DwarfDebug *DW, DwarfFile *DWU)
-    : DIEUnit(A->getDwarfVersion(), A->MAI->getCodePointerSize(), UnitTag),
-      CUNode(Node), Asm(A), DD(DW), DU(DWU), IndexTyDie(nullptr) {
-}
+    : DIEUnit(UnitTag), CUNode(Node), Asm(A), DD(DW), DU(DWU),
+      IndexTyDie(nullptr) {}
 
 DwarfTypeUnit::DwarfTypeUnit(DwarfCompileUnit &CU, AsmPrinter *A,
                              DwarfDebug *DW, DwarfFile *DWU,
                              MCDwarfDwoLineTable *SplitLineTable)
     : DwarfUnit(dwarf::DW_TAG_type_unit, CU.getCUNode(), A, DW, DWU), CU(CU),
       SplitLineTable(SplitLineTable) {
 }
 

llvm/unittests/DebugInfo/DWARF/DwarfGenerator.h

 /// A DWARF compile unit used to generate DWARF compile/type units.
 ///
 /// Instances of these classes are created by instances of the Generator
 /// class. All information required to generate a DWARF compile unit is
 /// contained inside this class.
 class CompileUnit {
   Generator &DG;
   BasicDIEUnit DU;
+  uint64_t Length; /// The length in bytes of all of the DIEs in this unit.
+  const uint16_t Version; /// The Dwarf version number for this unit.
+  const uint8_t AddrSize; /// The size in bytes of an address for this unit.
 
 public:
   CompileUnit(Generator &D, uint16_t V, uint8_t A)
-      : DG(D), DU(V, A, dwarf::DW_TAG_compile_unit) {}
+      : DG(D), DU(dwarf::DW_TAG_compile_unit), Version(V), AddrSize(A) {}
   DIE getUnitDIE();
   Generator &getGenerator() { return DG; }
   uint64_t getOffset() const { return DU.getDebugSectionOffset(); }
-  uint64_t getLength() const { return DU.getLength(); }
-  uint16_t getVersion() const { return DU.getDwarfVersion(); }
-  uint16_t getAddressSize() const { return DU.getAddressSize(); }
+  uint64_t getLength() const { return Length; }
+  uint16_t getVersion() const { return Version; }
+  uint16_t getAddressSize() const { return AddrSize; }
   void setOffset(uint64_t Offset) { DU.setDebugSectionOffset(Offset); }
-  void setLength(uint64_t Length) { DU.setLength(Length); }
+  void setLength(uint64_t L) { Length = L; }
 };
 
 /// A DWARF line unit-like class used to generate DWARF line units.
 ///
 /// Instances of this class are created by instances of the Generator class.
 class LineTable {
 public:
   enum ValueLength { Byte = 1, Half = 2, Long = 4, Quad = 8, ULEB, SLEB };