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

Author: swift-ci

include/swift/SILOptimizer/Utils/Devirtualize.h

@@ -76,7 +76,7 @@ bool canDevirtualizeClassMethod(FullApplySite AI, ClassDecl *CD,
                                 CanType ClassType,
                                 OptRemark::Emitter *ORE = nullptr,
                                 bool isEffectivelyFinalMethod = false);
-SILFunction *getTargetClassMethod(SILModule &M, ClassDecl *CD,
+SILFunction *getTargetClassMethod(SILModule &M, FullApplySite as, ClassDecl *CD,
                                   CanType ClassType, MethodInst *MI);
 CanType getSelfInstanceType(CanType ClassOrMetatypeType);
 

lib/SILOptimizer/Mandatory/MoveOnlyWrappedTypeEliminator.cpp

@@ -234,6 +234,7 @@ struct SILMoveOnlyWrappedTypeEliminatorVisitor
   NO_UPDATE_NEEDED(BridgeObjectToRef)
   NO_UPDATE_NEEDED(BeginAccess)
   NO_UPDATE_NEEDED(EndAccess)
+  NO_UPDATE_NEEDED(EndCOWMutationAddr)
   NO_UPDATE_NEEDED(ClassMethod)
   NO_UPDATE_NEEDED(FixLifetime)
   NO_UPDATE_NEEDED(AddressToPointer)

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -116,12 +116,13 @@ static void addMandatoryDiagnosticOptPipeline(SILPassPipelinePlan &P) {
   // Select access kind after capture promotion and before stack promotion.
   // This guarantees that stack-promotable boxes have [static] enforcement.
   P.addAccessEnforcementSelection();
-
+/* Temporarily disabled: rdar://154686063, rdar://154713388
 #ifdef SWIFT_ENABLE_SWIFT_IN_SWIFT
   P.addMandatoryAllocBoxToStack();
 #else
+*/
   P.addLegacyAllocBoxToStack();
-#endif
+//#endif
   P.addNoReturnFolding();
   P.addBooleanLiteralFolding();
   addDefiniteInitialization(P);
@@ -417,7 +418,8 @@ void addHighLevelLoopOptPasses(SILPassPipelinePlan &P) {
 void addFunctionPasses(SILPassPipelinePlan &P,
                        OptimizationLevelKind OpLevel) {
   // Promote box allocations to stack allocations.
-  P.addAllocBoxToStack();
+  // TODO: change this to add addAllocBoxToStack once rdar://154686063, rdar://154713388 is fixed
+  P.addLegacyAllocBoxToStack();
 
   if (P.getOptions().DestroyHoisting == DestroyHoistingOption::On) {
     P.addDestroyAddrHoisting();

lib/SILOptimizer/Transforms/SpeculativeDevirtualizer.cpp

@@ -446,7 +446,7 @@ static bool tryToSpeculateTarget(SILPassManager *pm, FullApplySite AI, ClassHier
 
   // Try to devirtualize the static class of instance
   // if it is possible.
-  if (auto F = getTargetClassMethod(M, CD, ClassType, CMI)) {
+  if (auto F = getTargetClassMethod(M, AI, CD, ClassType, CMI)) {
     // Do not devirtualize if a method in the base class is marked
     // as non-optimizable. This way it is easy to disable the
     // devirtualization of this method in the base class and

lib/SILOptimizer/Utils/Devirtualize.cpp

@@ -712,7 +712,7 @@ void swift::deleteDevirtualizedApply(ApplySite old) {
   recursivelyDeleteTriviallyDeadInstructions(oldApply, true);
 }
 
-SILFunction *swift::getTargetClassMethod(SILModule &module, ClassDecl *cd,
+SILFunction *swift::getTargetClassMethod(SILModule &module, FullApplySite as, ClassDecl *cd,
                                          CanType classType, MethodInst *mi) {
   assert((isa<ClassMethodInst>(mi) || isa<SuperMethodInst>(mi)) &&
          "Only class_method and super_method instructions are supported");
@@ -721,6 +721,11 @@ SILFunction *swift::getTargetClassMethod(SILModule &module, ClassDecl *cd,
 
   SILType silType = SILType::getPrimitiveObjectType(classType);
   if (auto *vtable = module.lookUpSpecializedVTable(silType)) {
+    // We cannot de-virtualize a generic method call to a specialized method.
+    // This would result in wrong argument/return calling conventions.
+    if (as.getSubstitutionMap().hasAnySubstitutableParams())
+      return nullptr;
+
     return vtable->getEntry(module, member)->getImplementation();
   }
 
@@ -757,7 +762,7 @@ bool swift::canDevirtualizeClassMethod(FullApplySite applySite, ClassDecl *cd,
   auto *mi = cast<MethodInst>(applySite.getCallee());
 
   // Find the implementation of the member which should be invoked.
-  auto *f = getTargetClassMethod(module, cd, classType, mi);
+  auto *f = getTargetClassMethod(module, applySite, cd, classType, mi);
 
   // If we do not find any such function, we have no function to devirtualize
   // to... so bail.
@@ -843,7 +848,7 @@ swift::devirtualizeClassMethod(SILPassManager *pm, FullApplySite applySite,
   SILModule &module = applySite.getModule();
   auto *mi = cast<MethodInst>(applySite.getCallee());
 
-  auto *f = getTargetClassMethod(module, cd, classType, mi);
+  auto *f = getTargetClassMethod(module, applySite, cd, classType, mi);
 
   CanSILFunctionType genCalleeType = f->getLoweredFunctionTypeInContext(
       TypeExpansionContext(*applySite.getFunction()));

test/IRGen/generic_tuples.swift

@@ -27,10 +27,9 @@ func dup<T>(_ x: T) -> (T, T) { var x = x; return (x,x) }
 //   Copy 'x' into the first result.
 // CHECK-NEXT: call ptr [[WITNESS]](ptr noalias %0, ptr noalias [[X_ALLOCA]], ptr %T)
 //   Copy 'x' into the second element.
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 4
+// CHECK-NEXT: [[WITNESS:%.*]] = load ptr, ptr [[WITNESS_ADDR]], align 8
 // CHECK-NEXT: call ptr [[WITNESS]](ptr noalias %1, ptr noalias [[X_ALLOCA]], ptr %T)
-// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds ptr, ptr [[VWT]], i32 1
-// CHECK-NEXT: [[DESTROYWITNESS:%.*]] = load ptr, ptr [[WITNESS_ADDR]], align 8
-// CHECK-NEXT: call void [[DESTROYWITNESS]](ptr noalias [[X_ALLOCA]],
 
 struct S {}
 

test/SILOptimizer/allocboxtostack_localapply.swift

@@ -103,7 +103,7 @@ public func testboxescapes() -> (() -> ()) {
 }
 
 // CHECK-LABEL: sil [noinline] @$s26allocboxtostack_localapply9testrecurSiyF :
-// CHECK:          alloc_stack [var_decl] $Int, var, name "x"
+// CHECK: alloc_box ${ var Int }, var, name "x"
 // CHECK-LABEL: } // end sil function '$s26allocboxtostack_localapply9testrecurSiyF'
 @inline(never)
 public func testrecur() -> Int {
@@ -146,9 +146,14 @@ public func testdfs1() -> Int {
   return common()
 }
 
+// Test to make sure we don't optimize the case when we have an inner common function call for multiple boxes.
+// We don't optimize this case now, because we don't have additional logic to correctly construct AppliesToSpecialize
+// Order of function calls constructed in PromotedOperands: bar innercommon local1 bas innercommon local2
+// AppliesToSpecialize should have the order: bar bas innercommon local1 local2
+// Since we don't maintain any tree like data structure with more info on the call tree, this is not possible to construct today 
 // CHECK-LABEL: sil [noinline] @$s26allocboxtostack_localapply8testdfs2SiyF :
-// CHECK:          alloc_stack [var_decl] $Int, var, name "x"
-// CHECK:          alloc_stack [var_decl] $Int, var, name "y"
+// CHECK: alloc_box ${ var Int }, var, name "x"
+// CHECK: alloc_box ${ var Int }, var, name "y"
 // CHECK-LABEL:} // end sil function '$s26allocboxtostack_localapply8testdfs2SiyF'
 @inline(never)
 public func testdfs2() -> Int {
@@ -177,20 +182,3 @@ public func testdfs2() -> Int {
   return local1() + local2()
 }
 
-// CHECK-LABEL: sil @$s26allocboxtostack_localapply15call2localfuncsSiyF :
-// CHECK-NOT:     alloc_box
-// CHECK-LABEL:} // end sil function '$s26allocboxtostack_localapply15call2localfuncsSiyF'
-public func call2localfuncs() -> Int {
-    var a1 = 1
-    
-    @inline(never)
-    func innerFunction() {
-        a1 += 1
-    }
-
-    innerFunction()
-    innerFunction()
-
-    return a1
-}
-

test/SILOptimizer/definite_init_protocol_init.swift

@@ -99,8 +99,7 @@ struct AddressOnlyStruct : TriviallyConstructible {
 // CHECK-NEXT: apply [[FN]]<AddressOnlyStruct>([[SELF_BOX]], %1, [[METATYPE]])
 // CHECK-NEXT: copy_addr [take] [[SELF_BOX]] to [init] [[SELF]]
 // CHECK-NEXT: dealloc_stack [[SELF_BOX]]
-// CHECK-NEXT: copy_addr [[SELF]] to [init] %0
-// CHECK-NEXT: destroy_addr [[SELF]]
+// CHECK-NEXT: copy_addr [take] [[SELF]] to [init] %0
 // CHECK-NEXT: dealloc_stack [[SELF]]
 // CHECK-NEXT: [[RESULT:%.*]] = tuple ()
 // CHECK-NEXT: return [[RESULT]]

test/SILOptimizer/span.swift

@@ -0,0 +1,8 @@
+// RUN: %target-swift-frontend %s -parse-as-library -disable-availability-checking -emit-ir -o /dev/null
+
+// Check that the MoveOnlyWrappedTypeEliminator doesn't crash
+func consumingArray(_ arr: consuming [Int]) {
+  let s = arr.mutableSpan;
+  _ = consume s
+}
+

test/embedded/devirt_generic_class_methods.swift

@@ -0,0 +1,22 @@
+// RUN: %target-swift-frontend %s -parse-as-library -enable-experimental-feature Embedded -Xllvm -sil-disable-pass=mandatory-inlining -emit-ir -o /dev/null
+
+// REQUIRES: swift_feature_Embedded
+
+
+// Check that the compiler doesn't crash
+
+public class Base<T> {
+  func foo(_ t: T) -> T {
+    return t
+  }
+}
+
+@_transparent
+func callee(_ i: Int, _ c: Base<Int>) -> Int {
+  return c.foo(i)
+}
+
+public func testit(_ i : Int) -> Int {
+  return callee(i, Base<Int>())
+}
+