[sil] Instead of returning an ArrayRef<SILValue> for SILInstruction::getResults(), use SILInstructionResultArray.

gottesmm · gottesmm · commit 267d63e085fa · 2017-10-12T18:30:05.000-07:00
The reason that I am doing this is in preparation for adding support for
MultipleValueInstruction. This enables us to avoid type issues and also ensures
that we do not increase the size of SingleValueInstruction while we are doing
it.

The MultipleValueInstruction commit will come soon.

rdar://31521023
diff --git a/include/swift/SIL/SILInstruction.h b/include/swift/SIL/SILInstruction.h
@@ -44,6 +44,7 @@ class DeclRefExpr;
 class FloatLiteralExpr;
 class FuncDecl;
 class IntegerLiteralExpr;
+class NonValueInstruction;
 class SILBasicBlock;
 class SILBuilder;
 class SILDebugLocation;
@@ -87,6 +88,114 @@ SILInstructionKind getSILInstructionKind(StringRef InstName);
 /// Map SILInstructionKind to a corresponding SILInstruction name.
 StringRef getSILInstructionName(SILInstructionKind Kind);
 
+/// A formal SIL reference to a list of values, suitable for use as the result
+/// of a SILInstruction.
+///
+/// *NOTE* Most multiple value instructions will not have many results, so if we
+/// want we can cache up to 3 bytes in the lower bits of the value.
+///
+/// *NOTE* Most of this defined out of line further down in the file to work
+/// around forward declaration issues.
+class SILInstructionResultArray {
+  const uint8_t *Pointer;
+  unsigned Size;
+
+public:
+  SILInstructionResultArray() : Pointer(nullptr), Size(0) {}
+  SILInstructionResultArray(const SingleValueInstruction *SVI);
+
+  SILInstructionResultArray(const SILInstructionResultArray &Other) = default;
+  SILInstructionResultArray &
+  operator=(const SILInstructionResultArray &Other) = default;
+  SILInstructionResultArray(SILInstructionResultArray &&Other) = default;
+  SILInstructionResultArray &
+  operator=(SILInstructionResultArray &&Other) = default;
+
+  SILValue operator[](size_t Index) const;
+
+  bool empty() const { return Size == 0; }
+
+  size_t size() const { return Size; }
+
+  class iterator;
+
+  iterator begin() const;
+  iterator end() const;
+
+  using range = llvm::iterator_range<iterator>;
+  range getValues() const;
+
+  using type_range = llvm::iterator_range<
+      llvm::mapped_iterator<iterator, std::function<SILType(SILValue)>>>;
+  type_range getTypes() const;
+
+  bool operator==(const SILInstructionResultArray &rhs);
+  bool operator!=(const SILInstructionResultArray &other) {
+    return !(*this == other);
+  }
+
+  /// Returns true if both this and \p rhs have the same result types.
+  ///
+  /// *NOTE* This does not imply that the actual return SILValues are the
+  /// same. Just that the types are the same.
+  bool hasSameTypes(const SILInstructionResultArray &rhs);
+
+private:
+  /// Return the offset 1 past the end of the array or None if we are not
+  /// actually storing anything.
+  Optional<unsigned> getStartOffset() const {
+    return empty() ? None : Optional<unsigned>(0);
+  }
+
+  /// Return the offset 1 past the end of the array or None if we are not
+  /// actually storing anything.
+  Optional<unsigned> getEndOffset() const {
+    return empty() ? None : Optional<unsigned>(size());
+  }
+};
+
+class SILInstructionResultArray::iterator
+    : public std::iterator<std::bidirectional_iterator_tag, SILValue,
+                           ptrdiff_t> {
+  /// Our "parent" array.
+  ///
+  /// This is actually a value type reference into a SILInstruction of some
+  /// sort. So we can just have our own copy. This also allows us to not worry
+  /// about our underlying array having too short of a lifetime.
+  SILInstructionResultArray Parent;
+
+  /// The index into the parent array.
+  Optional<unsigned> Index;
+
+public:
+  iterator() = default;
+  iterator(const SILInstructionResultArray &Parent,
+           Optional<unsigned> Index = 0)
+      : Parent(Parent), Index(Index) {}
+
+  SILValue operator*() const { return Parent[Index.getValue()]; }
+
+  SILValue operator->() const { return operator*(); }
+
+  iterator &operator++() {
+    ++Index.getValue();
+    return *this;
+  }
+
+  iterator operator++(int) {
+    iterator copy = *this;
+    ++Index.getValue();
+    return copy;
+  }
+
+  friend bool operator==(iterator lhs, iterator rhs) {
+    assert(lhs.Parent.Pointer == rhs.Parent.Pointer);
+    return lhs.Index == rhs.Index;
+  }
+
+  friend bool operator!=(iterator lhs, iterator rhs) { return !(lhs == rhs); }
+};
+
 /// This is the root class for all instructions that can be used as the
 /// contents of a Swift SILBasicBlock.
 ///
