Minor improvements to MetadataPath for base conformances.

rjmccall · rjmccall · commit 5b4c2cfc1c1e · 2017-03-14T03:21:51.000-04:00
diff --git a/lib/IRGen/Fulfillment.cpp b/lib/IRGen/Fulfillment.cpp
@@ -22,6 +22,7 @@
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/SIL/TypeLowering.h"
 #include "GenericRequirement.h"
+#include "ProtocolInfo.h"
 
 using namespace swift;
 using namespace irgen;
@@ -179,22 +180,20 @@ bool FulfillmentMap::searchWitnessTable(IRGenModule &IGM,
 
   bool hadFulfillment = false;
 
-  auto nextInheritedIndex = 0;
-  for (auto inherited : protocol->getInheritedProtocols()) {
-    auto index = nextInheritedIndex++;
+  auto &pi = IGM.getProtocolInfo(protocol);
 
-    // Ignore protocols that don't have witness tables.
-    if (!Lowering::TypeConverter::protocolRequiresWitnessTable(inherited))
-      continue;
+  for (auto &entry : pi.getWitnessEntries()) {
+    if (!entry.isBase()) continue;
 
+    ProtocolDecl *inherited = entry.getBase();
     MetadataPath inheritedPath = path;
-    inheritedPath.addInheritedProtocolComponent(index);
+    inheritedPath.addInheritedProtocolComponent(pi.getBaseWitnessIndex(&entry));
     hadFulfillment |= searchWitnessTable(IGM, type, inherited,
                                          source, std::move(inheritedPath),
                                          keys, interestingConformances);
   }
 
-  // If we're not limited the set of interesting conformances, or if
+  // If we're not limiting the set of interesting conformances, or if
   // this is an interesting conformance, record it.
   if (!interestingConformances || interestingConformances->count(protocol)) {
     hadFulfillment |= addFulfillment({type, protocol}, source, std::move(path));
diff --git a/lib/IRGen/GenProto.cpp b/lib/IRGen/GenProto.cpp
@@ -2066,11 +2066,14 @@ llvm::Value *MetadataPath::followComponent(IRGenFunction &IGF,
     return source;
   }
 
-  case Component::Kind::InheritedProtocol: {
+  case Component::Kind::OutOfLineBaseProtocol: {
     auto conformance = sourceKey.Kind.getProtocolConformance();
     auto protocol = conformance.getRequirement();
-    auto inheritedProtocol =
-      protocol->getInheritedProtocols()[component.getPrimaryIndex()];
+    auto &pi = IGF.IGM.getProtocolInfo(protocol);
+
+    auto &entry = pi.getWitnessEntries()[component.getPrimaryIndex()];
+    assert(entry.isOutOfLineBase());
+    auto inheritedProtocol = entry.getBase();
 
     sourceKey.Kind =
       LocalTypeDataKind::forAbstractProtocolWitnessTable(inheritedProtocol);
@@ -2084,14 +2087,11 @@ llvm::Value *MetadataPath::followComponent(IRGenFunction &IGF,
     }
 
     if (source) {
-      auto &pi = IGF.IGM.getProtocolInfo(protocol);
-      auto index = pi.getBaseIndex(inheritedProtocol);
-      if (!index.isPrefix()) {
-        source = emitInvariantLoadOfOpaqueWitness(IGF, source, index);
-        source = IGF.Builder.CreateBitCast(source, IGF.IGM.WitnessTablePtrTy);
-        setProtocolWitnessTableName(IGF.IGM, source, sourceKey.Type,
-                                    inheritedProtocol);
-      }
+      WitnessIndex index(component.getPrimaryIndex(), /*prefix*/ false);
+      source = emitInvariantLoadOfOpaqueWitness(IGF, source, index);
+      source = IGF.Builder.CreateBitCast(source, IGF.IGM.WitnessTablePtrTy);
+      setProtocolWitnessTableName(IGF.IGM, source, sourceKey.Type,
+                                  inheritedProtocol);
     }
     return source;
   }
@@ -2113,8 +2113,8 @@ void MetadataPath::print(llvm::raw_ostream &out) const {
     if (i != Path.begin()) out << ".";
     auto component = *i;
     switch (component.getKind()) {
-    case Component::Kind::InheritedProtocol:
-      out << "inherited_protocol[" << component.getPrimaryIndex() << "]";
+    case Component::Kind::OutOfLineBaseProtocol:
+      out << "out_of_line_base_protocol[" << component.getPrimaryIndex() << "]";
       break;
     case Component::Kind::NominalTypeArgument:
       out << "nominal_type_argument[" << component.getPrimaryIndex() << "]";
diff --git a/lib/IRGen/MetadataPath.h b/lib/IRGen/MetadataPath.h
@@ -20,6 +20,7 @@
 
 #include "swift/Basic/EncodedSequence.h"
 #include "swift/Reflection/MetadataSource.h"
+#include "WitnessIndex.h"
 #include "IRGen.h"
 
 namespace llvm {
@@ -45,8 +46,8 @@ class MetadataPath {
       // Some components carry indices.
       // P means the primary index.
 
-      /// Base protocol P of a protocol.
-      InheritedProtocol,
+      /// Base protocol of a protocol.  P is the WitnessIndex.
+      OutOfLineBaseProtocol,
 
       /// Witness table at requirement index P of a generic nominal type.
       NominalTypeArgumentConformance,
@@ -95,7 +96,7 @@ class MetadataPath {
     /// Return an abstract measurement of the cost of this component.
     OperationCost cost() const {
       switch (getKind()) {
-      case Kind::InheritedProtocol:
+      case Kind::OutOfLineBaseProtocol:
       case Kind::NominalTypeArgumentConformance:
       case Kind::NominalTypeArgument:
       case Kind::NominalParent:
@@ -155,12 +156,12 @@ class MetadataPath {
                              index));
   }
 
-  /// Add a step to this path which gets the kth inherited protocol from a
-  /// witness table.
-  ///
-  /// k is computed including protocols which do not have witness tables.
-  void addInheritedProtocolComponent(unsigned index) {
-    Path.push_back(Component(Component::Kind::InheritedProtocol, index));
+  /// Add a step to this path which gets the inherited protocol at
+  /// a particular witness index.
+  void addInheritedProtocolComponent(WitnessIndex index) {
+    assert(!index.isPrefix());
+    Path.push_back(Component(Component::Kind::OutOfLineBaseProtocol,
+                             index.getValue()));
   }
 
   /// Return an abstract measurement of the cost of this path.
diff --git a/lib/IRGen/ProtocolInfo.h b/lib/IRGen/ProtocolInfo.h
@@ -21,6 +21,7 @@
 #include "swift/AST/Decl.h"
 
 #include "ValueWitness.h"
+#include "WitnessIndex.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -36,21 +37,6 @@ namespace irgen {
   class IRGenModule;
   class TypeInfo;
 
-/// A class which encapsulates an index into a witness table.
-class WitnessIndex {
-  unsigned Value : 31;
-  unsigned IsPrefix : 1;
-public:
-  WitnessIndex() = default;
-  WitnessIndex(ValueWitness index) : Value(unsigned(index)) {}
-  explicit WitnessIndex(unsigned index, bool isPrefix)
-    : Value(index), IsPrefix(isPrefix) {}
-
-  unsigned getValue() const { return Value; }
-
-  bool isPrefix() const { return IsPrefix; }
-};
-
 /// A witness to a specific element of a protocol.  Every
 /// ProtocolTypeInfo stores one of these for each requirement
 /// introduced by the protocol.
@@ -195,48 +181,74 @@ class ProtocolInfo final :
     return NumTableEntries;
   }
 
+  /// Return all of the entries in this protocol witness table.
+  ///
+  /// The addresses of the entries in this array can be passed to
+  /// getBaseWitnessIndex/getNonBaseWitnessIndex, below.
   ArrayRef<WitnessTableEntry> getWitnessEntries() const {
     return {getTrailingObjects<WitnessTableEntry>(), NumTableEntries};
   }
 
-  WitnessIndex getBaseIndex(ProtocolDecl *protocol) const {
+  /// Given the address of a witness entry from this PI for a base protocol
+  /// conformance, return its witness index.
+  WitnessIndex getBaseWitnessIndex(const WitnessTableEntry *witness) const {
+    assert(witness && witness->isBase());
+    auto entries = getWitnessEntries();
+    assert(entries.begin() <= witness && witness < entries.end() &&
+           "argument witness entry does not belong to this ProtocolInfo");
+    if (witness->isOutOfLineBase()) {
+      return WitnessIndex(witness - entries.begin(), false);
+    } else {
+      return WitnessIndex(0, true);
+    }
+  }
+
+  /// Given the address of a witness entry from this PI for a non-base
+  /// witness, return its witness index.
+  WitnessIndex getNonBaseWitnessIndex(const WitnessTableEntry *witness) const {
+    assert(witness && !witness->isBase());
     auto entries = getWitnessEntries();
-    for (auto &witness : entries) {
-      if (witness.matchesBase(protocol)) {
-        if (witness.isOutOfLineBase()) {
-          return WitnessIndex(&witness - entries.begin(), false);
-        } else {
-          return WitnessIndex(0, true);
-        }
-      }
+    assert(entries.begin() <= witness && witness < entries.end());
+    return WitnessIndex(witness - entries.begin(), false);
+  }
+
+  /// Return the witness index for the protocol conformance pointer
+  /// for the given base protocol requirement.
+  WitnessIndex getBaseIndex(ProtocolDecl *protocol) const {
+    for (auto &witness : getWitnessEntries()) {
+      if (witness.matchesBase(protocol))
+        return getBaseWitnessIndex(&witness);
     }
     llvm_unreachable("didn't find entry for base");
   }
 
+  /// Return the witness index for the witness function for the given
+  /// function requirement.
   WitnessIndex getFunctionIndex(AbstractFunctionDecl *function) const {
-    auto entries = getWitnessEntries();
-    for (auto &witness : entries) {
+    for (auto &witness : getWitnessEntries()) {
       if (witness.matchesFunction(function))
-        return WitnessIndex(&witness - entries.begin(), false);
+        return getNonBaseWitnessIndex(&witness);
     }
     llvm_unreachable("didn't find entry for function");
   }
 
+  /// Return the witness index for the type metadata access function
+  /// for the given associated type.
   WitnessIndex getAssociatedTypeIndex(AssociatedTypeDecl *assocType) const {
-    auto entries = getWitnessEntries();
-    for (auto &witness : entries) {
+    for (auto &witness : getWitnessEntries()) {
       if (witness.matchesAssociatedType(assocType))
-        return WitnessIndex(&witness - entries.begin(), false);
+        return getNonBaseWitnessIndex(&witness);
     }
     llvm_unreachable("didn't find entry for associated type");
   }
 
+  /// Return the witness index for the protocol witness table access
+  /// function for the given associated protocol conformance.
   WitnessIndex getAssociatedConformanceIndex(CanType path,
                                              ProtocolDecl *requirement) const {
-    auto entries = getWitnessEntries();
-    for (auto &witness : entries) {
+    for (auto &witness : getWitnessEntries()) {
       if (witness.matchesAssociatedConformance(path, requirement))
-        return WitnessIndex(&witness - entries.begin(), false);
+        return getNonBaseWitnessIndex(&witness);
     }
     llvm_unreachable("didn't find entry for associated conformance");
   }
diff --git a/lib/IRGen/WitnessIndex.h b/lib/IRGen/WitnessIndex.h
@@ -0,0 +1,44 @@
+//===--- WitnessIndex.h - Index into a witness table ------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the WitnessIndex type, used for drilling into a
+// protocol witness table or value witness table.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_IRGEN_WITNESSINDEX_H
+#define SWIFT_IRGEN_WITNESSINDEX_H
+
+#include "ValueWitness.h"
+
+namespace swift {
+namespace irgen {
+
+/// A class which encapsulates an index into a witness table.
+class WitnessIndex {
+  unsigned Value : 31;
+  unsigned IsPrefix : 1;
+public:
+  WitnessIndex() = default;
+  WitnessIndex(ValueWitness index) : Value(unsigned(index)) {}
+  explicit WitnessIndex(unsigned index, bool isPrefix)
+    : Value(index), IsPrefix(isPrefix) {}
+
+  unsigned getValue() const { return Value; }
+
+  bool isPrefix() const { return IsPrefix; }
+};
+
+} // end namespace irgen
+} // end namespace swift
+
+#endif
