[sil] Teach constant folding how to handle destructures and multiple value instructions.

I also ported the constant_propagation.sil tests over for ownership and updated
a few parts of the cast optimizer so that those tests pass with and without
ownership. I purposely only updated the parts of the cast optimizer that crashed
with ownership in the relevant test so that I can add new sil code coverage for
those uncovered code paths.

Author: gottesmm

include/swift/SIL/PatternMatch.h

@@ -467,6 +467,34 @@ tupleextract_ty<LTy> m_TupleExtractInst(const LTy &Left, unsigned Index) {
   return tupleextract_ty<LTy>(Left, Index);
 }
 
+/// Match either a tuple_extract that the index field from a tuple or the
+/// indexth destructure_tuple result.
+template <typename LTy> struct tupleextractoperation_ty {
+  LTy L;
+  unsigned index;
+  tupleextractoperation_ty(const LTy &Left, unsigned i) : L(Left), index(i) {}
+
+  template <typename ITy> bool match(ITy *V) {
+    if (auto *TEI = dyn_cast<TupleExtractInst>(V)) {
+      return TEI->getFieldNo() == index &&
+             L.match((ValueBase *)TEI->getOperand());
+    }
+
+    if (auto *DTR = dyn_cast<DestructureTupleResult>(V)) {
+      return DTR->getIndex() == index &&
+             L.match((ValueBase *)DTR->getParent()->getOperand());
+    }
+
+    return false;
+  }
+};
+
+template <typename LTy>
+tupleextractoperation_ty<LTy> m_TupleExtractOperation(const LTy &Left,
+                                                      unsigned Index) {
+  return tupleextractoperation_ty<LTy>(Left, Index);
+}
+
 //===----------------------------------------------------------------------===//
 //              Function/Builtin/Intrinsic Application Matchers
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILInstruction.h

@@ -517,6 +517,8 @@ class SILInstruction
   SILInstructionResultArray getResults() const { return getResultsImpl(); }
   unsigned getNumResults() const { return getResults().size(); }
 
+  SILValue getResult(unsigned index) const { return getResults()[index]; }
+
   /// Return the types of the results produced by this instruction.
   SILInstructionResultArray::type_range getResultTypes() const {
     return getResultsImpl().getTypes();

include/swift/SILOptimizer/Utils/ConstantFolding.h

@@ -92,6 +92,10 @@ class ConstantFolder {
   /// Initialize the worklist with all instructions of the function \p F.
   void initializeWorklist(SILFunction &F);
 
+  /// When asserts are enabled, dumps the worklist for diagnostic
+  /// purposes. Without asserts this is a no-op.
+  void dumpWorklist() const;
+
   /// Initialize the worklist with a single instruction \p I.
   void addToWorklist(SILInstruction *I) {
     WorkList.insert(I);

lib/SILOptimizer/Utils/CastOptimizer.cpp

@@ -1429,12 +1429,12 @@ static bool optimizeStaticallyKnownProtocolConformance(
     }
     case ExistentialRepresentation::Class: {
       auto Value =
-          B.createLoad(Loc, Src, swift::LoadOwnershipQualifier::Unqualified);
+          B.emitLoadValueOperation(Loc, Src, LoadOwnershipQualifier::Take);
       auto Existential =
           B.createInitExistentialRef(Loc, Dest->getType().getObjectType(),
                                      SourceType, Value, Conformances);
-      B.createStore(Loc, Existential, Dest,
-                    swift::StoreOwnershipQualifier::Unqualified);
+      B.emitStoreValueOperation(Loc, Existential, Dest,
+                                StoreOwnershipQualifier::Init);
       break;
     }
     case ExistentialRepresentation::Boxed: {
@@ -1445,8 +1445,8 @@ static bool optimizeStaticallyKnownProtocolConformance(
       // This needs to be a copy_addr (for now) because we must handle
       // address-only types.
       B.createCopyAddr(Loc, Src, Projection, IsTake, IsInitialization);
-      B.createStore(Loc, AllocBox, Dest,
-                    swift::StoreOwnershipQualifier::Unqualified);
+      B.emitStoreValueOperation(Loc, AllocBox, Dest,
+                                StoreOwnershipQualifier::Init);
       break;
     }
     };
@@ -1489,12 +1489,12 @@ SILInstruction *CastOptimizer::optimizeUnconditionalCheckedCastAddrInst(
     if (!resultTL.isAddressOnly()) {
       auto undef = SILValue(
           SILUndef::get(DestType.getObjectType(), Builder.getModule()));
-      Builder.createStore(Loc, undef, Dest,
-                          StoreOwnershipQualifier::Unqualified);
+      Builder.emitStoreValueOperation(Loc, undef, Dest,
+                                      StoreOwnershipQualifier::Init);
     }
     auto *TrapI = Builder.createBuiltinTrap(Loc);
     EraseInstAction(Inst);
-    Builder.setInsertionPoint(std::next(SILBasicBlock::iterator(TrapI)));
+    Builder.setInsertionPoint(std::next(TrapI->getIterator()));
     auto *UnreachableInst =
         Builder.createUnreachable(ArtificialUnreachableLocation());