Merge pull request swiftlang#8824 from gottesmm/mark_uninitialized_fixup

Author: swift-ci

include/swift/Basic/STLExtras.h

@@ -711,6 +711,17 @@ inline void copy(const Container &C, OutputIterator iter) {
   std::copy(C.begin(), C.end(), iter);
 }
 
+template <typename Container, typename OutputIterator, typename Predicate>
+inline void copy_if(const Container &C, OutputIterator result, Predicate pred) {
+  std::copy_if(C.begin(), C.end(), result, pred);
+}
+
+template <typename Container, typename OutputIterator, typename UnaryOperation>
+inline OutputIterator transform(const Container &C, OutputIterator result,
+                                UnaryOperation op) {
+  return std::transform(C.begin(), C.end(), result, op);
+}
+
 //===----------------------------------------------------------------------===//
 //                              Function Traits
 //===----------------------------------------------------------------------===//

include/swift/SIL/SILInstruction.h

@@ -895,6 +895,11 @@ class AllocBoxInst final
     return getType().castTo<SILBoxType>();
   }
 
+  // Return the type of the memory stored in the alloc_box.
+  SILType getAddressType() const {
+    return getBoxType()->getFieldType(getModule(), 0).getAddressType();
+  }
+
   /// Return the underlying variable declaration associated with this
   /// allocation, or null if this is a temporary allocation.
   VarDecl *getDecl() const;

include/swift/SILOptimizer/PassManager/Passes.def

@@ -261,6 +261,8 @@ PASS(ValueOwnershipKindDumper, "value-ownership-kind-dumper",
      "Print Value Ownership Kind for Testing")
 PASS(SemanticARCOpts, "semantic-arc-opts",
      "Semantic ARC Optimization")
+PASS(MarkUninitializedFixup, "mark-uninitialized-fixup",
+     "Temporary pass for staging in mark_uninitialized changes.")
 PASS(BugReducerTester, "bug-reducer-tester",
      "sil-bug-reducer Tool Testing by Asserting on a Sentinel Function")
 PASS_RANGE(AllPasses, AADumper, BugReducerTester)

lib/SIL/SILOwnershipVerifier.cpp

@@ -303,7 +303,8 @@ class OwnershipCompatibilityUseChecker
   bool isAddressOrTrivialType() const {
     if (getType().isAddress())
       return true;
-    return getOwnershipKind() == ValueOwnershipKind::Trivial;
+    return getOwnershipKind() == ValueOwnershipKind::Trivial ||
+      getOwnershipKind() == ValueOwnershipKind::Any;
   }
 
   /// Depending on our initialization, either return false or call Func and
@@ -1928,6 +1929,9 @@ void SILInstruction::verifyOperandOwnership() const {
   for (const Operand &Op : getAllOperands()) {
     if (isTypeDependentOperand(Op))
       continue;
+    // Skip any SILUndef that we see.
+    if (isa<SILUndef>(Op.get()))
+      continue;
     OwnershipCompatibilityUseChecker(getModule(), Op, Op.get(), ErrorBehavior)
         .check(Self);
   }

lib/SIL/SILVerifier.cpp

@@ -1415,9 +1415,17 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     require(MU->getModule().getStage() == SILStage::Raw,
             "mark_uninitialized instruction can only exist in raw SIL");
     require(Src->getType().isAddress() ||
-            Src->getType().getSwiftRValueType()->getClassOrBoundGenericClass(),
-            "mark_uninitialized must be an address or class");
+                Src->getType()
+                    .getSwiftRValueType()
+                    ->getClassOrBoundGenericClass() ||
+                Src->getType().getAs<SILBoxType>(),
+            "mark_uninitialized must be an address, class, or box type");
     require(Src->getType() == MU->getType(),"operand and result type mismatch");
