ValueEnumerator: make the index type unsigned instead of size_t

This reduces the size of the index from 8 to 4 bytes, which is important in AliasAnalysis where we use pairs of such indices.

Author: eeckstein

include/swift/Basic/ValueEnumerator.h

@@ -18,18 +18,20 @@
 
 namespace swift {
 
+typedef unsigned ValueIndexTy;
+
 /// / This class maps values to unique indices.
-template<class ValueTy, class IndexTy = size_t>
+template<class ValueTy>
 class ValueEnumerator {
   /// A running counter to enumerate values.
-  IndexTy counter = 0;
+  ValueIndexTy counter = 0;
 
   /// Maps values to unique integers.
-  llvm::DenseMap<ValueTy, IndexTy> ValueToIndex;
+  llvm::DenseMap<ValueTy, ValueIndexTy> ValueToIndex;
 
 public:
   /// Return the index of value \p v.
-  IndexTy getIndex(const ValueTy &v) {
+  ValueIndexTy getIndex(const ValueTy &v) {
     // Return the index of this Key, if we've assigned one already.
     auto It = ValueToIndex.find(v);
     if (It != ValueToIndex.end()) {
@@ -38,6 +40,7 @@ class ValueEnumerator {
 
     // Generate a new counter for the key.
     ValueToIndex[v] = ++counter;
+    assert(counter != 0 && "counter overflow in ValueEnumerator");
     return counter;
   }
 

include/swift/SILOptimizer/Analysis/AliasAnalysis.h

@@ -27,26 +27,26 @@ namespace {
   /// A key used for the AliasAnalysis cache.
   ///
   /// This struct represents the argument list to the method 'alias'.  The two
-  /// SILValue pointers are mapped to size_t indices because we need an
+  /// SILValue pointers are mapped to integer indices because we need an
   /// efficient way to invalidate them (the mechanism is described below). The
   /// Type arguments are translated to void* because their underlying storage is
   /// opaque pointers that never goes away.
   struct AliasKeyTy {
     // The SILValue pair:
-    size_t V1, V2;
+    swift::ValueIndexTy V1, V2;
     // The TBAAType pair:
     void *T1, *T2;
   };
 
   /// A key used for the MemoryBehavior Analysis cache.
   ///
-  /// The two SILValue pointers are mapped to size_t indices because we need an
+  /// The two SILValue pointers are mapped to integer indices because we need an
   /// efficient way to invalidate them (the mechanism is described below).  The
   /// RetainObserveKind represents the inspection mode for the memory behavior
   /// analysis.
   struct MemBehaviorKeyTy {
     // The SILValue pair:
-    size_t V1, V2;
+    swift::ValueIndexTy V1, V2;
   };
 }
 
@@ -276,17 +276,17 @@ SILType computeTBAAType(SILValue V);
 namespace llvm {
   template <> struct DenseMapInfo<AliasKeyTy> {
     static inline AliasKeyTy getEmptyKey() {
-      auto Allone = std::numeric_limits<size_t>::max();
+      auto Allone = std::numeric_limits<swift::ValueIndexTy>::max();
       return {0, Allone, nullptr, nullptr};
     }
     static inline AliasKeyTy getTombstoneKey() {
-      auto Allone = std::numeric_limits<size_t>::max();
+      auto Allone = std::numeric_limits<swift::ValueIndexTy>::max();
       return {Allone, 0, nullptr, nullptr};
     }
     static unsigned getHashValue(const AliasKeyTy Val) {
       unsigned H = 0;
-      H ^= DenseMapInfo<size_t>::getHashValue(Val.V1);
-      H ^= DenseMapInfo<size_t>::getHashValue(Val.V2);
+      H ^= DenseMapInfo<swift::ValueIndexTy>::getHashValue(Val.V1);
+      H ^= DenseMapInfo<swift::ValueIndexTy>::getHashValue(Val.V2);
       H ^= DenseMapInfo<void *>::getHashValue(Val.T1);
       H ^= DenseMapInfo<void *>::getHashValue(Val.T2);
       return H;
@@ -301,17 +301,17 @@ namespace llvm {
 
   template <> struct DenseMapInfo<MemBehaviorKeyTy> {
     static inline MemBehaviorKeyTy getEmptyKey() {
-      auto Allone = std::numeric_limits<size_t>::max();
+      auto Allone = std::numeric_limits<swift::ValueIndexTy>::max();
       return {0, Allone};
     }
     static inline MemBehaviorKeyTy getTombstoneKey() {
-      auto Allone = std::numeric_limits<size_t>::max();
+      auto Allone = std::numeric_limits<swift::ValueIndexTy>::max();
       return {Allone, 0};
     }
     static unsigned getHashValue(const MemBehaviorKeyTy V) {
       unsigned H = 0;
-      H ^= DenseMapInfo<size_t>::getHashValue(V.V1);
-      H ^= DenseMapInfo<size_t>::getHashValue(V.V2);
+      H ^= DenseMapInfo<swift::ValueIndexTy>::getHashValue(V.V1);
+      H ^= DenseMapInfo<swift::ValueIndexTy>::getHashValue(V.V2);
       return H;
     }
     static bool isEqual(const MemBehaviorKeyTy LHS,

lib/SILOptimizer/Analysis/AliasAnalysis.cpp

@@ -818,11 +818,11 @@ SILAnalysis *swift::createAliasAnalysis(SILModule *M) {
 
 AliasKeyTy AliasAnalysis::toAliasKey(SILValue V1, SILValue V2,
                                      SILType Type1, SILType Type2) {
-  size_t idx1 = ValueToIndex.getIndex(V1);
-  assert(idx1 != std::numeric_limits<size_t>::max() &&
+  ValueIndexTy idx1 = ValueToIndex.getIndex(V1);
+  assert(idx1 != std::numeric_limits<ValueIndexTy>::max() &&
          "~0 index reserved for empty/tombstone keys");
-  size_t idx2 = ValueToIndex.getIndex(V2);
-  assert(idx2 != std::numeric_limits<size_t>::max() &&
+  ValueIndexTy idx2 = ValueToIndex.getIndex(V2);
+  assert(idx2 != std::numeric_limits<ValueIndexTy>::max() &&
          "~0 index reserved for empty/tombstone keys");
   void *t1 = Type1.getOpaqueValue();
   void *t2 = Type2.getOpaqueValue();

lib/SILOptimizer/Analysis/MemoryBehavior.cpp

@@ -546,11 +546,11 @@ AliasAnalysis::computeMemoryBehaviorInner(SILInstruction *Inst, SILValue V) {
 
 MemBehaviorKeyTy AliasAnalysis::toMemoryBehaviorKey(SILInstruction *V1,
                                                     SILValue V2) {
-  size_t idx1 = InstructionToIndex.getIndex(V1);
-  assert(idx1 != std::numeric_limits<size_t>::max() &&
+  ValueIndexTy idx1 = InstructionToIndex.getIndex(V1);
+  assert(idx1 != std::numeric_limits<ValueIndexTy>::max() &&
          "~0 index reserved for empty/tombstone keys");
-  size_t idx2 = ValueToIndex.getIndex(V2);
-  assert(idx2 != std::numeric_limits<size_t>::max() &&
+  ValueIndexTy idx2 = ValueToIndex.getIndex(V2);
+  assert(idx2 != std::numeric_limits<ValueIndexTy>::max() &&
          "~0 index reserved for empty/tombstone keys");
   return {idx1, idx2};
 }