Revert "Merge pull request #26608 from gottesmm/ownership-onone-stdlibcore"

This reverts commit 4ecab47, reversing
changes made to f743c68.

Author: pschuh

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1526,71 +1526,55 @@ constantFoldGlobalStringTablePointerBuiltin(BuiltinInst *bi,
 }
 
 /// Initialize the worklist to all of the constant instructions.
-void ConstantFolder::initializeWorklist(SILFunction &f) {
-  for (auto &block : f) {
-    for (auto ii = block.begin(), ie = block.end(); ii != ie; ) {
-      auto *inst = &*ii;
-      ++ii;
-
-      // TODO: Eliminate trivially dead instructions here.
-
+void ConstantFolder::initializeWorklist(SILFunction &F) {
+  for (auto &BB : F) {
+    for (auto &I : BB) {
       // If `I` is a floating-point literal instruction where the literal is
       // inf, it means the input has a literal that overflows even
       // MaxBuiltinFloatType. Diagnose this error, but allow this instruction
       // to be folded, if needed.
-      if (auto *floatLit = dyn_cast<FloatLiteralInst>(inst)) {
+      if (auto floatLit = dyn_cast<FloatLiteralInst>(&I)) {
         APFloat fpVal = floatLit->getValue();
         if (EnableDiagnostics && fpVal.isInfinity()) {
           SmallString<10> litStr;
           tryExtractLiteralText(floatLit, litStr);
-          diagnose(inst->getModule().getASTContext(), inst->getLoc().getSourceLoc(),
+          diagnose(I.getModule().getASTContext(), I.getLoc().getSourceLoc(),
                    diag::warning_float_overflows_maxbuiltin, litStr,
                    fpVal.isNegative());
         }
       }
 
-      if (isFoldable(inst) && inst->hasUsesOfAnyResult()) {
-        WorkList.insert(inst);
+      if (isFoldable(&I) && I.hasUsesOfAnyResult()) {
+        WorkList.insert(&I);
         continue;
       }
 
       // - Should we replace calls to assert_configuration by the assert
       // configuration and fold calls to any cond_unreachable.
       if (AssertConfiguration != SILOptions::DisableReplacement &&
-          (isApplyOfBuiltin(*inst, BuiltinValueKind::AssertConf) ||
-           isApplyOfBuiltin(*inst, BuiltinValueKind::CondUnreachable))) {
-        WorkList.insert(inst);
-        continue;
-      }
-
-      if (isApplyOfBuiltin(*inst, BuiltinValueKind::GlobalStringTablePointer)) {
-        WorkList.insert(inst);
+          (isApplyOfBuiltin(I, BuiltinValueKind::AssertConf) ||
+           isApplyOfBuiltin(I, BuiltinValueKind::CondUnreachable))) {
+        WorkList.insert(&I);
         continue;
       }
 
-      if (isa<CheckedCastBranchInst>(inst) ||
-          isa<CheckedCastAddrBranchInst>(inst) ||
-          isa<UnconditionalCheckedCastInst>(inst) ||
-          isa<UnconditionalCheckedCastAddrInst>(inst)) {
-        WorkList.insert(inst);
+      if (isApplyOfBuiltin(I, BuiltinValueKind::GlobalStringTablePointer)) {
+        WorkList.insert(&I);
         continue;
       }
 
-      if (isApplyOfStringConcat(*inst)) {
-        WorkList.insert(inst);
+      if (isa<CheckedCastBranchInst>(&I) ||
+          isa<CheckedCastAddrBranchInst>(&I) ||
+          isa<UnconditionalCheckedCastInst>(&I) ||
+          isa<UnconditionalCheckedCastAddrInst>(&I)) {
+        WorkList.insert(&I);
         continue;
       }
 
-      // If we have nominal type literals like struct, tuple, enum visit them
-      // like we do in the worklist to see if we can fold any projection
-      // manipulation operations.
-      if (isa<StructInst>(inst) || isa<TupleInst>(inst)) {
-        // TODO: Enum.
-        WorkList.insert(inst);
+      if (!isApplyOfStringConcat(I)) {
         continue;
       }
-
-      // ...
+      WorkList.insert(&I);
     }
   }
 }

stdlib/public/core/CMakeLists.txt

@@ -292,8 +292,6 @@ if(SWIFT_STDLIB_ENABLE_STDLIBCORE_EXCLUSIVITY_CHECKING)
   list(APPEND swift_stdlib_compile_flags "-enforce-exclusivity=checked")
 endif()
 
-list(APPEND swift_stdlib_compile_flags "-Xfrontend" "-enable-ownership-stripping-after-serialization")
-
 if(SWIFT_CHECK_ESSENTIAL_STDLIB)
   add_swift_target_library(swift_stdlib_essential ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} IS_STDLIB IS_STDLIB_CORE
       INSTALL_IN_COMPONENT never_install

test/SILOptimizer/constant_propagation.sil

@@ -1004,23 +1004,3 @@ bb0(%0 : $Builtin.Int1):
   %9999 = tuple()
   return %9999 : $()
 }
-
-// CHECK-LABEL: sil @simplify_struct_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
-// CHECK-NOT: struct
-// CHECK: } // end sil function 'simplify_struct_test'
-sil @simplify_struct_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
-bb0(%0 : $Builtin.Int64):
-  %1 = struct $Int64 (%0 : $Builtin.Int64)
-  %2 = struct_extract %1 : $Int64, #Int64.value
-  return %2 : $Builtin.Int64
-}
-
-// CHECK-LABEL: sil @simplify_tuple_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
-// CHECK-NOT: tuple
-// CHECK: } // end sil function 'simplify_tuple_test'
-sil @simplify_tuple_test : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
-bb0(%0 : $Builtin.Int64):
-  %1 = tuple(%0 : $Builtin.Int64, %0 : $Builtin.Int64)
-  %2 = tuple_extract %1 : $(Builtin.Int64, Builtin.Int64), 0
-  return %2 : $Builtin.Int64
-}

test/SILOptimizer/pound_assert.swift

@@ -67,9 +67,8 @@ func test_loops() {
   #assert(infiniteLoop() == 1)
 }
 
-// NOTE: We currently hit the limit of 512 on a debug_value in the prelude of
-// this function. TODO: What is the right thing to do here?
-func recursive(a: Int) -> Int {  // expected-note {{limit exceeded here}}
+func recursive(a: Int) -> Int {
+   // expected-note@+1 {{limit exceeded here}}
   return a == 0 ? 0 : recursive(a: a-1)
 }