Give operation costs a proper type instead of using unsigned. NFC.

Author: rjmccall

lib/IRGen/IRGen.h

@@ -268,6 +268,27 @@ class ConstantInit {
   }
 };
 
+/// An abstraction for computing the cost of an operation.
+enum class OperationCost : unsigned {
+  Free = 0,
+  Arithmetic = 1,
+  Load = 3, // TODO: split into static- and dynamic-offset cases?
+  Call = 10
+};
+inline OperationCost operator+(OperationCost l, OperationCost r) {
+  return OperationCost(unsigned(l) + unsigned(r));
+}
+inline OperationCost &operator+=(OperationCost &l, OperationCost r) {
+  l = l + r;
+  return l;
+}
+inline bool operator<(OperationCost l, OperationCost r) {
+  return unsigned(l) < unsigned(r);
+}
+inline bool operator<=(OperationCost l, OperationCost r) {
+  return unsigned(l) <= unsigned(r);
+}
+
 /// An alignment value, in eight-bit units.
 class Alignment {
 public:

lib/IRGen/LocalTypeData.cpp

@@ -54,7 +54,7 @@ void IRGenFunction::destroyLocalTypeData() {
   delete LocalTypeData;
 }
 
-unsigned LocalTypeDataCache::CacheEntry::cost() const {
+OperationCost LocalTypeDataCache::CacheEntry::cost() const {
   switch (getKind()) {
   case Kind::Concrete:
     return static_cast<const ConcreteCacheEntry*>(this)->cost();
@@ -99,7 +99,7 @@ llvm::Value *LocalTypeDataCache::tryGet(IRGenFunction &IGF, Key key,
   auto &chain = it->second;
 
   CacheEntry *best = nullptr;
-  Optional<unsigned> bestCost;
+  Optional<OperationCost> bestCost;
 
   CacheEntry *next = chain.Root;
   while (next) {
@@ -120,7 +120,7 @@ llvm::Value *LocalTypeDataCache::tryGet(IRGenFunction &IGF, Key key,
       // If that's zero, go ahead and short-circuit out.
       if (!bestCost) {
         bestCost = best->cost();
-        if (*bestCost == 0) break;
+        if (*bestCost == OperationCost::Free) break;
       }
 
       auto curCost = cur->cost();
@@ -317,8 +317,8 @@ addAbstractForFulfillments(IRGenFunction &IGF, FulfillmentMap &&fulfillments,
 
     // Check whether there's already an entry that's at least as good as the
     // fulfillment.
-    Optional<unsigned> fulfillmentCost;
-    auto getFulfillmentCost = [&]() -> unsigned {
+    Optional<OperationCost> fulfillmentCost;
+    auto getFulfillmentCost = [&]() -> OperationCost {
       if (!fulfillmentCost)
         fulfillmentCost = fulfillment.second.Path.cost();
       return *fulfillmentCost;
@@ -335,7 +335,7 @@ addAbstractForFulfillments(IRGenFunction &IGF, FulfillmentMap &&fulfillments,
 
       // Ensure that the entry isn't better than the fulfillment.
       auto curCost = cur->cost();
-      if (curCost == 0 || curCost <= getFulfillmentCost()) {
+      if (curCost == OperationCost::Free || curCost <= getFulfillmentCost()) {
         foundBetter = true;
         break;
       }

lib/IRGen/LocalTypeData.h

@@ -79,7 +79,7 @@ class LocalTypeDataCache {
     void setNext(CacheEntry *next) { NextAndFlags.setPointer(next); }
 
     /// Return the abstract cost of evaluating this cache entry.
-    unsigned cost() const;
+    OperationCost cost() const;
 
     /// Destruct and deallocate this cache entry.
     void erase() const;
@@ -105,7 +105,7 @@ class LocalTypeDataCache {
                        llvm::Value *value)
       : CacheEntry(Kind::Concrete, point, isConditional), Value(value) {}
 
-    unsigned cost() const { return 0; }
+    OperationCost cost() const { return OperationCost::Free; }
   };
 
   /// A source of concrete data from which abstract cache entries can be
@@ -159,7 +159,7 @@ class LocalTypeDataCache {
 
     llvm::Value *follow(IRGenFunction &IGF, AbstractSource &source) const;
 
-    unsigned cost() const { return Path.cost(); }
+    OperationCost cost() const { return Path.cost(); }
   };
 
   /// The linked list of cache entries corresponding to a particular key.

lib/IRGen/MetadataPath.h

@@ -20,6 +20,7 @@
 
 #include "swift/Basic/EncodedSequence.h"
 #include "swift/Reflection/MetadataSource.h"
+#include "IRGen.h"
 
 namespace llvm {
   class Value;
@@ -34,6 +35,7 @@ namespace irgen {
   class IRGenFunction;
   class LocalTypeDataKey;
 
+
 /// A path from one source metadata --- either Swift type metadata or a Swift
 /// protocol conformance --- to another.
 class MetadataPath {
@@ -91,12 +93,18 @@ class MetadataPath {
     }
 
     /// Return an abstract measurement of the cost of this component.
-    unsigned cost() const {
-      // Right now, all components cost the same: they take one load.
-      // In the future, maybe some components will be cheaper (no loads,
-      // like loading from a superclass's metadata) or more expensive
-      // (multiple loads, or even a call).
-      return 1;
+    OperationCost cost() const {
+      switch (getKind()) {
+      case Kind::InheritedProtocol:
+      case Kind::NominalTypeArgumentConformance:
+      case Kind::NominalTypeArgument:
+      case Kind::NominalParent:
+        return OperationCost::Load;
+
+      case Kind::Impossible:
+        llvm_unreachable("cannot compute cost of an imposible path");
+      }
+      llvm_unreachable("bad path component");
     }
 
     static Component decode(const EncodedSequenceBase::Chunk *&ptr) {
@@ -156,8 +164,8 @@ class MetadataPath {
   }
 
   /// Return an abstract measurement of the cost of this path.
-  unsigned cost() const {
-    unsigned cost = 0;
+  OperationCost cost() const {
+    auto cost = OperationCost::Free;
     for (const Component &component : Path)
       cost += component.cost();
     return cost;