Redesign the spare bit mask calculation

This adds a `getSpareBits` method to all the TypeInfo classes
that returns a suitable bitmask indicating the spare bits available
in values of this type.  This gives us a way to recursively explore
the type tree and build up a full spare bit mask for an arbitrary type.

Happily, it appears we actually do have enough information to do this
calculation entirely from first principles, without requiring additional
reflection information.  So once this is stable, we should remove my
earlier incomplete effort to publish spare bit mask info in the reflection
data, as that adds unnecessary metadata to every binary.

This doubtless still has plenty of holes, but seems sufficient
to handle a few basic enum types, including the stdlib DecodingError
which was used as an example to work out some key issues.

Author: tbkka

include/swift/RemoteInspection/BitMask.h

@@ -35,6 +35,7 @@ class BitMask {
   ~BitMask() {
     free(mask);
   }
+private:
   // Construct a bitmask of the appropriate number of bytes
   // initialized to all bits set
   BitMask(unsigned sizeInBytes = 0): size(sizeInBytes) {
@@ -58,6 +59,24 @@ class BitMask {
 
     memset(mask, 0xff, size);
   }
+
+public:  
+  static BitMask zeroMask(unsigned sizeInBytes) {
+    auto mask = BitMask(sizeInBytes);
+    mask.makeZero();
+    return mask;
+  }
+
+  static BitMask oneMask(unsigned sizeInBytes) {
+    auto mask = BitMask(sizeInBytes);
+    return mask;
+  }
+
+  BitMask(unsigned sizeInBytes, uint64_t sourceMask): size(sizeInBytes) {
+    mask = (uint8_t *)calloc(1, sizeInBytes);
+    memcpy(mask, &sourceMask, sizeInBytes);
+  }
+
   // Construct a bitmask of the appropriate number of bytes
   // initialized with bits from the specified buffer
   BitMask(unsigned sizeInBytes, const uint8_t *initialValue,
@@ -184,13 +203,7 @@ class BitMask {
   }
 
   int countZeroBits() const {
-    static const int counter[] =
-      {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0};
-    int bits = 0;
-    for (unsigned i = 0; i < size; ++i) {
-      bits += counter[mask[i] >> 4] + counter[mask[i] & 15];
-    }
-    return bits;
+    return (size * 8) - countSetBits();
   }
 
   // Treat the provided value as a mask, `and` it with
@@ -242,6 +255,12 @@ class BitMask {
 #endif
   }
 
+  void keepOnlyLeastSignificantBytes(unsigned n) {
+    if (size > n) {
+      size = n;
+    }
+  }
+  
   unsigned numBits() const {
     return size * 8;
   }

include/swift/RemoteInspection/TypeLowering.h

@@ -23,6 +23,7 @@
 #include "llvm/Support/Casting.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Remote/TypeInfoProvider.h"
+#include "swift/RemoteInspection/BitMask.h"
 #include "swift/RemoteInspection/DescriptorFinder.h"
 
 #include <memory>
@@ -34,6 +35,7 @@ using llvm::cast;
 using llvm::dyn_cast;
 using remote::RemoteRef;
 
+class TypeConverter;
 class TypeRef;
 class TypeRefBuilder;
 class BuiltinTypeDescriptor;
@@ -158,6 +160,11 @@ class TypeInfo {
     return false;
   }
 
+  // Calculate and return the spare bit mask for this type
+  virtual BitMask getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const {
+    return BitMask::zeroMask(getSize());
+  }
+
   virtual ~TypeInfo() { }
 };
 
@@ -195,6 +202,8 @@ class BuiltinTypeInfo : public TypeInfo {
                                 remote::RemoteAddress address,
                                 int *extraInhabitantIndex) const override;
 
+  BitMask getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const override;
+
   static bool classof(const TypeInfo *TI) {
     return TI->getKind() == TypeInfoKind::Builtin;
   }
@@ -222,6 +231,8 @@ class RecordTypeInfo : public TypeInfo {
                                 remote::RemoteAddress address,
                                 int *index) const override;
 
+  BitMask getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const override;
+
   static bool classof(const TypeInfo *TI) {
     return TI->getKind() == TypeInfoKind::Record;
   }
@@ -330,6 +341,8 @@ class ReferenceTypeInfo : public TypeInfo {
     return reader.readHeapObjectExtraInhabitantIndex(address, extraInhabitantIndex);
   }
 
+  BitMask getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const override;
+
   static bool classof(const TypeInfo *TI) {
     return TI->getKind() == TypeInfoKind::Reference;
   }