Improve clarity of CS2::TableOf

Currently, the implementation of CS2::TableOf does a few of things that
hinder the ability to reason about the code. 1) To increase the terse-
ness of the code, it makes prolific use of preprocessor macro substi-
tutes for class and function template parameters.  2) It uses inheri-
tance rather than composition to bring in the implementation of its
underlying storage. 3) When providing a function template parameter for
initializing entires, it passes the parameter by non-const reference,
preventing the use of r-values for initialization.

The second point is particularly problematic, as it leads to scenarios
like the following:

```
class Allocator;
class TakesAnAllocator {
  TakesAnAllocator(Allocator a);
}
TableOf<TakesAnAllocator> myTable(someAllocator);
myTable.addElement(myTable);
```

In the final line of this example, the user of TableOf takes advantage
of TableOf's inheriting from its underlying container to initialize
objects as if it were an Allocator.

To solve 1), this change set expands the preprocessor macros, purging
them from existence.  To solve 2) this change set refactors TableOf to
use composition to import the functionality of the underlying storage
rather than inheritance, plus the required changes to the rest of the
code-base to support this new model.  Finally, to solve 3) we change the
signature of both TableOf's AddEntry, as well as the constructor for
BaseArrayOf::DerivedElement to take the initializer object by const
reference.  Furthermore, we update TR_BitVector's copy constructor and
assignment operator such that they also take const references, to cause
TR_RegisterCandidate's implicit copy constructor to use const referen-
ces.

Signed-off-by: Luc des Trois Maisons <lmaisons@ca.ibm.com>

Author: lmaisons

compiler/cs2/arrayof.h

@@ -64,7 +64,7 @@ namespace CS2 {
 ///
 // ------------------------------------------------------------------------
 template <class AElementType, class Allocator, size_t segmentBits = 8>
-class BaseArrayOf : private Allocator {
+struct BaseArrayOf : private Allocator {
 public:
 
   BaseArrayOf (const Allocator &a = Allocator());
@@ -102,10 +102,12 @@ class BaseArrayOf : private Allocator {
   /// \param[in] s Size to grow the array.
   void GrowTo (size_t s);
 
+  /// \return Size in bytes of memory dynamically allocated for the array
+  unsigned long DynamicMemoryUsage() const;
+
   /// \return Size in bytes currently allocated for the array
   unsigned long MemoryUsage() const;
 
-  protected:
   /// \return Number of elements per segment.
   size_t ElementsPerSegment() const;
 
@@ -132,7 +134,6 @@ class BaseArrayOf : private Allocator {
     return out;
   }
 
-  protected:
   class DerivedElement {
     public:
 
@@ -142,7 +143,7 @@ class BaseArrayOf : private Allocator {
 
     DerivedElement() : fElement() {}
     template <class Initializer>
-    DerivedElement (Initializer &element) : fElement(element) {}
+    DerivedElement (const Initializer &element) : fElement(element) {}
     ~DerivedElement() {}
 
     AElementType &Element() { return fElement; }
@@ -189,7 +190,8 @@ CS2_ARTEMP inline typename CS2_BASEARDECL::DerivedElement *CS2_BASEARDECL::Segme
 }
 
 CS2_ARTEMP inline
-typename CS2_BASEARDECL::DerivedElement *CS2_BASEARDECL::DerivedElementAt (size_t elementIndex) const {
+typename CS2_BASEARDECL::DerivedElement *
+CS2_BASEARDECL::DerivedElementAt (size_t elementIndex) const {
   size_t segmentMapIndex = elementIndex >> segmentBits;
   CS2Assert (segmentMapIndex < fNumberOfSegments,
           ("Index %lu does not exist", elementIndex));
@@ -385,16 +387,19 @@ CS2_ARTEMP inline void CS2_BASEARDECL::ShrinkTo (size_t newSize) {
   }
 }
 
-CS2_ARTEMP inline unsigned long CS2_BASEARDECL::MemoryUsage() const {
+CS2_ARTEMP inline unsigned long CS2_BASEARDECL::DynamicMemoryUsage() const {
   unsigned long sizeInBytes;
 
   sizeInBytes = fMaxSegments * sizeof(DerivedElement *);
   sizeInBytes += NumberOfElements() * sizeof(DerivedElement);
-  sizeInBytes += sizeof(CS2_BASEARDECL);
 
   return sizeInBytes;
 }
 
+CS2_ARTEMP inline unsigned long CS2_BASEARDECL::MemoryUsage() const {
+  return DynamicMemoryUsage() + sizeof(CS2_BASEARDECL);
+}
+
 
 template <class AElementType, class Allocator, size_t segmentBits = 8, class Initializer = AElementType>
   class ArrayOf : public CS2_BASEARDECL {

compiler/cs2/bitvectr.h

@@ -69,7 +69,7 @@ class ABitVector : private Allocator {
   class BitRef;
 public:
 
-  ABitVector(const Allocator &a = Allocator()) :
+  explicit ABitVector(const Allocator &a = Allocator()) :
     Allocator(a), fNumBits(0), fBitWords(NULL) {
   }