Move DWARFUnitSection from inheriting SmallVector to holding an instance.

[friss]

Summary

This introduces all the proxy methods that make DWARFUnitSection behave
like the vector it was before. It has no functional change, but it moves
away from the multiple inheritance that everybody dislikes.

Follow-up patches will progressively move the interface away from the
vector interface to something that is closer to the intended semantics
of the data structure.

[samsonov]

Are you sure you need all these methods? For instance, can you introduce

iterator_range units() {
  return iterator_range(Units.begin(), Units.end());
}

and use this method in DWARFContext methods getNumCompileUnits(), getNumTypeUnits(), etc. In this case there will be no need for exposing begin()/end() methods directly. Same for operator[] - IMO it makes more sense to have a method "UnitType* getUnitAtIndex()" than "std::unique_ptr<UnitType>& operator[]", and make caller call get().

[friss]

As it is explained in the commit log, this patch only moves from inheritance to composition, and the goal is to design a new interface better suited to DWARFUnitSection. This step is arguably what I should have posted first, the inheritance step wasn't really necessary. Now I could modify a lot more things in one go, but I usually get asked to split functional steps more not less :-)

[friss]

Abandoned in favour of D5369

lib/DebugInfo/DWARFUnit.h

 //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_DEBUGINFO_DWARFUNIT_H
 #define LLVM_LIB_DEBUGINFO_DWARFUNIT_H
 
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugInfoEntry.h"
 #include "DWARFDebugRangeList.h"
 #include "DWARFRelocMap.h"
+#include <utility>
 #include <vector>
 
 namespace llvm {
 
 namespace object {
 class ObjectFile;
 }
 

 public:
   /// Returns the Unit that contains the given section offset in the
   /// same section this Unit originated from.
   virtual DWARFUnit *getUnitForOffset(uint32_t Offset) const = 0;
 };
 
 /// Concrete instance of DWARFUnitSection, specialized for one Unit type.
 template<typename UnitType>
-class DWARFUnitSection : public SmallVector<std::unique_ptr<UnitType>, 1>,
-                         public DWARFUnitSectionBase {
+class DWARFUnitSection : public DWARFUnitSectionBase {
+  SmallVector<std::unique_ptr<UnitType>, 1> Units;
 
   struct UnitOffsetComparator {
     bool operator()(const std::unique_ptr<UnitType> &LHS,
                     const std::unique_ptr<UnitType> &RHS) const {
       return LHS->getOffset() < RHS->getOffset();
     }
     bool operator()(const std::unique_ptr<UnitType> &LHS,
                     uint32_t RHS) const {
       return LHS->getOffset() < RHS;
     }
     bool operator()(uint32_t LHS,
                     const std::unique_ptr<UnitType> &RHS) const {
       return LHS < RHS->getOffset();
     }
   };
 
 public:
   typedef llvm::SmallVectorImpl<std::unique_ptr<UnitType>> UnitVector;
+  typedef typename UnitVector::size_type size_type;
   typedef typename UnitVector::iterator iterator;
+  typedef typename UnitVector::const_iterator const_iterator;
+  typedef typename UnitVector::reference reference;
+  typedef typename UnitVector::const_reference const_reference;
   typedef llvm::iterator_range<typename UnitVector::iterator> iterator_range;
+  typedef llvm::iterator_range<typename UnitVector::const_iterator> const_iterator_range;
+
+  iterator begin() {
+    return Units.begin();
+  }
+  const_iterator begin() const {
+    return Units.begin();
+  }
+
+  iterator end() {
+    return Units.end();
+  }
+  const_iterator end() const {
+    return Units.end();
+  }
+
+  size_type size() {
+    return Units.size();
+  }
+
+  reference operator[](unsigned Index) {
+    return Units[Index];
+  }
+  const_reference operator[](unsigned Index) const {
+    return Units[Index];
+  }
+
+  bool empty() const {
+    return Units.empty();
+  }
+
+  reference back() {
+    return Units.back();
+  }
+  const_reference back() const {
+    return Units.back();
+  }
+
+  void push_back(std::unique_ptr<UnitType> &&Elt) {
+    Units.push_back(std::forward<std::unique_ptr<UnitType> &&>(Elt));
+  }
 
   UnitType *getUnitForOffset(uint32_t Offset) const {
-    auto *CU = std::lower_bound(this->begin(), this->end(), Offset,
+    auto *CU = std::lower_bound(Units.begin(), Units.end(), Offset,
                                 UnitOffsetComparator());
-    if (CU != this->end())
+    if (CU != Units.end())
       return CU->get();
     return nullptr;
   }
 };
 
 class DWARFUnit {
   DWARFContext &Context;