---

yaml
---
r: 570809
b: refs/heads/main
c: 34353b8
h: refs/heads/main
i:
  570807: 67caf65

Author: xymus

[refs]

@@ -2015,4 +2015,4 @@ refs/tags/swift-5.3-DEVELOPMENT-SNAPSHOT-2020-09-06-a: 539017b61d4fd33e72f269983
 refs/tags/swift-5.3-DEVELOPMENT-SNAPSHOT-2020-09-07-a: 30277ea9d7139d33bf3a0b476c9f05f7140a17f0
 refs/tags/swift-5.3-DEVELOPMENT-SNAPSHOT-2020-09-09-a: e1eb555e1b2365ec8b0252d9d7edec351f40f9ca
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2020-09-11-a: 48ed530cc4805b5f29fc519ec25ed290e058e674
-refs/heads/main: 2bbebcb18022362192780157917eb16e3c9b8239
+refs/heads/main: 34353b8a40809a6b279b3fd5eab94874aa53b55f

trunk/docs/SIL.rst

@@ -1961,7 +1961,7 @@ alloc_stack
 ```````````
 ::
 
-  sil-instruction ::= 'alloc_stack' sil-type (',' debug-var-attr)*
+  sil-instruction ::= 'alloc_stack' '[dynamic_lifetime]'? sil-type (',' debug-var-attr)*
 
   %1 = alloc_stack $T
   // %1 has type $*T
@@ -1980,6 +1980,10 @@ predecessors, the stack height and order of allocations must be consistent
 coming from all predecessor blocks. ``alloc_stack`` allocations must be
 deallocated in last-in, first-out stack order.
 
+The ``dynamic_lifetime`` attribute specifies that the initialization and
+destruction of the stored value cannot be verified at compile time.
+This is the case, e.g. for conditionally initialized objects.
+
 The memory is not retainable. To allocate a retainable box for a value
 type, use ``alloc_box``.
 

trunk/include/swift/SIL/ApplySite.h

@@ -134,6 +134,9 @@ class ApplySite {
   /// Return the callee operand as a value.
   SILValue getCallee() const { return getCalleeOperand()->get(); }
 
+  /// Return the callee operand.
+  Operand *getCalleeOperand() { FOREACH_IMPL_RETURN(getCalleeOperand()); }
+
   /// Return the callee operand.
   const Operand *getCalleeOperand() const {
     FOREACH_IMPL_RETURN(getCalleeOperand());

trunk/include/swift/SIL/BasicBlockUtils.h

@@ -71,13 +71,13 @@ class DeadEndBlocks {
   DeadEndBlocks(const SILFunction *F) : F(F) {}
 
   /// Returns true if \p BB is a dead-end block.
-  bool isDeadEnd(SILBasicBlock *BB) {
+  bool isDeadEnd(const SILBasicBlock *block) {
     if (!isComputed) {
       // Lazily compute the dataflow.
       compute();
       isComputed = true;
     }
-    return ReachableBlocks.count(BB) == 0;
+    return ReachableBlocks.count(block) == 0;
   }
 };
 

trunk/include/swift/SIL/BranchPropagatedUser.h

@@ -15,7 +15,6 @@
 
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
-#include "swift/SIL/BranchPropagatedUser.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILValue.h"
@@ -29,7 +28,6 @@ class SILInstruction;
 class SILModule;
 class SILValue;
 class DeadEndBlocks;
-class BranchPropagatedUser;
 
 namespace ownership {
 
@@ -167,30 +165,21 @@ class LinearLifetimeChecker {
   /// \p leakingBlocks If non-null a list of blocks where the value was detected
   /// to leak. Can be used to insert missing destroys.
   LinearLifetimeError
-  checkValue(SILValue value, ArrayRef<BranchPropagatedUser> consumingUses,
-             ArrayRef<BranchPropagatedUser> nonConsumingUses,
+  checkValue(SILValue value, ArrayRef<Operand *> consumingUses,
+             ArrayRef<Operand *> nonConsumingUses,
              ownership::ErrorBehaviorKind errorBehavior,
              SmallVectorImpl<SILBasicBlock *> *leakingBlocks = nullptr);
 
   /// Returns true that \p value forms a linear lifetime with consuming uses \p
   /// consumingUses, non consuming uses \p nonConsumingUses. Returns false
   /// otherwise.
-  bool validateLifetime(SILValue value,
-                        ArrayRef<BranchPropagatedUser> consumingUses,
-                        ArrayRef<BranchPropagatedUser> nonConsumingUses) {
+  bool validateLifetime(SILValue value, ArrayRef<Operand *> consumingUses,
+                        ArrayRef<Operand *> nonConsumingUses) {
     return !checkValue(value, consumingUses, nonConsumingUses,
                        ownership::ErrorBehaviorKind::ReturnFalse,
                        nullptr /*leakingBlocks*/)
                 .getFoundError();
   }
-
-  bool validateLifetime(SILValue value,
-                        ArrayRef<SILInstruction *> consumingUses,
-                        ArrayRef<SILInstruction *> nonConsumingUses) {
-    return validateLifetime(
-        value, BranchPropagatedUser::convertFromInstArray(consumingUses),
-        BranchPropagatedUser::convertFromInstArray(nonConsumingUses));
-  }
 };
 
 } // namespace swift

trunk/include/swift/SIL/LinearLifetimeChecker.h

@@ -53,6 +53,14 @@ namespace swift {
 /// (pointer-to-address is not stripped).
 SILValue stripAccessMarkers(SILValue v);
 
+/// Return a non-null address-type SingleValueInstruction if \p v is the result
+/// of an address projection that may be inside of a formal access, such as
+/// (begin_borrow, struct_element_addr, tuple_element_addr).
+///
+/// The resulting projection must have an address-type operand at index zero
+/// representing the projected address.
+SingleValueInstruction *isAccessProjection(SILValue v);
+
 /// Attempt to return the address corresponding to a variable's formal access
 /// by stripping indexing and address projections.
 ///
@@ -540,7 +548,7 @@ bool memInstMustInitialize(Operand *memOper);
 /// alloc_stack. If the alloc_stack is destroyed in pieces, we do not guarantee
 /// that the list of destroying users is a minimal jointly post-dominating set.
 bool isSingleInitAllocStack(AllocStackInst *asi,
-                            SmallVectorImpl<SILInstruction *> &destroyingUsers);
+                            SmallVectorImpl<Operand *> &destroyingUses);
 
 /// Return true if the given address producer may be the source of a formal
 /// access (a read or write of a potentially aliased, user visible variable).

trunk/include/swift/SIL/MemAccessUtils.h

@@ -319,16 +319,15 @@ struct BorrowScopeIntroducingValue {
 
   bool isLocalScope() const { return kind.isLocalScope(); }
 
-  /// Returns true if the passed in set of instructions is completely within the
-  /// lifetime of this borrow introducer.
+  /// Returns true if the passed in set of uses is completely within
+  /// the lifetime of this borrow introducer.
   ///
   /// NOTE: Scratch space is used internally to this method to store the end
   /// borrow scopes if needed.
-  bool
-  areInstructionsWithinScope(ArrayRef<SILInstruction *> instructions,
-                             SmallVectorImpl<SILInstruction *> &scratchSpace,
-                             SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
-                             DeadEndBlocks &deadEndBlocks) const;
+  bool areUsesWithinScope(ArrayRef<Operand *> instructions,
+                          SmallVectorImpl<Operand *> &scratchSpace,
+                          SmallPtrSetImpl<SILBasicBlock *> &visitedBlocks,
+                          DeadEndBlocks &deadEndBlocks) const;
 
   /// Given a local borrow scope introducer, visit all non-forwarding consuming
   /// users. This means that this looks through guaranteed block arguments.

trunk/include/swift/SIL/OwnershipUtils.h

@@ -728,6 +728,7 @@ class SILBuilder {
   }
 
   BeginBorrowInst *createBeginBorrow(SILLocation Loc, SILValue LV) {
+    assert(!LV->getType().isAddress());
     return insert(new (getModule())
                       BeginBorrowInst(getSILDebugLocation(Loc), LV));
   }

trunk/include/swift/SIL/SILBuilder.h

@@ -1444,7 +1444,18 @@ class AllocStackInst final
     }
   }
 
+  /// Set to true that this alloc_stack contains a value whose lifetime can not
+  /// be ascertained from uses.
+  ///
+  /// As an example if an alloc_stack is known to be only conditionally
+  /// initialized.
   void setDynamicLifetime() { dynamicLifetime = true; }
+
+  /// Returns true if the alloc_stack's initialization can not be ascertained
+  /// from uses directly (so should be treated conservatively).
+  ///
+  /// An example of an alloc_stack with dynamic lifetime is an alloc_stack that
+  /// is conditionally initialized.
   bool hasDynamicLifetime() const { return dynamicLifetime; }
 
   /// Return the debug variable information attached to this instruction.
@@ -1875,6 +1886,7 @@ class ApplyInstBase<Impl, Base, false> : public Base {
   /// The operand number of the first argument.
   static unsigned getArgumentOperandNumber() { return NumStaticOperands; }
 
+  Operand *getCalleeOperand() { return &getAllOperands()[Callee]; }
   const Operand *getCalleeOperand() const { return &getAllOperands()[Callee]; }
   SILValue getCallee() const { return getCalleeOperand()->get(); }
 

trunk/include/swift/SIL/SILInstruction.h

@@ -669,6 +669,9 @@ class Operand {
     return constraint == UseLifetimeConstraint::MustBeInvalidated;
   }
 
+  SILBasicBlock *getParentBlock() const;
+  SILFunction *getParentFunction() const;
+
 private:
   void removeFromCurrent() {
     if (!Back) return;

trunk/include/swift/SIL/SILValue.h

@@ -3204,8 +3204,11 @@ static void dumpSubstitutionMapRec(
     out << "substitution ";
     genericParams[i]->print(out);
     out << " -> ";
-    if (replacementTypes[i])
-      replacementTypes[i]->print(out);
+    if (replacementTypes[i]) {
+      PrintOptions opts;
+      opts.PrintForSIL = true;
+      replacementTypes[i]->print(out, opts);
+    }
     else
       out << "<<unresolved concrete type>>";
     printParen(')');