[sil] Add support for multiple value instructions by adding MultipleValueInstruction{,Result}.

rdar://31521023

Author: gottesmm

include/swift/SIL/SILInstruction.h

@@ -44,16 +44,20 @@ class DeclRefExpr;
 class FloatLiteralExpr;
 class FuncDecl;
 class IntegerLiteralExpr;
+class SingleValueInstruction;
+class MultipleValueInstruction;
 class NonValueInstruction;
 class SILBasicBlock;
 class SILBuilder;
 class SILDebugLocation;
 class SILDebugScope;
 class SILFunction;
 class SILGlobalVariable;
+class SILInstructionResultArray;
 class SILOpenedArchetypesState;
 class SILType;
 class SILArgument;
+class SILUndef;
 class Stmt;
 class StringLiteralExpr;
 class Substitution;
@@ -103,6 +107,7 @@ class SILInstructionResultArray {
 public:
   SILInstructionResultArray() : Pointer(nullptr), Size(0) {}
   SILInstructionResultArray(const SingleValueInstruction *SVI);
+  SILInstructionResultArray(const MultipleValueInstruction *MVI);
 
   SILInstructionResultArray(const SILInstructionResultArray &Other)
       : Pointer(Other.Pointer), Size(Other.Size) {}
@@ -704,6 +709,122 @@ inline SingleValueInstruction *SILNode::castToSingleValueInstruction() {
            inst->getKind() <= SILInstructionKind::Last_##ID;    \
   }
 
+/// A value base result of a multiple value instruction.
+class MultipleValueInstructionResult : public ValueBase {
+  /// The parent instruction that this MultipleValueInstructionResult is
+  /// contained within.
+  MultipleValueInstruction *Parent;
+
+  /// The ownership kind assigned to this result by its parent.
+  ///
+  /// We store this rather than delegating to our parent since there is not a
+  /// natural clear way to derive the ValueOwnershipKind for all potential
+  /// multiple value instructions. This contrasts with the index of our result
+  /// in the parent array.
+  ValueOwnershipKind Kind;
+
+public:
+  MultipleValueInstructionResult(MultipleValueInstruction *parent, SILType type,
+                                 ValueOwnershipKind kind)
+      : ValueBase(ValueKind::MultipleValueInstructionResult, type),
+        Parent(parent), Kind(kind) {}
+
+  MultipleValueInstruction *getParent() const { return Parent; }
+
+  unsigned getIndex() const;
+
+  ValueOwnershipKind getOwnershipKind() const { return Kind; }
+
+  SILNode *getCanonicalSILNodeInObject();
+  const SILNode *getCanonicalSILNodeInObject() const;
+
+  static bool classof(const SILInstruction *) = delete;
+  static bool classof(const SILUndef *) = delete;
+  static bool classof(const SILNode *node) {
+    return node->getKind() == SILNodeKind::MultipleValueInstructionResult;
+  }
+};
+
+/// An instruction which always produces a fixed list of values.
+class MultipleValueInstruction : public SILInstruction {
+  // *NOTE* THis is just a stub since we do not currently have any multiple
+  // value instructions.
+  static bool isMultipleValueInstKind(SILNodeKind kind) { return false; }
+
+  friend class SILInstruction;
+  friend class SILInstructionResultArray;
+
+  /// An ArrayRef of Result objects. We assume that our child classes's will
+  /// allocate this for us on memory that will be placement newed.
+  ArrayRef<MultipleValueInstructionResult> Results;
+
+  SILInstructionResultArray getResultsImpl() const {
+    return SILInstructionResultArray(this);
+  }
+
+protected:
+  MultipleValueInstruction(
+      SILInstructionKind kind, SILDebugLocation loc,
+      ArrayRef<MultipleValueInstructionResult> results = {})
+      : SILInstruction(kind, loc), Results(results) {}
+
+  // Sometimes our subclasses need to set the new results /after/ we construct
+  // the MultipleValueInstruction.
+  void setResults(ArrayRef<MultipleValueInstructionResult> NewResults) {
+    Results = NewResults;
+  }
+
+public:
+  // Redeclare because lldb currently doesn't know about using-declarations
+  void dump() const;
+
+  void operator delete(void *Ptr, size_t)SWIFT_DELETE_OPERATOR_DELETED;
+
+  SILInstructionResultArray getValueKinds() const { return getResultsImpl(); }
+
+  SILNode *getCanonicalSILNodeInObject() {
+    assert(SILInstruction::isCanonicalSILNodeInObject() &&
+           "the SILInstruction subobject is always canonical");
+    return static_cast<SILInstruction *>(this);
+  }
+  const SILNode *getCanonicalSILNodeInObject() const {
+    assert(SILInstruction::isCanonicalSILNodeInObject() &&
+           "the SILInstruction subobject is always canonical");
+    return static_cast<const SILInstruction *>(this);
+  }
+
+  MultipleValueInstruction *clone(SILInstruction *insertPt = nullptr) {
+    return cast<MultipleValueInstruction>(SILInstruction::clone(insertPt));
+  }
+
+  /// Override this to reflect the more efficient access pattern.
+  SILInstructionResultArray getResults() const {
+    return SILInstructionResultArray(this);
+  }
+
+  SILValue getResult(unsigned Index) const { return getResults()[Index]; }
+
+  unsigned getIndexOfResult(const MultipleValueInstructionResult *R) const {
+    assert(((&Results.front() <= R) && (&Results.back() >= R)) &&
+           "Passed in result is not a result of this MultipleValueInstruction");
+    uintptr_t bytes = uintptr_t(R) - uintptr_t(&Results.front());
+    return unsigned(bytes) / sizeof(MultipleValueInstructionResult);
+  }
+
+  unsigned getNumResults() const { return getResults().size(); }
+
+  static bool classof(const SILNode *node) {
+    return isMultipleValueInstKind(node->getKind());
+  }
+};
+
+// Resolve ambiguities.
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
+                                     const MultipleValueInstruction &I) {
+  I.print(OS);
+  return OS;
+}
+
 /// A subclass of SILInstruction which does not produce any values.
 class NonValueInstruction : public SILInstruction {
 public:
@@ -7058,6 +7179,19 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
   }
 }
 