@@ -143,7 +252,7 @@ class SILInstruction
 
   /// An internal method which retrieves the result values of the
   /// instruction as an array of ValueBase objects.
-  ArrayRef<ValueBase> getResultsImpl() const;
+  SILInstructionResultArray getResultsImpl() const;
 
 protected:
   SILInstruction(SILInstructionKind kind, SILDebugLocation DebugLoc)
@@ -318,18 +427,13 @@ class SILInstruction
     getAllOperands()[Num1].swap(getAllOperands()[Num2]);
   }
 
-  using ResultArrayRef =
-    ArrayRefView<ValueBase,SILValue,projectValueBaseAsSILValue>;
-
   /// Return the list of results produced by this instruction.
-  ResultArrayRef getResults() const { return getResultsImpl(); }
-
-  using ResultTypeArrayRef =
-    ArrayRefView<ValueBase,SILType,projectValueBaseType>;
+  SILInstructionResultArray getResults() const { return getResultsImpl(); }
+  unsigned getNumResults() const { return getResults().size(); }
 
   /// Return the types of the results produced by this instruction.
-  ResultTypeArrayRef getResultTypes() const {
-    return getResultsImpl();
+  SILInstructionResultArray::type_range getResultTypes() const {
+    return getResultsImpl().getTypes();
   }
 
   MemoryBehavior getMemoryBehavior() const;
@@ -364,9 +468,9 @@ class SILInstruction
       return false;
     }
 
-    if (getResultTypes() != RHS->getResultTypes())
+    if (!getResults().hasSameTypes(RHS->getResults()))
       return false;
-    
+
     // Check operands.
     for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
       if (!opEqual(getOperand(i), RHS->getOperand(i)))
@@ -504,8 +608,8 @@ class SingleValueInstruction : public SILInstruction, public ValueBase {
   }
 
   friend class SILInstruction;
