---

yaml
---
r: 349357
b: refs/heads/master-next
c: fada3bd
h: refs/heads/master
i:
  349355: c1d785e

Author: swift-ci

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: 3574c513bbc5578dd9346b4ea9ab5995c5927bb5
-refs/heads/master-next: c431f3705a8ea3b975255f209bb75dfbe2a1fe5d
+refs/heads/master-next: fada3bd80b332da46e35067350221dfb587670a7
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -1526,55 +1526,71 @@ constantFoldGlobalStringTablePointerBuiltin(BuiltinInst *bi,
 }
 
 /// Initialize the worklist to all of the constant instructions.
-void ConstantFolder::initializeWorklist(SILFunction &F) {
-  for (auto &BB : F) {
-    for (auto &I : BB) {
+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.
+
       // 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>(&I)) {
+      if (auto *floatLit = dyn_cast<FloatLiteralInst>(inst)) {
         APFloat fpVal = floatLit->getValue();
         if (EnableDiagnostics && fpVal.isInfinity()) {
           SmallString<10> litStr;
           tryExtractLiteralText(floatLit, litStr);
-          diagnose(I.getModule().getASTContext(), I.getLoc().getSourceLoc(),
+          diagnose(inst->getModule().getASTContext(), inst->getLoc().getSourceLoc(),
                    diag::warning_float_overflows_maxbuiltin, litStr,
                    fpVal.isNegative());
         }
       }
 
-      if (isFoldable(&I) && I.hasUsesOfAnyResult()) {
-        WorkList.insert(&I);
+      if (isFoldable(inst) && inst->hasUsesOfAnyResult()) {
+        WorkList.insert(inst);
         continue;
       }
 
       // - Should we replace calls to assert_configuration by the assert
       // configuration and fold calls to any cond_unreachable.
       if (AssertConfiguration != SILOptions::DisableReplacement &&
-          (isApplyOfBuiltin(I, BuiltinValueKind::AssertConf) ||
-           isApplyOfBuiltin(I, BuiltinValueKind::CondUnreachable))) {
-        WorkList.insert(&I);
+          (isApplyOfBuiltin(*inst, BuiltinValueKind::AssertConf) ||
+           isApplyOfBuiltin(*inst, BuiltinValueKind::CondUnreachable))) {
+        WorkList.insert(inst);
+        continue;
+      }
+
+      if (isApplyOfBuiltin(*inst, BuiltinValueKind::GlobalStringTablePointer)) {
+        WorkList.insert(inst);
         continue;
       }
 
-      if (isApplyOfBuiltin(I, BuiltinValueKind::GlobalStringTablePointer)) {
-        WorkList.insert(&I);
+      if (isa<CheckedCastBranchInst>(inst) ||
+          isa<CheckedCastAddrBranchInst>(inst) ||
+          isa<UnconditionalCheckedCastInst>(inst) ||
+          isa<UnconditionalCheckedCastAddrInst>(inst)) {
+        WorkList.insert(inst);
         continue;
       }
 
-      if (isa<CheckedCastBranchInst>(&I) ||
-          isa<CheckedCastAddrBranchInst>(&I) ||
-          isa<UnconditionalCheckedCastInst>(&I) ||
-          isa<UnconditionalCheckedCastAddrInst>(&I)) {
-        WorkList.insert(&I);
+      if (isApplyOfStringConcat(*inst)) {
+        WorkList.insert(inst);
         continue;
       }
 
-      if (!isApplyOfStringConcat(I)) {
+      // 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);
         continue;
       }
-      WorkList.insert(&I);
+
+      // ...
     }
   }
 }

branches/master-next/stdlib/public/core/CMakeLists.txt

@@ -288,6 +288,8 @@ 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

branches/master-next/test/SILOptimizer/constant_propagation.sil

@@ -1004,3 +1004,23 @@ 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
+}

branches/master-next/test/SILOptimizer/pound_assert.swift

@@ -67,8 +67,9 @@ func test_loops() {
   #assert(infiniteLoop() == 1)
 }
 
-func recursive(a: Int) -> Int {
-   // expected-note@+1 {{limit exceeded here}}
+// 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}}
   return a == 0 ? 0 : recursive(a: a-1)
 }