+inline SILNode *MultipleValueInstructionResult::getCanonicalSILNodeInObject() {
+  return Parent->getCanonicalSILNodeInObject();
+}
+
+inline const SILNode *
+MultipleValueInstructionResult::getCanonicalSILNodeInObject() const {
+  return Parent->getCanonicalSILNodeInObject();
+}
+
+inline unsigned MultipleValueInstructionResult::getIndex() const {
+  return Parent->getIndexOfResult(this);
+}
+
 } // end swift namespace
 
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILNode.h

@@ -32,7 +32,7 @@ class SingleValueInstruction;
 class ValueBase;
 
 /// An enumeration which contains values for all the nodes in SILNodes.def.
-/// Other enumerators, like ValueKind and SILInstructionind, ultimately
+/// Other enumerators, like ValueKind and SILInstructionKind, ultimately
 /// take their values from this enumerator.
 enum class SILNodeKind {
 #define NODE(ID, PARENT) \
@@ -113,15 +113,20 @@ class alignas(8) SILNode {
 
 protected:
   SILNode(SILNodeKind kind, SILNodeStorageLocation storageLoc)
-    : Kind(unsigned(kind)),
-      StorageLoc(unsigned(storageLoc)),
-      IsCanonical(storageLoc == SILNodeStorageLocation::Instruction ||
-                  !hasMultipleSILNodes(kind)) {}
+      : Kind(unsigned(kind)), StorageLoc(unsigned(storageLoc)),
+        IsCanonical(storageLoc == SILNodeStorageLocation::Instruction ||
+                    // TODO: Ask John about why he is using
+                    // hasMultipleSILNodeBaseClasses. Seems weird.
+                    (!hasMultipleSILNodeBaseClasses(kind) &&
+                     kind != SILNodeKind::MultipleValueInstructionResult)) {}
 
 public:
-
-  /// Does the given kind of node have multiple SILNode bases?
-  static bool hasMultipleSILNodes(SILNodeKind kind) {
+  /// Does the given kind of node inherit from multiple multiple SILNode base
+  /// classes.
+  ///
+  /// This enables one to know if their is a diamond in the inheritence
+  /// hierarchy for this SILNode.
+  static bool hasMultipleSILNodeBaseClasses(SILNodeKind kind) {
     // Currently only SingleValueInstructions.  Note that multi-result
     // instructions shouldn't return true for this.
     return kind >= SILNodeKind::First_SingleValueInstruction &&
@@ -246,7 +251,7 @@ struct cast_sil_node<To, /*single value*/ false, /*unambiguous*/ false> {
   static To *doit(SILNode *node) {
     // If the node isn't dynamically a SingleValueInstruction, then this
     // is indeed the SILNode subobject that's statically observable in To.
-    if (!SILNode::hasMultipleSILNodes(node->getKind())) {
+    if (!SILNode::hasMultipleSILNodeBaseClasses(node->getKind())) {
       return &static_cast<To&>(*node);
     }
 

include/swift/SIL/SILNodes.def

@@ -38,6 +38,16 @@
 #endif
 #endif
 
+/// MULTIPLE_VALUE_INST(Id, TextualName, Parent, MemBehavior, MayRelease)
+///
+///   A concrete subclass of MultipleValueInstruction. ID is a member of
+///   SILInstructionKind. The Node's class name is ID and the name of the base
+///   class in the heirarchy is PARENT.
+#ifndef MULTIPLE_VALUE_INST
+#define MULTIPLE_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE) \
+  FULL_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)
+#endif
+
 /// VALUE(ID, PARENT)
 ///
 ///   A concrete subclass of ValueBase.  ID is a member of ValueKind.
@@ -195,6 +205,8 @@ ABSTRACT_VALUE(SILArgument, ValueBase)
   ARGUMENT(SILFunctionArgument, SILArgument)
   VALUE_RANGE(SILArgument, SILPHIArgument, SILFunctionArgument)
 
+VALUE(MultipleValueInstructionResult, ValueBase)
+
 VALUE(SILUndef, ValueBase)
 
 ABSTRACT_NODE(SILInstruction, SILNode)
@@ -629,6 +641,7 @@ NODE_RANGE(SILNode, SILPHIArgument, CondFailInst)
 #undef ABSTRACT_VALUE_AND_INST
 #undef TERMINATOR
 #undef NON_VALUE_INST
+#undef MULTIPLE_VALUE_INST
 #undef SINGLE_VALUE_INST
 #undef FULL_INST
 #undef INST

include/swift/SIL/SILValue.h

@@ -133,7 +133,8 @@ struct ValueOwnershipKind {
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ValueOwnershipKind Kind);
 
 /// This is the base class of the SIL value hierarchy, which represents a
-/// runtime computed value. Things like SILInstruction derive from this.
+/// runtime computed value. Some examples of ValueBase are SILArgument and
+/// SingleValueInstruction.
 class ValueBase : public SILNode, public SILAllocated<ValueBase> {
   SILType Type;
   Operand *FirstUse = nullptr;

lib/ParseSIL/ParseSIL.cpp

@@ -4781,15 +4781,18 @@ bool SILParser::parseSILFunctionRef(SILLocation InstLoc,
 }
 
 /// True if the current token sequence looks like the start of a SIL
-/// instruction, either:
-///   %name
-/// or:
-///   identifier | keyword
+/// instruction. This can be one of:
+///
+/// 1. %name
+/// 2. (%name1
+/// 3. identifier | keyword
 /// where identifier is not followed by a '(' or ':', which would indicate
 /// a basic block.
 bool SILParser::isStartOfSILInstruction() {
   if (P.Tok.is(tok::sil_local_name))
     return true;
+  if (P.Tok.is(tok::l_paren) && P.peekToken().is(tok::sil_local_name))
+    return true;
   if (P.Tok.is(tok::identifier) || P.Tok.isKeyword()) {
     auto &peek = P.peekToken();
     return !peek.is(tok::l_paren) && !peek.is(tok::colon);

lib/SIL/SILInstruction.cpp

@@ -185,9 +185,13 @@ SILInstructionResultArray SILInstruction::getResultsImpl() const {
     return SILInstructionResultArray(
         static_cast<const SingleValueInstruction *>(this));
 
-    // add any multi-result instructions here...
+#define MULTIPLE_VALUE_INST(ID, NAME, PARENT, MEMBEHAVIOR, MAYRELEASE)         \
+  case SILInstructionKind::ID:
+#include "swift/SIL/SILNodes.def"
+    return SILInstructionResultArray(
+        static_cast<const MultipleValueInstruction *>(this));
   }
-  llvm_unreachable("bad kind");
+  llvm_unreachable("unhandled kind");
 }
 
 // Initialize the static members of SILInstruction.
@@ -1202,33 +1206,70 @@ SILInstructionResultArray::SILInstructionResultArray(
          "multi-inheritence parent");
   Pointer = reinterpret_cast<const uint8_t *>(Value);
 
+#ifndef NDEBUG
   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);
+#endif
+}
+
+SILInstructionResultArray::SILInstructionResultArray(
+    const MultipleValueInstruction *MVI)
+    : Pointer(), Size(MVI->Results.size()) {
+  // We are assuming here that MultipleValueInstructionResult when static_cast
+  // is not offset.
+  Pointer = reinterpret_cast<const uint8_t *>(&MVI->Results[0]);
+
+#ifndef NDEBUG
+  // Verify our invariants.
+  assert(size() == MVI->Results.size());
+  auto ValueRange = getValues();
+  auto VRangeBegin = ValueRange.begin();
+  auto VRangeIter = VRangeBegin;
+  auto VRangeEnd = ValueRange.end();
+  assert(MVI->Results.size() ==
+         unsigned(std::distance(VRangeBegin, VRangeEnd)));
+
+  auto TypedRange = getTypes();
+  auto TRangeBegin = TypedRange.begin();
+  auto TRangeIter = TRangeBegin;
+  auto TRangeEnd = TypedRange.end();
+  assert(MVI->Results.size() ==
+         unsigned(std::distance(VRangeBegin, VRangeEnd)));
+  for (unsigned i : indices(MVI->Results)) {
+    assert(SILValue(&MVI->Results[i]) == (*this)[i]);
+    assert(SILValue(&MVI->Results[i])->getType() == (*this)[i]->getType());
+    assert(SILValue(&MVI->Results[i]) == (*VRangeIter));
+    assert(SILValue(&MVI->Results[i])->getType() == (*VRangeIter)->getType());
+    assert(SILValue(&MVI->Results[i])->getType() == *TRangeIter);
+    ++VRangeIter;
+    ++TRangeIter;
+  }
+
+  SILInstructionResultArray Copy = *this;
+  assert(Copy.hasSameTypes(*this));
+  assert(Copy == *this);
+#endif
 }
 
 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;
+  // *NOTE* In the case where we have a single instruction, Index will always
+  // necessarily be 0 implying that it is safe for us to just multiple Index by
+  // sizeof(MultipleValueInstructionResult).
+  size_t Offset = sizeof(MultipleValueInstructionResult) * Index;
   return SILValue(reinterpret_cast<const ValueBase *>(&Pointer[Offset]));
 }