-  ArrayRef<ValueBase> getResultsImpl() const {
-    return ArrayRef<ValueBase>(this, 1);
+  SILInstructionResultArray getResultsImpl() const {
+    return SILInstructionResultArray(this);
   }
 public:
   SingleValueInstruction(SILInstructionKind kind, SILDebugLocation loc,
@@ -547,9 +651,7 @@ class SingleValueInstruction : public SILInstruction, public ValueBase {
   }
 
   /// Override this to reflect the more efficient access pattern.
-  ResultArrayRef getResults() const {
-    return getResultsImpl();
-  }
+  SILInstructionResultArray getResults() const { return getResultsImpl(); }
 
   static bool classof(const SILNode *node) {
     return isSingleValueInstKind(node->getKind());
@@ -599,7 +701,14 @@ class NonValueInstruction : public SILInstruction {
 
   /// Doesn't produce any results.
   SILType getType() const = delete;
-  ResultArrayRef getResults() const = delete;
+  SILInstructionResultArray getResults() const = delete;
+
+  static bool classof(const ValueBase *value) = delete;
+  static bool classof(const SILNode *N) {
+    return N->getKind() >= SILNodeKind::First_NonValueInstruction &&
+           N->getKind() <= SILNodeKind::Last_NonValueInstruction;
+  }
+  static bool classof(const NonValueInstruction *) { return true; }
 };
 #define DEFINE_ABSTRACT_NON_VALUE_INST_BOILERPLATE(ID)          \
   static bool classof(const ValueBase *value) = delete;         \
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
@@ -613,6 +613,8 @@ NON_VALUE_INST(AllocGlobalInst, alloc_global,
 NON_VALUE_INST(CondFailInst, cond_fail,
                SILInstruction, MayHaveSideEffects, DoesNotRelease)
 
+NODE_RANGE(NonValueInstruction, UnreachableInst, CondFailInst)
+
 NODE_RANGE(SILInstruction, AllocStackInst, CondFailInst)
 NODE_RANGE(SILNode, SILPHIArgument, CondFailInst)
 
diff --git a/lib/SIL/SILInstruction.cpp b/lib/SIL/SILInstruction.cpp
@@ -172,19 +172,20 @@ void SILInstruction::dropAllReferences() {
   }
 }
 
-ArrayRef<ValueBase> SILInstruction::getResultsImpl() const {
+SILInstructionResultArray SILInstruction::getResultsImpl() const {
   switch (getKind()) {
 #define NON_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
   case SILInstructionKind::ID:
 #include "swift/SIL/SILNodes.def"
-    return {};
+    return SILInstructionResultArray();
 
 #define SINGLE_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
   case SILInstructionKind::ID:
 #include "swift/SIL/SILNodes.def"
-    return static_cast<const SingleValueInstruction *>(this)->getResultsImpl();
+    return SILInstructionResultArray(
+        static_cast<const SingleValueInstruction *>(this));
 
-  // add any multi-result instructions here...
+    // add any multi-result instructions here...
   }
   llvm_unreachable("bad kind");
 }
@@ -1174,3 +1175,101 @@ llvm::raw_ostream &swift::operator<<(llvm::raw_ostream &OS,
 
   llvm_unreachable("Unhandled ReleasingBehavior in switch.");
 }
+
+//===----------------------------------------------------------------------===//
+//                         SILInstructionResultArray
+//===----------------------------------------------------------------------===//
+
+SILInstructionResultArray::SILInstructionResultArray(
+    const SingleValueInstruction *SVI)
+    : Pointer(), Size(1) {
+  // Make sure that even though we are munging things, we are able to get back
+  // the original value, types, and operands.
+  SILValue originalValue(SVI);
+  SILType originalType = SVI->getType();
+  (void)originalValue;
+  (void)originalType;
+
+  // *PLEASE READ BEFORE CHANGING*
+  //
+  // Since SingleValueInstruction is both a ValueBase and a SILInstruction, but
+  // SILInstruction is the first parent, we need to ensure that our ValueBase *
+  // pointer is properly offset. by first static casting to ValueBase and then
+  // going back to a uint8_t *.
+  auto *Value = static_cast<const ValueBase *>(SVI);
+  assert(uintptr_t(Value) != uintptr_t(SVI) &&
+         "Expected value to be offset from SVI since it is not the first "
+         "multi-inheritence parent");
+  Pointer = reinterpret_cast<const uint8_t *>(Value);
+
+  assert(originalValue == (*this)[0] &&
+         "Wrong value returned for single result");
+  assert(originalType == (*this)[0]->getType());
+
+  auto ValueRange = getValues();
+  (void)ValueRange;
+  assert(1 == std::distance(ValueRange.begin(), ValueRange.end()));
+  assert(originalValue == *ValueRange.begin());
+
+  auto TypedRange = getTypes();
+  (void)TypedRange;
+  assert(1 == std::distance(TypedRange.begin(), TypedRange.end()));
+  assert(originalType == *TypedRange.begin());
+
+  SILInstructionResultArray Copy = *this;
+  (void)Copy;
+  assert(Copy.hasSameTypes(*this));
+  assert(Copy == *this);
+}
+
+SILValue SILInstructionResultArray::operator[](size_t Index) const {
+  assert(Index < Size && "Index out of bounds");
+  // Today we only have single instruction results so offset will always be
+  // zero. Once we have multiple instruction results, this will be equal to
+  // sizeof(MultipleValueInstructionResult)*Index. This is safe even to do with
+  // SingleValueInstruction since index will always be zero for the offset.
+  size_t Offset = 0;
+  return SILValue(reinterpret_cast<const ValueBase *>(&Pointer[Offset]));
+}
+
+bool SILInstructionResultArray::hasSameTypes(
+    const SILInstructionResultArray &rhs) {
+  auto &lhs = *this;
+  if (lhs.size() != rhs.size())
+    return false;
+  for (unsigned i : indices(lhs)) {
+    if (lhs[i]->getType() != rhs[i]->getType())
+      return false;
+  }
+  return true;
+}
+
+bool SILInstructionResultArray::
+operator==(const SILInstructionResultArray &other) {
+  if (size() != other.size())
+    return false;
+  for (auto i : indices(*this))
+    if ((*this)[i] != other[i])
+      return false;
+  return true;
+}
+
+SILInstructionResultArray::type_range
+SILInstructionResultArray::getTypes() const {
+  std::function<SILType(SILValue)> F = [](SILValue V) -> SILType {
+    return V->getType();
+  };
+  return {llvm::map_iterator(begin(), F), llvm::map_iterator(end(), F)};
+}
+
+SILInstructionResultArray::iterator SILInstructionResultArray::begin() const {
+  return iterator(*this, getStartOffset());
+}
+
+SILInstructionResultArray::iterator SILInstructionResultArray::end() const {
+  return iterator(*this, getEndOffset());
+}
+
+SILInstructionResultArray::range SILInstructionResultArray::getValues() const {
+  return {begin(), end()};
+}
diff --git a/lib/SIL/SILPrinter.cpp b/lib/SIL/SILPrinter.cpp
@@ -660,13 +660,13 @@ class SILPrinter : public SILInstructionVisitor<SILPrinter> {
   /// Print out the users of the SILValue \p V. Return true if we printed out
   /// either an id or a use list. Return false otherwise.
   bool printUsersOfSILNode(const SILNode *node, bool printedSlashes) {
-    SILInstruction::ResultArrayRef values;
+    TinyPtrVector<SILValue> values;
     if (auto value = dyn_cast<ValueBase>(node)) {
       // The base pointer of the ultimate ArrayRef here is just the
       // ValueBase; we aren't forming a reference to a temporary array.
-      values = ArrayRef<ValueBase>(value, 1);
-    } else if (auto inst = dyn_cast<SILInstruction>(node)) {
-      values = inst->getResults();
+      values.push_back(value);
+    } else if (auto *inst = dyn_cast<SILInstruction>(node)) {
+      copy(inst->getResults(), std::back_inserter(values));
     }
 
     // If the set of values is empty, we need to print the ID of
