Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/SIL/ApplySite.h

@@ -116,6 +116,9 @@ class ApplySite {
 
   ApplySiteKind getKind() const { return ApplySiteKind(Inst->getKind()); }
 
+  SILInstruction *operator*() const { return Inst; }
+  SILInstruction *operator->() const { return Inst; }
+
   explicit operator bool() const { return Inst != nullptr; }
 
   SILInstruction *getInstruction() const { return Inst; }

include/swift/SIL/OwnershipUtils.h

@@ -189,13 +189,13 @@ struct BorrowingOperand {
 
   // A set of operators so that a BorrowingOperand can be used like a normal
   // operand in a light weight way.
-  operator const Operand *() const { return op; }
-  operator Operand *() { return op; }
   const Operand *operator*() const { return op; }
   Operand *operator*() { return op; }
   const Operand *operator->() const { return op; }
   Operand *operator->() { return op; }
 
+  operator bool() const { return kind != BorrowingOperandKind::Invalid && op; }
+
   /// If \p op is a borrow introducing operand return it after doing some
   /// checks.
   static BorrowingOperand get(Operand *op) {

include/swift/SIL/SILType.h

@@ -429,6 +429,13 @@ class SILType {
   SILType getEnumElementType(EnumElementDecl *elt, SILModule &M,
                              TypeExpansionContext context) const;
 
+  /// Given that this is an enum type, return the lowered type of the
+  /// data for the given element.  Applies substitutions as necessary.
+  /// The result will have the same value category as the base type.
+  ///
+  /// NOTE: Takes the type expansion context from \p fn.
+  SILType getEnumElementType(EnumElementDecl *elt, SILFunction *fn) const;
+
   /// Given that this is an enum type, return true if this type is effectively
   /// exhausted.
   bool isEffectivelyExhaustiveEnumType(SILFunction *f);

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -705,6 +705,11 @@ SILValue
 makeNewValueAvailable(SILValue value, SILBasicBlock *inBlock,
                       JointPostDominanceSetComputer *jointPostDomComputer);
 
+/// Given a forwarding instruction, eliminate it if all of its users are debug
+/// instructions and ownership uses.
+bool tryEliminateOnlyOwnershipUsedForwardingInst(
+    SingleValueInstruction *forwardingInst, InstModCallbacks &callbacks);
+
 } // end namespace swift
 
 #endif

include/swift/SILOptimizer/Utils/OwnershipOptUtils.h

@@ -19,6 +19,7 @@
 #ifndef SWIFT_SILOPTIMIZER_UTILS_OWNERSHIPOPTUTILS_H
 #define SWIFT_SILOPTIMIZER_UTILS_OWNERSHIPOPTUTILS_H
 
+#include "swift/Basic/Defer.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/OwnershipUtils.h"
 #include "swift/SIL/SILModule.h"
@@ -76,6 +77,17 @@ struct OwnershipFixupContext {
     extraAddressFixupInfo.intPtrOp = InteriorPointerOperand();
   }
 
+  /// Gets access to the joint post dominance computer and clears it after \p
+  /// callback.
+  template <typename ResultTy>
+  ResultTy withJointPostDomComputer(
+      function_ref<ResultTy(JointPostDominanceSetComputer &)> callback) {
+    // Make sure we clear the joint post dom computer after callback.
+    SWIFT_DEFER { jointPostDomSetComputer.clear(); };
+    // Then return callback passing in the computer.
+    return callback(jointPostDomSetComputer);
+  }
+
 private:
   /// Helper method called to determine if we discovered we needed interior
   /// pointer fixups while simplifying.
@@ -129,6 +141,37 @@ class OwnershipRAUWHelper {
                                              SILValue newValue);
 };
 
+/// A utility composed ontop of OwnershipFixupContext that knows how to replace
+/// a single use of a value with another value with a different ownership. We
+/// allow for the values to have different types.
+///
+/// NOTE: When not in OSSA, this just performs a normal set use, so this code is
+/// safe to use with all code.
+class OwnershipReplaceSingleUseHelper {
+  OwnershipFixupContext *ctx;
+  Operand *use;
+  SILValue newValue;
+
+public:
+  OwnershipReplaceSingleUseHelper()
+      : ctx(nullptr), use(nullptr), newValue(nullptr) {}
+
+  /// Return an instance of this class if we support replacing \p use->get()
+  /// with \p newValue.
+  ///
+  /// NOTE: For now we only support objects, not addresses so addresses will
+  /// always yield an invalid helper.
+  OwnershipReplaceSingleUseHelper(OwnershipFixupContext &ctx, Operand *use,
+                                  SILValue newValue);
+
+  /// Returns true if this helper was initialized into a valid state.
+  operator bool() const { return isValid(); }
+  bool isValid() const { return bool(ctx) && bool(use) && bool(newValue); }
+
+  /// Perform the actual RAUW.
+  SILBasicBlock::iterator perform();
+};
+
 } // namespace swift
 
 #endif

lib/SIL/IR/SILType.cpp

@@ -195,6 +195,12 @@ SILType SILType::getEnumElementType(EnumElementDecl *elt, SILModule &M,
   return getEnumElementType(elt, M.Types, context);
 }
 
+SILType SILType::getEnumElementType(EnumElementDecl *elt,
+                                    SILFunction *fn) const {
+  return getEnumElementType(elt, fn->getModule(),
+                            fn->getTypeExpansionContext());
+}
+
 bool SILType::isLoadableOrOpaque(const SILFunction &F) const {
   SILModule &M = F.getModule();
   return isLoadable(F) || !SILModuleConventions(M).useLoweredAddresses();

lib/SIL/Verifier/MemoryLifetime.cpp

@@ -132,6 +132,36 @@ int MemoryLocations::getLocationIdx(SILValue addr) const {
   return iter->second;
 }
 
+static bool canHandleAllocStack(AllocStackInst *asi) {
+  assert(asi);
+
+  // An alloc_stack with dynamic lifetime set has a lifetime that relies on
+  // unrelated conditional control flow for correctness. This means that we may
+  // statically leak along paths that were known by the emitter to never be
+  // taken if the value is live. So bail since we can't verify this.
+  if (asi->hasDynamicLifetime())
+    return false;
+
+  // Currently in this verifier, we stop verifying if we find a switch_enum_addr
+  // use. This creates a problem since no one has gone through and changed the
+  // frontend/optimizer to understand that it needs to insert destroy_addr on
+  // alloc_stack even if dynamically we know that the enum has a trivial case or
+  // non-payloaded case due to a switch_enum_addr. So if one then performs the
+  // completely unrelated, valid optimization of promoting the switch_enum_addr
+  // to a switch_enum (lets say using a load_borrow), then this verifier will
+  // see a leaked value along the non-payloaded path.
+  //
+  // Disable this verification for now until a complete analysis of enums is
+  // implemented.
+  //
+  // https://bugs.swift.org/browse/SR-14123
+  if (asi->getType().getEnumOrBoundGenericEnum())
+    return false;
+
+  // Otherwise we can optimize!
+  return true;
+}
+
 void MemoryLocations::analyzeLocations(SILFunction *function) {
   // As we have to limit the set of handled locations to memory, which is
   // guaranteed to be not aliased, we currently only handle indirect function
@@ -152,12 +182,13 @@ void MemoryLocations::analyzeLocations(SILFunction *function) {
   }
   for (SILBasicBlock &BB : *function) {
     for (SILInstruction &I : BB) {
-      auto *ASI = dyn_cast<AllocStackInst>(&I);
-      if (ASI && !ASI->hasDynamicLifetime()) {
-        if (allUsesInSameBlock(ASI)) {
-          singleBlockLocations.push_back(ASI);
-        } else {
-          analyzeLocation(ASI);
+      if (auto *ASI = dyn_cast<AllocStackInst>(&I)) {
+        if (canHandleAllocStack(ASI)) {
+          if (allUsesInSameBlock(ASI)) {
+            singleBlockLocations.push_back(ASI);
+          } else {
+            analyzeLocation(ASI);
+          }
         }
       }
     }

lib/SILOptimizer/Analysis/SimplifyInstruction.cpp

@@ -70,6 +70,7 @@ namespace {
     SILValue visitPointerToThinFunctionInst(PointerToThinFunctionInst *PTTFI);
     SILValue visitBeginAccessInst(BeginAccessInst *BAI);
     SILValue visitMetatypeInst(MetatypeInst *MTI);
+    SILValue visitConvertFunctionInst(ConvertFunctionInst *cfi);
 
     SILValue simplifyOverflowBuiltin(BuiltinInst *BI);
   };
@@ -482,6 +483,19 @@ SILValue InstSimplifier::visitBeginAccessInst(BeginAccessInst *BAI) {
   return SILValue();
 }
 
+SILValue InstSimplifier::visitConvertFunctionInst(ConvertFunctionInst *cfi) {
+  // Eliminate round trip convert_function. Non round-trip is performed in
+  // SILCombine.
+  //
+  // (convert_function Y->X (convert_function x X->Y)) -> x
+  SILValue convertedValue = lookThroughOwnershipInsts(cfi->getConverted());
+  if (auto *subCFI = dyn_cast<ConvertFunctionInst>(convertedValue))
+    if (subCFI->getConverted()->getType() == cfi->getType())
+      return lookThroughOwnershipInsts(subCFI->getConverted());
+
+  return SILValue();
+}
+
 SILValue InstSimplifier::visitMetatypeInst(MetatypeInst *MI) {
   auto metaType = MI->getType().castTo<MetatypeType>();
   auto instanceType = metaType.getInstanceType();

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -21,6 +21,7 @@
 #ifndef SWIFT_SILOPTIMIZER_PASSMANAGER_SILCOMBINER_H
 #define SWIFT_SILOPTIMIZER_PASSMANAGER_SILCOMBINER_H
 
+#include "swift/Basic/Defer.h"
 #include "swift/SIL/BasicBlockUtils.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILInstruction.h"
@@ -433,6 +434,21 @@ class SILCombiner :
   /// Returns true if the results of a try_apply are not used.
   static bool isTryApplyResultNotUsed(UserListTy &AcceptedUses,
                                       TryApplyInst *TAI);
+
+  bool hasOwnership() const {
+    return Builder.hasOwnership();
+  }
+
+  /// Gets access to the joint post dominance computer and clears it after \p
+  /// callback.
+  template <typename ResultTy>
+  ResultTy withJointPostDomComputer(
+      function_ref<ResultTy(JointPostDominanceSetComputer &)> callback) {
+    // Make sure we clear the joint post dom computer after callback.
+    SWIFT_DEFER { jPostDomComputer.clear(); };
+    // Then return callback passing in the computer.
+    return callback(jPostDomComputer);
+  }
 };
 
 } // end namespace swift