[sil] Add support for the destructure_{struct,tuple} instructions.

rdar://31521023

Author: gottesmm

docs/SIL.rst

@@ -784,8 +784,11 @@ Basic Blocks
   sil-label ::= sil-identifier ('(' sil-argument (',' sil-argument)* ')')? ':'
   sil-argument ::= sil-value-name ':' sil-type
 
-  sil-instruction-def ::= (sil-value-name '=')? sil-instruction
-                          (',' sil-loc)? (',' sil-scope-ref)?
+  sil-instruction-result ::= sil-value-name
+  sil-instruction-result ::= '(' (sil-value-name (',' sil-value-name)*)? ')'
+  sil-instruction-source-info ::= (',' sil-scope-ref)? (',' sil-loc)?
+  sil-instruction-def ::=
+    (sil-instruction-result '=')? sil-instruction sil-instruction-source-info
 
 A function body consists of one or more basic blocks that correspond
 to the nodes of the function's control flow graph. Each basic block
@@ -3506,6 +3509,19 @@ tuple_element_addr
 Given the address of a tuple in memory, derives the
 address of an element within that value.
 
+destructure_tuple
+`````````````````
+
+::
+
+   sil-instruction ::= 'destructure_tuple' sil-operand
+
+   (%elt1, ..., %eltn) = destructure_tuple %0 : $(Elt1Ty, ..., EltNTy)
+   // %0 must be a tuple of type $(Elt1Ty, ..., EltNTy)
+   // %eltN must have the type $EltNTy
+
+Given a tuple value, split the value into its constituent elements.
+
 struct
 ``````
 ::
@@ -3547,6 +3563,19 @@ struct_element_addr
 Given the address of a struct value in memory, derives the address of a
 physical field within the value.
 
+destructure_struct
+``````````````````
+
+::
+
+   sil-instruction ::= 'destructure_struct' sil-operand
+
+   (%elt1, ..., %eltn) = destructure_struct %0 : $S
+   // %0 must be a struct of type $S
+   // %eltN must have the same type as the Nth field of $S
+
+Given a struct, split the struct into its constituant fields.
+
 object
 ``````
 ::

include/swift/SIL/SILBuilder.h

@@ -1178,6 +1178,18 @@ class SILBuilder {
                                                       Ref, ResultTy));
   }
 
+  DestructureStructInst *createDestructureStruct(SILLocation Loc,
+                                                 SILValue Operand) {
+    return insert(DestructureStructInst::create(
+        getModule(), getSILDebugLocation(Loc), Operand));
+  }
+
+  DestructureTupleInst *createDestructureTuple(SILLocation Loc,
+                                               SILValue Operand) {
+    return insert(DestructureTupleInst::create(
+        getModule(), getSILDebugLocation(Loc), Operand));
+  }
+
   ClassMethodInst *createClassMethod(SILLocation Loc, SILValue Operand,
                                      SILDeclRef Member, SILType MethodTy) {
     return insert(new (getModule()) ClassMethodInst(

include/swift/SIL/SILCloner.h

@@ -1518,9 +1518,28 @@ SILCloner<ImplClass>::visitRefTailAddrInst(RefTailAddrInst *Inst) {
                                    getOpType(Inst->getType())));
 }
 
-template<typename ImplClass>
-void
-SILCloner<ImplClass>::visitClassMethodInst(ClassMethodInst *Inst) {
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitDestructureStructInst(
+    DestructureStructInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(
+      Inst,
+      getBuilder().createDestructureStruct(getOpLocation(Inst->getLoc()),
+                                           getOpValue(Inst->getOperand())));
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitDestructureTupleInst(
+    DestructureTupleInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  doPostProcess(
+      Inst,
+      getBuilder().createDestructureTuple(getOpLocation(Inst->getLoc()),
+                                          getOpValue(Inst->getOperand())));
+}
+
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitClassMethodInst(ClassMethodInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
   doPostProcess(Inst,
     getBuilder().createClassMethod(getOpLocation(Inst->getLoc()),

include/swift/SIL/SILInstruction.h

@@ -788,7 +788,9 @@ class MultipleValueInstructionResult : public ValueBase {
   static bool classof(const SILNode *node) {
     // This is an abstract class without anything implementing it right now, so
     // just return false. This will be fixed in a subsequent commit.
-    return false;
+    SILNodeKind kind = node->getKind();
+    return kind >= SILNodeKind::First_MultipleValueInstructionResult &&
+           kind <= SILNodeKind::Last_MultipleValueInstructionResult;
   }
 
 protected:
@@ -830,9 +832,9 @@ class MultipleValueInstruction : public SILInstruction {
   unsigned getNumResults() const { return getResults().size(); }
 
   static bool classof(const SILNode *node) {
-    // This is an abstract class without anything implementing it right now, so
-    // just return false. This will be fixed in a subsequent commit.
-    return false;
+    SILNodeKind kind = node->getKind();
+    return kind >= SILNodeKind::First_MultipleValueInstruction &&
+           kind <= SILNodeKind::Last_MultipleValueInstruction;
   }
 };
 
@@ -7265,14 +7267,81 @@ SILFunction *ApplyInstBase<Impl, Base, false>::getCalleeFunction() const {
   }
 }
 
-inline SILNode *MultipleValueInstructionResult::getCanonicalSILNodeInObject() {
-  return getParent();
-}
+/// A result for the destructure_struct instruction. See documentation for
+/// destructure_struct for more information.
+class DestructureStructResult final : public MultipleValueInstructionResult {
+public:
+  DestructureStructResult(unsigned Index, SILType Type,
+                          ValueOwnershipKind OwnershipKind)
+      : MultipleValueInstructionResult(ValueKind::DestructureStructResult,
+                                       Index, Type, OwnershipKind) {}
 
-inline const SILNode *
-MultipleValueInstructionResult::getCanonicalSILNodeInObject() const {
-  return getParent();
-}
+  static bool classof(const SILNode *N) {
+    return N->getKind() == SILNodeKind::DestructureStructResult;
+  }
+};
+
+/// Instruction that takes in a struct value and splits the struct into the
+/// struct's fields.
+class DestructureStructInst final
+    : public UnaryInstructionBase<SILInstructionKind::DestructureStructInst,
+                                  MultipleValueInstruction>,
+      public MultipleValueInstructionTrailingObjects<
+          SILInstructionKind::DestructureStructInst, DestructureStructInst,
+          DestructureStructResult> {
+  friend TrailingObjects;
+
+  DestructureStructInst(SILModule &M, SILDebugLocation Loc, SILValue Operand,
+                        ArrayRef<SILType> Types,
+                        ArrayRef<ValueOwnershipKind> OwnershipKinds)
+      : UnaryInstructionBase(Loc, Operand),
+        MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
+
+public:
+  static DestructureStructInst *create(SILModule &M, SILDebugLocation Loc,
+                                       SILValue Operand);
+  static bool classof(const SILNode *N) {
+    return N->getKind() == SILNodeKind::DestructureStructInst;
+  }
+};
+
+/// A result for the destructure_tuple instruction. See documentation for
+/// destructure_tuple for more information.
+class DestructureTupleResult final : public MultipleValueInstructionResult {
+public:
+  DestructureTupleResult(unsigned Index, SILType Type,
+                         ValueOwnershipKind OwnershipKind)
+      : MultipleValueInstructionResult(ValueKind::DestructureTupleResult, Index,
+                                       Type, OwnershipKind) {}
+
+  static bool classof(const SILNode *N) {
+    return N->getKind() == SILNodeKind::DestructureTupleResult;
+  }
+};
+
+/// Instruction that takes in a tuple value and splits the tuple into the
+/// tuples's elements.
+class DestructureTupleInst final
+    : public UnaryInstructionBase<SILInstructionKind::DestructureTupleInst,
+                                  MultipleValueInstruction>,
+      public MultipleValueInstructionTrailingObjects<
+          SILInstructionKind::DestructureTupleInst, DestructureTupleInst,
+          DestructureTupleResult> {
+  friend TrailingObjects;
+
+  DestructureTupleInst(SILModule &M, SILDebugLocation Loc, SILValue Operand,
+                       ArrayRef<SILType> Types,
+                       ArrayRef<ValueOwnershipKind> OwnershipKinds)
+      : UnaryInstructionBase(Loc, Operand),
+        MultipleValueInstructionTrailingObjects(this, Types, OwnershipKinds) {}
+
+public:
+  static DestructureTupleInst *create(SILModule &M, SILDebugLocation Loc,
+                                      SILValue Operand);
+  static bool classof(const SILNode *N) {
+    return N->getKind() == SILNodeKind::DestructureTupleInst;
+  }
+};
 
 } // end swift namespace
 

include/swift/SIL/SILNodes.def

@@ -214,7 +214,10 @@ ABSTRACT_VALUE(SILArgument, ValueBase)
   ARGUMENT(SILFunctionArgument, SILArgument)
   VALUE_RANGE(SILArgument, SILPHIArgument, SILFunctionArgument)
 
-ABSTRACT_VALUE(MultipleValueResult, ValueBase)
+ABSTRACT_VALUE(MultipleValueInstructionResult, ValueBase)
+  MULTIPLE_VALUE_INST_RESULT(DestructureStructResult, MultipleValueInstructionResult)
+  MULTIPLE_VALUE_INST_RESULT(DestructureTupleResult, MultipleValueInstructionResult)
+  VALUE_RANGE(MultipleValueInstructionResult, DestructureStructResult, DestructureTupleResult)
 
 VALUE(SILUndef, ValueBase)
 
@@ -633,8 +636,15 @@ NON_VALUE_INST(CondFailInst, cond_fail,
 
 NODE_RANGE(NonValueInstruction, UnreachableInst, CondFailInst)
 
-NODE_RANGE(SILInstruction, AllocStackInst, CondFailInst)
-NODE_RANGE(SILNode, SILPHIArgument, CondFailInst)
+ABSTRACT_INST(MultipleValueInstruction, SILInstruction)
+MULTIPLE_VALUE_INST(DestructureStructInst, destructure_struct,
+                    SILInstruction, None, DoesNotRelease)
+MULTIPLE_VALUE_INST(DestructureTupleInst, destructure_tuple,
+                    SILInstruction, None, DoesNotRelease)
+INST_RANGE(MultipleValueInstruction, DestructureStructInst, DestructureTupleInst)
+
+NODE_RANGE(SILInstruction, AllocStackInst, DestructureTupleInst)
+NODE_RANGE(SILNode, SILPHIArgument, DestructureTupleInst)
 
 #undef SINGLE_VALUE_INST_RANGE
 #undef INST_RANGE

include/swift/SIL/SILValue.h

@@ -138,6 +138,13 @@ struct ValueOwnershipKind {
   bool isTrivialOr(ValueOwnershipKind Kind) const {
     return Value == Trivial || Value == Kind;
   }
+
+  /// Given that there is an aggregate value (like a struct or enum) with this
+  /// ownership kind, and a subobject of type Proj is being projected from the
+  /// aggregate, return Trivial if Proj has trivial type and the aggregate's
+  /// ownership kind otherwise.
+  ValueOwnershipKind getProjectedOwnershipKind(SILModule &M,
+                                               SILType Proj) const;
 };
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, ValueOwnershipKind Kind);

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 372; // Last change: VTable serialized
+const uint16_t VERSION_MINOR = 373; // Last change: destructure
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/IRGen/IRGenSIL.cpp

@@ -884,6 +884,12 @@ class IRGenSILFunction :
   void visitValueMetatypeInst(ValueMetatypeInst *i);
   void visitExistentialMetatypeInst(ExistentialMetatypeInst *i);
   void visitTupleExtractInst(TupleExtractInst *i);
+  void visitDestructureTupleInst(DestructureTupleInst *i) {
+    llvm_unreachable("unimplemented");
+  }
+  void visitDestructureStructInst(DestructureStructInst *i) {
+    llvm_unreachable("unimplemented");
+  }
   void visitTupleElementAddrInst(TupleElementAddrInst *i);
   void visitStructExtractInst(StructExtractInst *i);
   void visitStructElementAddrInst(StructElementAddrInst *i);

lib/ParseSIL/ParseSIL.cpp

@@ -2315,6 +2315,8 @@ bool SILParser::parseSILInstruction(SILBuilder &B) {
     UNARY_INSTRUCTION(DestroyValue)
     UNARY_INSTRUCTION(CondFail)
     UNARY_INSTRUCTION(EndBorrowArgument)
+    UNARY_INSTRUCTION(DestructureStruct)
+    UNARY_INSTRUCTION(DestructureTuple)
     REFCOUNTING_INSTRUCTION(UnmanagedReleaseValue)
     REFCOUNTING_INSTRUCTION(UnmanagedRetainValue)
     REFCOUNTING_INSTRUCTION(UnmanagedAutoreleaseValue)

lib/SIL/SILInstructions.cpp

@@ -14,15 +14,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/SIL/SILInstruction.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/ProtocolConformance.h"
-#include "swift/Basic/type_traits.h"
-#include "swift/Basic/Unicode.h"
 #include "swift/Basic/AssertImplements.h"
+#include "swift/Basic/Unicode.h"
+#include "swift/Basic/type_traits.h"
 #include "swift/SIL/FormalLinkage.h"
+#include "swift/SIL/Projection.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILCloner.h"
+#include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILVisitor.h"
 #include "llvm/ADT/APInt.h"
@@ -2326,3 +2327,69 @@ GenericSpecializationInformation::create(SILInstruction *Inst, SILBuilder &B) {
 
   return nullptr;
 }
+
+static void computeAggregateFirstLevelSubtypeInfo(
+    SILModule &M, SILValue Operand, llvm::SmallVectorImpl<SILType> &Types,
+    llvm::SmallVectorImpl<ValueOwnershipKind> &OwnershipKinds) {
+  SILType OpType = Operand->getType();
+
+  // TODO: Create an iterator for accessing first level projections to eliminate
+  // this SmallVector.
+  llvm::SmallVector<Projection, 8> Projections;
+  Projection::getFirstLevelProjections(OpType, M, Projections);
+
+  auto OpOwnershipKind = Operand.getOwnershipKind();
+  for (auto &P : Projections) {
+    SILType ProjType = P.getType(OpType, M);
+    Types.emplace_back(ProjType);
+    OwnershipKinds.emplace_back(
+        OpOwnershipKind.getProjectedOwnershipKind(M, ProjType));
+  }
+}
+
+DestructureStructInst *DestructureStructInst::create(SILModule &M,
+                                                     SILDebugLocation Loc,
+                                                     SILValue Operand) {
+  assert(Operand->getType().getStructOrBoundGenericStruct() &&
+         "Expected a struct typed operand?!");
+
+  llvm::SmallVector<SILType, 8> Types;
+  llvm::SmallVector<ValueOwnershipKind, 8> OwnershipKinds;
+  computeAggregateFirstLevelSubtypeInfo(M, Operand, Types, OwnershipKinds);
+  assert(Types.size() == OwnershipKinds.size() &&
+         "Expected same number of Types and OwnerKinds");
+
+  unsigned NumElts = Types.size();
+  unsigned Size =
+      totalSizeToAlloc<MultipleValueInstruction *, DestructureStructResult>(
+          1, NumElts);
+
+  void *Buffer = M.allocateInst(Size, alignof(DestructureStructInst));
+
+  return ::new (Buffer)
+      DestructureStructInst(M, Loc, Operand, Types, OwnershipKinds);
+}
+
+DestructureTupleInst *DestructureTupleInst::create(SILModule &M,
+                                                   SILDebugLocation Loc,
+                                                   SILValue Operand) {
+  assert(Operand->getType().getSwiftRValueType()->is<TupleType>() &&
+         "Expected a tuple typed operand?!");
+
+  llvm::SmallVector<SILType, 8> Types;
+  llvm::SmallVector<ValueOwnershipKind, 8> OwnershipKinds;
+  computeAggregateFirstLevelSubtypeInfo(M, Operand, Types, OwnershipKinds);
+  assert(Types.size() == OwnershipKinds.size() &&
+         "Expected same number of Types and OwnerKinds");
+
+  // We add 1 since we store an offset to our
+  unsigned NumElts = Types.size();
+  unsigned Size =
+      totalSizeToAlloc<MultipleValueInstruction *, DestructureTupleResult>(
+          1, NumElts);
+
+  void *Buffer = M.allocateInst(Size, alignof(DestructureTupleInst));
+
+  return ::new (Buffer)
+      DestructureTupleInst(M, Loc, Operand, Types, OwnershipKinds);
+}