Merge pull request #41366 from atrick/addrlower-silapi

Many minor/obvious SIL API improvements that address lowering depends on

Author: atrick

include/swift/SIL/ApplySite.h

@@ -580,18 +580,19 @@ class FullApplySite : public ApplySite {
     return getSubstCalleeConv().hasIndirectSILResults();
   }
 
-  /// If our apply site has a single direct result SILValue, return that
-  /// SILValue. Return SILValue() otherwise.
+  /// Get the SIL value that represents all of the given call's results. For a
+  /// single direct result, returns the result. For multiple results, returns a
+  /// fake tuple value. The tuple has no storage of its own. The real results
+  /// must be extracted from it.
   ///
-  /// This means that:
+  /// For ApplyInst, returns the single-value instruction itself.
   ///
-  /// 1. If we have an ApplyInst, we just visit the apply.
-  /// 2. If we have a TryApplyInst, we visit the first argument of the normal
-  ///    block.
-  /// 3. If we have a BeginApplyInst, we return SILValue() since the begin_apply
-  ///    yields values instead of returning them. A returned value should only
-  ///    be valid after a full apply site has completely finished executing.
-  SILValue getSingleDirectResult() const {
+  /// For TryApplyInst returns the continuation block argument.
+  ///
+  /// For BeginApplyInst, returns an invalid value. For coroutines, there is no
+  /// single value representing all results. Yielded values are generally
+  /// handled differently since they have the convention of incoming arguments.
+  SILValue getPseudoResult() const {
     switch (getKind()) {
     case FullApplySiteKind::ApplyInst:
       return SILValue(cast<ApplyInst>(getInstruction()));

include/swift/SIL/Dominance.h

@@ -88,6 +88,19 @@ class DominanceInfo : public DominatorTreeBase {
   }
 };
 
+/// Compute a single block's dominance frontier.
+///
+/// Precondition: no critical edges (OSSA)
+///
+/// Postcondition: each block in \p frontier is dominated by \p root and either
+/// exits the function or has a single successor that is not dominated by \p
+/// root.
+///
+/// With no critical edges, the dominance frontier is identified simply by leaf
+/// blocks in the dominance subtree.
+void computeDominanceFrontier(SILBasicBlock *root, DominanceInfo *domTree,
+                              SmallVectorImpl<SILBasicBlock *> &frontier);
+
 /// Helper class for visiting basic blocks in dominance order, based on a
 /// worklist algorithm. Example usage:
 /// \code

include/swift/SIL/MemAccessUtils.h

@@ -1689,7 +1689,7 @@ Result AccessUseDefChainVisitor<Impl, Result>::visit(SILValue sourceAddr) {
 
   case ValueKind::SILPhiArgument: {
     auto *phiArg = cast<SILPhiArgument>(sourceAddr);
-    if (phiArg->isPhiArgument()) {
+    if (phiArg->isPhi()) {
       return asImpl().visitPhi(phiArg);
     }
 

include/swift/SIL/OwnershipUtils.h

@@ -79,8 +79,7 @@ inline bool isForwardingConsume(SILValue value) {
 }
 
 /// Find leaf "use points" of \p guaranteedValue that determine its lifetime
-/// requirement. If \p usePoints is nullptr, then the simply returns true if no
-/// PointerEscape use was found.
+/// requirement. Return true if no PointerEscape use was found.
 ///
 /// Precondition: \p guaranteedValue is not a BorrowedValue.
 ///

include/swift/SIL/SILArgument.h

@@ -22,6 +22,7 @@ namespace swift {
 
 class SILBasicBlock;
 class SILModule;
+class SILPhiArgument;
 class SILUndef;
 class TermInst;
 
@@ -115,9 +116,15 @@ class SILArgument : public ValueBase {
 
   unsigned getIndex() const;
 
-  /// Return true if this block argument is actually a phi argument as
-  /// opposed to a cast or projection.
-  bool isPhiArgument() const;
+  /// Return non-null if \p value is a phi.
+  static SILPhiArgument *isPhi(SILValue value);
+
+  /// Return non-null if \p value is a terminator result.
+  static SILPhiArgument *isTerminatorResult(SILValue value);
+
+  /// Return true if this block argument is a phi as opposed to a terminator
+  /// result.
+  bool isPhi() const;
 
   /// Return true if this block argument is a terminator result.
   bool isTerminatorResult() const;
@@ -217,12 +224,12 @@ class SILPhiArgument : public SILArgument {
       : SILArgument(ValueKind::SILPhiArgument, type, ownershipKind, decl) {}
 
 public:
-  /// Return true if this is block argument is actually a phi argument as
-  /// opposed to a cast or projection.
-  bool isPhiArgument() const;
+  /// Return true if this is block argument is a phi, as opposed to a terminator
+  /// result.
+  bool isPhi() const;
 
   /// Return true if this block argument is a terminator result.
-  bool isTerminatorResult() const { return !isPhiArgument(); }
+  bool isTerminatorResult() const { return !isPhi(); }
 
   /// If this argument is a phi, return the incoming phi value for the given
   /// predecessor BB. If this argument is not a phi, return an invalid SILValue.
@@ -365,16 +372,34 @@ class SILFunctionArgument : public SILArgument {
 // Out of line Definitions for SILArgument to avoid Forward Decl issues
 //===----------------------------------------------------------------------===//
 
-inline bool SILArgument::isPhiArgument() const {
+/// Return non-null if \p value is a real phi argument.
+inline SILPhiArgument *SILArgument::isPhi(SILValue value) {
+  if (auto *arg = dyn_cast<SILPhiArgument>(value)) {
+    if (arg->isPhi())
+      return arg;
+  }
+  return nullptr;
+}
+
+inline bool SILArgument::isPhi() const {
   switch (getKind()) {
   case SILArgumentKind::SILPhiArgument:
-    return cast<SILPhiArgument>(this)->isPhiArgument();
+    return cast<SILPhiArgument>(this)->isPhi();
   case SILArgumentKind::SILFunctionArgument:
     return false;
   }
   llvm_unreachable("Covered switch is not covered?!");
 }
 
+/// Return non-null if \p value is a terminator result.
+inline SILPhiArgument *SILArgument::isTerminatorResult(SILValue value) {
+  if (auto *arg = dyn_cast<SILPhiArgument>(value)) {
+    if (arg->isTerminatorResult())
+      return arg;
+  }
+  return nullptr;
+}
+
 inline bool SILArgument::isNoImplicitCopy() const {
   if (auto *fArg = dyn_cast<SILFunctionArgument>(this))
     return fArg->isNoImplicitCopy();

include/swift/SIL/SILBasicBlock.h

@@ -581,7 +581,7 @@ struct PhiValue {
 
   PhiValue(SILValue value) {
     auto *blockArg = dyn_cast<SILPhiArgument>(value);
-    if (!blockArg || !blockArg->isPhiArgument())
+    if (!blockArg || !blockArg->isPhi())
       return;
 
     phiBlock = blockArg->getParent();
@@ -600,6 +600,11 @@ struct PhiValue {
     return cast<SILPhiArgument>(phiBlock->getArgument(argIndex));
   }
 
+  Operand *getOperand(SILBasicBlock *predecessor) {
+    auto *branch = cast<BranchInst>(predecessor->getTerminator());
+    return &branch->getAllOperands()[argIndex];
+  }
+
   operator SILValue() const { return getValue(); }
   SILValue operator*() const { return getValue(); }
   SILValue operator->() const { return getValue(); }

include/swift/SIL/SILBuilder.h

@@ -896,19 +896,18 @@ class SILBuilder {
   ///   [trivial].
   ///
   /// * Otherwise, emit an actual store_borrow.
-  void emitStoreBorrowOperation(SILLocation loc, SILValue src,
-                                SILValue destAddr) {
+  SILInstruction *emitStoreBorrowOperation(SILLocation loc, SILValue src,
+                                           SILValue destAddr) {
     if (!hasOwnership()) {
-      return emitStoreValueOperation(loc, src, destAddr,
-                                     StoreOwnershipQualifier::Unqualified);
-    }
-
-    if (src->getType().isTrivial(getFunction())) {
-      return emitStoreValueOperation(loc, src, destAddr,
-                                     StoreOwnershipQualifier::Trivial);
+      emitStoreValueOperation(loc, src, destAddr,
+                              StoreOwnershipQualifier::Unqualified);
+    } else if (src->getType().isTrivial(getFunction())) {
+      emitStoreValueOperation(loc, src, destAddr,
+                              StoreOwnershipQualifier::Trivial);
+    } else {
+      createStoreBorrow(loc, src, destAddr);
     }
-
-    createStoreBorrow(loc, src, destAddr);
+    return &*std::prev(getInsertionPoint());
   }
 
   MarkUninitializedInst *
@@ -2691,7 +2690,7 @@ class SILBuilder {
     // sync. We don't care if an instruction is used in global_addr.
     if (F)
       TheInst->verifyDebugInfo();
-    TheInst->verifyOperandOwnership();
+    TheInst->verifyOperandOwnership(&C.silConv);
 #endif
   }
 

include/swift/SIL/SILInstruction.h

@@ -567,19 +567,30 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   bool maySuspend() const;
 
 private:
-  /// Predicate used to filter OperandValueRange.
+  /// Functor for Operand::get()
   struct OperandToValue;
-  /// Predicate used to filter TransformedOperandValueRange.
+  /// Functor for Operand::get()
+  struct OperandRefToValue;
+  /// Predicate to filter NonTypeDependentOperandValueRange
+  struct NonTypeDependentOperandToValue;
+  /// Predicate to filter TransformedOperandValueRange.
   struct OperandToTransformedValue;
 
 public:
-  using OperandValueRange =
-      OptionalTransformRange<ArrayRef<Operand>, OperandToValue>;
+  using OperandValueRange = TransformRange<ArrayRef<Operand*>, OperandToValue>;
+  using OperandRefValueRange =
+    TransformRange<ArrayRef<Operand>, OperandRefToValue>;
+  using NonTypeDependentOperandValueRange =
+    OptionalTransformRange<ArrayRef<Operand>, NonTypeDependentOperandToValue>;
   using TransformedOperandValueRange =
-      OptionalTransformRange<ArrayRef<Operand>, OperandToTransformedValue>;
+    OptionalTransformRange<ArrayRef<Operand>, OperandToTransformedValue>;
+
+  static OperandValueRange getOperandValues(ArrayRef<Operand*> operands);
+
+  OperandRefValueRange getOperandValues() const;
+
+  NonTypeDependentOperandValueRange getNonTypeDependentOperandValues() const;
 
-  OperandValueRange
-  getOperandValues(bool skipTypeDependentOperands = false) const;
   TransformedOperandValueRange
   getOperandValues(std::function<SILValue(SILValue)> transformFn,
                    bool skipTypeDependentOperands) const;
@@ -762,7 +773,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
 
   /// Verify that all operands of this instruction have compatible ownership
   /// with this instruction.
-  void verifyOperandOwnership() const;
+  void verifyOperandOwnership(SILModuleConventions *silConv = nullptr) const;
 
   /// Verify that this instruction and its associated debug information follow
   /// all SIL debug info invariants.
@@ -879,14 +890,24 @@ inline const SILNode *SILNode::instAsNode(const SILInstruction *inst) {
 
 
 struct SILInstruction::OperandToValue {
+  SILValue operator()(const Operand *use) const {
+    return use->get();
+  }
+};
+
+struct SILInstruction::OperandRefToValue {
+  SILValue operator()(const Operand &use) const {
+    return use.get();
+  }
+};
+
+struct SILInstruction::NonTypeDependentOperandToValue {
   const SILInstruction &i;
-  bool skipTypeDependentOps;
 
-  OperandToValue(const SILInstruction &i, bool skipTypeDependentOps)
-      : i(i), skipTypeDependentOps(skipTypeDependentOps) {}
+  NonTypeDependentOperandToValue(const SILInstruction &i): i(i) {}
 
   Optional<SILValue> operator()(const Operand &use) const {
-    if (skipTypeDependentOps && i.isTypeDependentOperand(use))
+    if (i.isTypeDependentOperand(use))
       return None;
     return use.get();
   }
@@ -910,11 +931,21 @@ struct SILInstruction::OperandToTransformedValue {
   }
 };
 
+inline SILInstruction::OperandValueRange
+SILInstruction::getOperandValues(ArrayRef<Operand*> operands) {
+  return OperandValueRange(operands, OperandToValue());
+}
+
 inline auto
-SILInstruction::getOperandValues(bool skipTypeDependentOperands) const
-    -> OperandValueRange {
-  return OperandValueRange(getAllOperands(),
-                           OperandToValue(*this, skipTypeDependentOperands));
+SILInstruction::getOperandValues() const -> OperandRefValueRange {
+  return OperandRefValueRange(getAllOperands(), OperandRefToValue());
+}
+
+inline auto
+SILInstruction::getNonTypeDependentOperandValues() const
+  -> NonTypeDependentOperandValueRange {
+  return NonTypeDependentOperandValueRange(getAllOperands(),
+                                           NonTypeDependentOperandToValue(*this));
 }
 
 inline auto
@@ -1145,6 +1176,18 @@ class OwnershipForwardingMixin {
       return isa(i);
     return false;
   }
+
+  /// Return true if the forwarded value has the same representation. If true,
+  /// then the result can be mapped to the same storage without a move or copy.
+  ///
+  /// \p inst is an OwnershipForwardingMixin
+  static bool hasSameRepresentation(SILInstruction *inst);
+
+  /// Return true if the forwarded value is address-only either before or after
+  /// forwarding.
+  ///
+  /// \p inst is an OwnershipForwardingMixin
+  static bool isAddressOnly(SILInstruction *inst);
 };
 
 /// A single value inst that forwards a static ownership from its first operand.

include/swift/SIL/SILValue.h

@@ -46,6 +46,7 @@ class ConsumingUseIterator;
 class NonConsumingUseIterator;
 class NonTypeDependentUseIterator;
 class SILValue;
+class SILModuleConventions;
 
 /// An enumeration which contains values for all the concrete ValueBase
 /// subclasses.
@@ -922,7 +923,8 @@ inline bool canAcceptUnownedValue(OperandOwnership operandOwnership) {
 }
 
 /// Return true if all OperandOwnership invariants hold.
-bool checkOperandOwnershipInvariants(const Operand *operand);
+bool checkOperandOwnershipInvariants(const Operand *operand,
+                                     SILModuleConventions *silConv = nullptr);
 
 /// Return the OperandOwnership for a forwarded operand when the forwarding
 /// operation has this "forwarding ownership" (as returned by
@@ -1039,22 +1041,25 @@ class Operand {
   /// Return the use ownership of this operand.
   ///
   /// NOTE: This is implemented in OperandOwnership.cpp.
-  OperandOwnership getOperandOwnership() const;
+  OperandOwnership
+  getOperandOwnership(SILModuleConventions *silConv = nullptr) const;
 
   /// Return the ownership constraint that restricts what types of values this
   /// Operand can contain.
-  OwnershipConstraint getOwnershipConstraint() const {
-    return getOperandOwnership().getOwnershipConstraint();
+  OwnershipConstraint
+  getOwnershipConstraint(SILModuleConventions *silConv = nullptr) const {
+    return getOperandOwnership(silConv).getOwnershipConstraint();
   }
 
   /// Returns true if changing the operand to use a value with the given
   /// ownership kind, without rewriting the instruction, would not cause the
   /// operand to violate the operand's ownership constraints.
-  bool canAcceptKind(ValueOwnershipKind kind) const;
+  bool canAcceptKind(ValueOwnershipKind kind,
+                     SILModuleConventions *silConv = nullptr) const;
 
   /// Returns true if this operand and its value satisfy the operand's
   /// operand constraint.
-  bool satisfiesConstraints() const;
+  bool satisfiesConstraints(SILModuleConventions *silConv = nullptr) const;
 
   /// Returns true if this operand acts as a use that ends the lifetime its
   /// associated value, either by consuming the owned value or ending the

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -78,6 +78,16 @@ makeGuaranteedValueAvailable(SILValue value, SILInstruction *user,
                              DeadEndBlocks &deBlocks,
                              InstModCallbacks callbacks = InstModCallbacks());
 
+/// Compute the liveness boundary for a guaranteed value. Returns true if no
+/// uses are pointer escapes. If pointer escapes are present, the liveness
+/// boundary is still valid for all known uses.
+///
+/// Precondition: \p value has guaranteed ownership and no reborrows. It is
+/// either an "inner" guaranteed value or a simple borrow introducer whose
+/// end_borrows have not yet been inserted.
+bool computeGuaranteedBoundary(SILValue value,
+                               PrunedLivenessBoundary &boundary);
+
 //===----------------------------------------------------------------------===//
 //                        GuaranteedOwnershipExtension
 //===----------------------------------------------------------------------===//