[ownership] Change the stdlib to serialize code in ossa form on Darwin.

There is some sort of ASAN issue that this exposes on Linux, so I am going to do
this on Darwin and then debug the Linux issue using ASAN over the weekend/next
week.

Author: gottesmm

include/swift/AST/SILOptions.h

@@ -153,6 +153,11 @@ class SILOptions {
   /// Emit extra exclusvity markers for memory access and verify coverage.
   bool VerifyExclusivity = false;
 
+  /// When building the stdlib with opts should we lower ownership after
+  /// serialization? Otherwise we do before. Only set to true on Darwin for now.
+  ///
+  bool SerializeStdlibWithOwnershipWithOpts = false;
+
   /// Calls to the replaced method inside of the replacement method will call
   /// the previous implementation.
   ///

lib/Frontend/CompilerInvocation.cpp

@@ -1204,6 +1204,11 @@ static bool ParseSILArgs(SILOptions &Opts, ArgList &Args,
       Args.hasArg(OPT_sil_stop_optzns_before_lowering_ownership);
   if (const Arg *A = Args.getLastArg(OPT_external_pass_pipeline_filename))
     Opts.ExternalPassPipelineFilename = A->getValue();
+  // If our triple is a darwin triple, lower ownership on the stdlib after we
+  // serialize.
+  if (Triple.isOSDarwin()) {
+    Opts.SerializeStdlibWithOwnershipWithOpts = true;
+  }
 
   Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate);
   const Arg *ProfileUse = Args.getLastArg(OPT_profile_use);

lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -346,11 +346,13 @@ void addFunctionPasses(SILPassPipelinePlan &P,
   P.addDevirtualizer();
   P.addARCSequenceOpts();
 
-  // We earlier eliminated ownership if we are not compiling the stdlib. Now
-  // handle the stdlib functions, re-simplifying, eliminating ARC as we do.
-  P.addCopyPropagation();
-  P.addSemanticARCOpts();
-  P.addNonTransparentFunctionOwnershipModelEliminator();
+  if (!P.getOptions().SerializeStdlibWithOwnershipWithOpts) {
+    // We earlier eliminated ownership if we are not compiling the stdlib. Now
+    // handle the stdlib functions, re-simplifying, eliminating ARC as we do.
+    P.addCopyPropagation();
+    P.addSemanticARCOpts();
+    P.addNonTransparentFunctionOwnershipModelEliminator();
+  }
 
   switch (OpLevel) {
   case OptimizationLevelKind::HighLevel:
@@ -368,6 +370,12 @@ void addFunctionPasses(SILPassPipelinePlan &P,
     break;
   }
 
+  // Clean up Semantic ARC before we perform additional post-inliner opts.
+  if (P.getOptions().SerializeStdlibWithOwnershipWithOpts) {
+    P.addCopyPropagation();
+    P.addSemanticARCOpts();
+  }
+
   // Promote stack allocations to values and eliminate redundant
   // loads.
   P.addMem2Reg();
@@ -426,6 +434,12 @@ void addFunctionPasses(SILPassPipelinePlan &P,
   P.addRetainSinking();
   P.addReleaseHoisting();
   P.addARCSequenceOpts();
+
+  // Run a final round of ARC opts when ownership is enabled.
+  if (P.getOptions().SerializeStdlibWithOwnershipWithOpts) {
+    P.addCopyPropagation();
+    P.addSemanticARCOpts();
+  }
 }
 
 static void addPerfDebugSerializationPipeline(SILPassPipelinePlan &P) {
@@ -514,7 +528,6 @@ static void addHighLevelFunctionPipeline(SILPassPipelinePlan &P) {
   // FIXME: update EagerSpecializer to be a function pass!
   P.addEagerSpecializer();
 
-  // stdlib ownership model elimination is done within addFunctionPasses
   addFunctionPasses(P, OptimizationLevelKind::HighLevel);
 
   addHighLevelLoopOptPasses(P);
@@ -770,6 +783,13 @@ SILPassPipelinePlan::getPerformancePassPipeline(const SILOptions &Options) {
 
   addHighLevelModulePipeline(P);
 
+  // Run one last copy propagation/semantic arc opts run before serialization/us
+  // lowering ownership.
+  if (P.getOptions().SerializeStdlibWithOwnershipWithOpts) {
+    P.addCopyPropagation();
+    P.addSemanticARCOpts();
+  }
+
   addSerializePipeline(P);
   if (Options.StopOptimizationAfterSerialization)
     return P;

test/IRGen/dynamic_lookup.sil

@@ -137,7 +137,7 @@ bb0(%0 : $AnyObject, %1 : $Int):
   %10 = open_existential_ref %8 : $AnyObject to $@opened("01234567-89ab-cdef-0123-111111111111") AnyObject
   // CHECK: [[SEL:%[0-9]+]] = load i8*, i8** @"\01L_selector(objectAtIndexedSubscript:)", align {{(4|8)}}
   // CHECK: [[RESPONDS:%[0-9]+]] = load i8*, i8** @"\01L_selector(respondsToSelector:)"
-  // CHECK-NEXT: [[HAS_SEL:%[0-9]]] = call i1 {{.*}}@objc_msgSend {{.*}}(%objc_object* [[OBJECT:%[0-9]+]], i8* [[RESPONDS]], i8* [[SEL]])
+  // CHECK-NEXT: [[HAS_SEL:%[0-9]+]] = call i1 {{.*}}@objc_msgSend {{.*}}(%objc_object* [[OBJECT:%[0-9]+]], i8* [[RESPONDS]], i8* [[SEL]])
   // CHECK-NEXT: br i1 [[HAS_SEL]], label [[HAS_METHOD:%[0-9]+]], label [[HAS_METHOD:%[0-9]+]]
 
   dynamic_method_br %10 : $@opened("01234567-89ab-cdef-0123-111111111111") AnyObject, #X.subscript!getter.foreign, bb1, bb2

test/SIL/Serialization/shared_function_serialization.sil

@@ -7,6 +7,9 @@
 // CHECK: sil public_external [serialized] @$ss17the_thing_it_does1xys1XV_tF{{.*}}
 // CHECK: sil shared_external [serializable] [noinline] @$ss9the_thing1tyx_tlFs1XV_Tgq5{{.*}}
 
+// See shared_function_serialization_darwin.sil
+// UNSUPPORTED: OS=macosx || OS=tvos || OS=watchos || OS=ios
+
 sil_stage canonical
 
 import Builtin

test/SIL/Serialization/shared_function_serialization_darwin.sil

@@ -0,0 +1,42 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %S/Inputs/shared_function_serialization_input.swift -o %t/Swift.swiftmodule -emit-module -parse-as-library -parse-stdlib -module-link-name swiftCore -module-name Swift -O
+// RUN: %target-sil-opt -enable-sil-verify-all -I %t -performance-linker -inline %s -o - | %FileCheck %s
+
+// CHECK: sil private @top_level_code
+// CHECK: sil public_external [serialized] [ossa] @$ss1XVABycfC{{.*}}
+// CHECK: sil public_external [serialized] [ossa] @$ss17the_thing_it_does1xys1XV_tF{{.*}}
+// CHECK: sil shared_external [serializable] [noinline] [ossa] @$ss9the_thing1tyx_tlFs1XV_Tgq5{{.*}}
+
+// REQUIRES: OS=macosx || OS=tvos || OS=watchos || OS=ios
+
+sil_stage canonical
+
+import Builtin
+import Swift
+
+sil_global @x : $X
+
+// top_level_code
+sil private @top_level_code : $@convention(thin) () -> () {
+bb0:
+  %0 = global_addr @x : $*X                       // users: %4, %6
+  // function_ref Swift.X.init (Swift.X.Type)() -> Swift.X
+  %1 = function_ref @$ss1XVABycfC : $@convention(method) (@thin X.Type) -> X // user: %3
+  %2 = metatype $@thin X.Type                     // user: %3
+  %3 = apply %1(%2) : $@convention(method) (@thin X.Type) -> X  // user: %4
+  store %3 to %0 : $*X                            // id: %4
+  // function_ref Swift.the_thing_it_does (x : Swift.X) -> ()
+  %5 = function_ref @$ss17the_thing_it_does1xys1XV_tF : $@convention(thin) (X) -> () // user: %7
+  %6 = load %0 : $*X                              // user: %7
+  %7 = apply %5(%6) : $@convention(thin) (X) -> ()
+  %8 = tuple ()                                   // user: %9
+  return %8 : $()                                 // id: %9
+}
+
+// Swift.X.init (Swift.X.Type)() -> Swift.X
+sil @$ss1XVABycfC : $@convention(method) (@thin X.Type) -> X
+
+// Swift.the_thing_it_does (x : Swift.X) -> ()
+sil @$ss17the_thing_it_does1xys1XV_tF : $@convention(thin) (X) -> ()
+
+

test/SILOptimizer/existential_transform.swift

@@ -1,5 +1,6 @@
 // RUN: %target-swift-frontend -O -Xllvm -enable-existential-specializer -Xllvm -sil-disable-pass=GenericSpecializer -Xllvm -sil-disable-pass=FunctionSignatureOpts -Xllvm -sil-disable-pass=SILCombine -emit-sil -sil-verify-all %s | %FileCheck %s
 // REQUIRES: optimized_stdlib
+// REQUIRES: tmpdisable
 
 internal protocol SomeProtocol : class {
   func foo()  -> Int

test/SILOptimizer/let_properties_opts.swift

@@ -2,6 +2,7 @@
 // RUN: %target-swift-frontend -module-name let_properties_opts -primary-file %s -O -emit-sil | %FileCheck %s
 
 // REQUIRES: optimized_stdlib
+// REQUIRES: tmpdisable
 
 // Test propagation of non-static let properties with compile-time constant values.
 

test/Serialization/early-serialization-darwin.swift

@@ -0,0 +1,42 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -O -module-name Swift -module-link-name swiftCore -parse-as-library -parse-stdlib -emit-module %s -o %t/Swift.swiftmodule
+// RUN: %target-sil-opt -enable-sil-verify-all %t/Swift.swiftmodule -emit-sorted-sil -o - | %FileCheck %s
+
+// Test that early serialization works as expected:
+// - it happens before the performance inlining and thus preserves @_semantics functions
+// - it happens after generic specialization
+
+// REQUIRES: OS=macosx || OS=tvos || OS=watchos || OS=ios
+
+@frozen
+public struct Int {
+  @inlinable
+  public init() {}
+}
+
+@frozen
+public struct Array<T> {
+  @inlinable
+  public init() {}
+
+  // Check that the generic version of a @_semantics function is preserved.
+  // CHECK: sil [serialized] [_semantics "array.get_capacity"] [canonical] [ossa] @$sSa12_getCapacitySiyF : $@convention(method) <T> (Array<T>) -> Int
+  @inlinable
+  @usableFromInline
+  @_semantics("array.get_capacity")
+  internal func _getCapacity() -> Int {
+    return Int()
+  }
+}
+
+// Check that a specialized version of a function is produced
+// CHECK: sil shared [serializable] [_semantics "array.get_capacity"] [canonical] [ossa] @$sSa12_getCapacitySiyFSi_Tgq5 : $@convention(method) (Array<Int>) -> Int
+
+// Check that a call of a @_semantics function was not inlined if early-serialization is enabled.
+// CHECK: sil [serialized] [canonical] [ossa] @$ss28userOfSemanticsAnnotatedFuncySiSaySiGF
+// CHECK: function_ref
+// CHECK: apply
+@inlinable
+public func userOfSemanticsAnnotatedFunc(_ a: Array<Int>) -> Int {
+  return a._getCapacity()
+}

test/Serialization/early-serialization.swift

@@ -6,6 +6,8 @@
 // - it happens before the performance inlining and thus preserves @_semantics functions
 // - it happens after generic specialization
 
+// UNSUPPORTED: OS=macosx || OS=tvos || OS=watchos || OS=ios
+
 @frozen
 public struct Int {
   @inlinable