+#if 0
+    // This will be turned back on in a couple of commits.
+    require(isa<AllocationInst>(Src) || isa<SILArgument>(Src),
+            "Mark Uninitialized should always be on the storage location");
+#endif
   }
 
   void checkMarkUninitializedBehaviorInst(MarkUninitializedBehaviorInst *MU) {
@@ -1888,9 +1896,19 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     require(AI->getType().isObject(),
             "result of alloc_box must be an object");
-    for (unsigned field : indices(AI->getBoxType()->getLayout()->getFields()))
+    for (unsigned field : indices(AI->getBoxType()->getLayout()->getFields())) {
       verifyOpenedArchetype(AI,
                    AI->getBoxType()->getFieldLoweredType(F.getModule(), field));
+    }
+
+    // An alloc_box with a mark_uninitialized user can not have any other users.
+    require(none_of(AI->getUses(),
+                    [](Operand *Op) -> bool {
+                      return isa<MarkUninitializedInst>(Op->getUser());
+                    }) ||
+                AI->hasOneUse(),
+            "An alloc_box with a mark_uninitialized user can not have any "
+            "other users.");
   }
 
   void checkDeallocBoxInst(DeallocBoxInst *DI) {

lib/SILGen/SILGenConstructor.cpp

@@ -567,11 +567,7 @@ void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
 
   if (NeedsBoxForSelf) {
     // Allocate the local variable for 'self'.
-    emitLocalVariableWithCleanup(selfDecl, None)->finishInitialization(*this);
-
-    auto &SelfVarLoc = VarLocs[selfDecl];
-    SelfVarLoc.value = B.createMarkUninitialized(selfDecl,
-                                                 SelfVarLoc.value, MUKind);
+    emitLocalVariableWithCleanup(selfDecl, MUKind)->finishInitialization(*this);
   }
 
   // Emit the prolog for the non-self arguments.

lib/SILGen/SILGenDecl.cpp

@@ -386,13 +386,14 @@ class LocalVariableInitialization : public SingleBufferInitialization {
 
     // The variable may have its lifetime extended by a closure, heap-allocate
     // it using a box.
-    AllocBoxInst *allocBox =
+    SILInstruction *allocBox =
         SGF.B.createAllocBox(decl, boxType, {decl->isLet(), ArgNo});
-    SILValue addr = SGF.B.createProjectBox(decl, allocBox, 0);
 
     // Mark the memory as uninitialized, so DI will track it for us.
     if (kind)
-      addr = SGF.B.createMarkUninitialized(decl, addr, kind.getValue());
+      allocBox = SGF.B.createMarkUninitialized(decl, allocBox, kind.getValue());
+
+    SILValue addr = SGF.B.createProjectBox(decl, allocBox, 0);
 
     /// Remember that this is the memory location that we're emitting the
     /// decl to.

lib/SILGen/SILGenFunction.cpp

@@ -276,7 +276,8 @@ void SILGenFunction::emitCaptures(SILLocation loc,
 
         AllocBoxInst *allocBox = B.createAllocBox(loc, boxTy);
         ProjectBoxInst *boxAddress = B.createProjectBox(loc, allocBox, 0);
-        B.createCopyAddr(loc, vl.value, boxAddress, IsNotTake,IsInitialization);
+        B.createCopyAddr(loc, vl.value, boxAddress, IsNotTake,
+                         IsInitialization);
         capturedArgs.push_back(emitManagedRValueWithCleanup(allocBox));
       }
 

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -74,6 +74,7 @@ static void addOwnershipModelEliminatorPipeline(SILPassPipelinePlan &P) {
 static void addMandatoryOptPipeline(SILPassPipelinePlan &P,
                                     const SILOptions &Options) {
   P.startPipeline("Guaranteed Passes");
+  P.addMarkUninitializedFixup();
   if (Options.EnableMandatorySemanticARCOpts) {
     P.addSemanticARCOpts();
   }

lib/SILOptimizer/Transforms/CMakeLists.txt

@@ -14,6 +14,7 @@ set(TRANSFORMS_SOURCES
   Transforms/FunctionSignatureOpts.cpp
   Transforms/GenericSpecializer.cpp
   Transforms/MergeCondFail.cpp
+  Transforms/MarkUninitializedFixup.cpp
   Transforms/OwnershipModelEliminator.cpp
   Transforms/PerformanceInliner.cpp
   Transforms/RedundantLoadElimination.cpp