---

yaml
---
r: 327543
b: refs/heads/tensorflow
c: d07593b
h: refs/heads/master
i:
  327541: e8c3162
  327539: eafae43
  327535: 38da48d

Author: eeckstein

[refs]

@@ -816,7 +816,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-04-25-a: 22f738a831d43aff2b9c9773bcb65
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-05-08-a: 7d98cc16689baba5c8a3b90a9329bdcc1a12b4e9
 refs/heads/cherr42: a566ad54b073c2c56ac0a705d0a5bed9743135a5
 "refs/heads/codable_test_comment_fix": fc8f6824f7f347e1e8db55bff62db385c5728b5a
-refs/heads/tensorflow: bb1ae9c697f6f408ea0d85671e894b8a5b04cf53
+refs/heads/tensorflow: d07593b3522e9c493e7da1c6e0dfb543144ba0cc
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-11-a: 8126fd7a652e2f70ad6d76505239e34fb2ef3e1a
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-12-a: b3fd3dd84df6717f2e2e9df58c6d7e99fed57086
 refs/tags/swift-4.1-DEVELOPMENT-SNAPSHOT-2018-05-13-a: 71135119579039dc321c5f65d870050fe36efda2

branches/tensorflow/include/swift/Basic/BlotSetVector.h

@@ -64,9 +64,6 @@ class BlotSetVector {
   iterator end() { return vector.end(); }
   const_iterator begin() const { return vector.begin(); }
   const_iterator end() const { return vector.end(); }
-
-  ArrayRef<Optional<ValueT>> getArray() const { return vector; }
-
   llvm::iterator_range<const_iterator> getRange() const {
     return {begin(), end()};
   }

branches/tensorflow/lib/SILOptimizer/Mandatory/SemanticARCOpts.cpp

@@ -145,18 +145,12 @@ namespace {
 /// the worklist before we delete them.
 struct SemanticARCOptVisitor
     : SILInstructionVisitor<SemanticARCOptVisitor, bool> {
-  /// Our main worklist. We use this after an initial run through.
   SmallBlotSetVector<SILValue, 32> worklist;
-
-  /// A secondary work list that we use to store dead trivial instructions to
-  /// delete after we are done processing the worklist.
-  SmallBlotSetVector<SILInstruction *, 32> deadTrivialInsts;
-
   SILFunction &F;
   Optional<DeadEndBlocks> TheDeadEndBlocks;
-
+  
   explicit SemanticARCOptVisitor(SILFunction &F) : F(F) {}
-
+      
   DeadEndBlocks &getDeadEndBlocks() {
     if (!TheDeadEndBlocks)
       TheDeadEndBlocks.emplace(&F);
@@ -173,7 +167,7 @@ struct SemanticARCOptVisitor
 
   /// Add all operands of i to the worklist and then call eraseInstruction on
   /// i. Assumes that the instruction doesnt have users.
-  void eraseInstructionAndAddOperandsToWorklist(SILInstruction *i) {
+  void eraseInstructionAndAddOptsToWorklist(SILInstruction *i) {
     // Then copy all operands into the worklist for future processing.
     for (SILValue v : i->getOperandValues()) {
       worklist.insert(v);
@@ -190,7 +184,6 @@ struct SemanticARCOptVisitor
     for (SILValue result : i->getResults()) {
       worklist.erase(result);
     }
-    deadTrivialInsts.erase(i);
     i->eraseFromParent();
   }
 
@@ -234,7 +227,18 @@ bool SemanticARCOptVisitor::processWorklist() {
     // the instruction).
     if (auto *defInst = next->getDefiningInstruction()) {
       if (isInstructionTriviallyDead(defInst)) {
-        deadTrivialInsts.insert(defInst);
+        madeChange = true;
+        recursivelyDeleteTriviallyDeadInstructions(
+            defInst, true/*force*/,
+            [&](SILInstruction *i) {
+              for (SILValue operand : i->getOperandValues()) {
+                worklist.insert(operand);
+              }
+              for (SILValue result : i->getResults()) {
+                worklist.erase(result);
+              }
+              ++NumEliminatedInsts;
+            });
         continue;
       }
     }
@@ -247,23 +251,6 @@ bool SemanticARCOptVisitor::processWorklist() {
     }
   }
 
-  // Then eliminate the rest of the dead trivial insts.
-  //
-  // NOTE: We do not need to touch the worklist here since it is guaranteed to
-  // be empty due to the loop above. We enforce this programatically with the
-  // assert.
-  assert(worklist.empty() && "Expected drained worklist so we don't have to "
-                             "remove dead insts form it");
-  while (!deadTrivialInsts.empty()) {
-    auto val = deadTrivialInsts.pop_back_val();
-    if (!val)
-      continue;
-    recursivelyDeleteTriviallyDeadInstructions(
-        *val, true /*force*/,
-        [&](SILInstruction *i) { deadTrivialInsts.erase(i); });
-    madeChange = true;
-  }
-
   return madeChange;
 }
 
@@ -517,7 +504,7 @@ bool SemanticARCOptVisitor::eliminateDeadLiveRangeCopyValue(CopyValueInst *cvi)
   if (auto *op = cvi->getSingleUse()) {
     if (auto *dvi = dyn_cast<DestroyValueInst>(op->getUser())) {
       eraseInstruction(dvi);
-      eraseInstructionAndAddOperandsToWorklist(cvi);
+      eraseInstructionAndAddOptsToWorklist(cvi);
       NumEliminatedInsts += 2;
       return true;
     }
@@ -544,7 +531,7 @@ bool SemanticARCOptVisitor::eliminateDeadLiveRangeCopyValue(CopyValueInst *cvi)
     eraseInstruction(destroys.pop_back_val());
     ++NumEliminatedInsts;
   }
-  eraseInstructionAndAddOperandsToWorklist(cvi);
+  eraseInstructionAndAddOptsToWorklist(cvi);
   ++NumEliminatedInsts;
   return true;
 }
@@ -751,9 +738,8 @@ bool SemanticARCOptVisitor::visitLoadInst(LoadInst *li) {
   if (!isDeadLiveRange(li, destroyValues))
     return false;
 
-  // Then check if our address is ever written to. If it is, then we cannot use
-  // the load_borrow because the stored value may be released during the loaded
-  // value's live range.
+  // Then check if our address is ever written to. If it is, then we
+  // can not use the load_borrow.
   if (isWrittenTo(li))
     return false;
 

branches/tensorflow/lib/SILOptimizer/Transforms/PerformanceInliner.cpp

@@ -262,8 +262,6 @@ bool SILPerformanceInliner::isProfitableToInline(
   assert(Callee);
   bool IsGeneric = AI.hasSubstitutions();
 
-  assert(EnableSILInliningOfGenerics || !IsGeneric);
-
   // Start with a base benefit.
   int BaseBenefit = RemovedCallBenefit;
 
@@ -555,17 +553,26 @@ static Optional<bool> shouldInlineGeneric(FullApplySite AI) {
   if (Callee->getInlineStrategy() == AlwaysInline || Callee->isTransparent())
     return true;
 
-  // All other generic functions should not be inlined if this kind of inlining
-  // is disabled.
-  if (!EnableSILInliningOfGenerics)
-    return false;
-
   // If all substitutions are concrete, then there is no need to perform the
   // generic inlining. Let the generic specializer create a specialized
   // function and then decide if it is beneficial to inline it.
   if (!AI.getSubstitutionMap().hasArchetypes())
     return false;
 
+  if (Callee->getLoweredFunctionType()->getCoroutineKind() !=
+      SILCoroutineKind::None) {
+    // Co-routines are so expensive (e.g. Array.subscript.read) that we always
+    // enable inlining them in a generic context. Though the final inlining
+    // decision is done by the usual heuristics. Therefore we return None and
+    // not true.
+    return None;
+  }
+
+  // All other generic functions should not be inlined if this kind of inlining
+  // is disabled.
+  if (!EnableSILInliningOfGenerics)
+    return false;
+
   // It is not clear yet if this function should be decided or not.
   return None;
 }

branches/tensorflow/lib/SILOptimizer/Utils/PerformanceInlinerUtils.cpp

@@ -767,20 +767,16 @@ SILFunction *swift::getEligibleFunction(FullApplySite AI,
     return nullptr;
   }
 
-  if (!EnableSILInliningOfGenerics && AI.hasSubstitutions()) {
-    // Inlining of generics is not allowed unless it is an @inline(__always)
-    // or transparent function.
-    if (Callee->getInlineStrategy() != AlwaysInline && !Callee->isTransparent())
-      return nullptr;
-  }
-
   // We cannot inline function with layout constraints on its generic types
   // if the corresponding substitution type does not have the same constraints.
   // The reason for this restriction is that we'd need to be able to express
   // in SIL something like casting a value of generic type T into a value of
   // generic type T: _LayoutConstraint, which is impossible currently.
-  if (EnableSILInliningOfGenerics && AI.hasSubstitutions()) {
-    if (!isCallerAndCalleeLayoutConstraintsCompatible(AI))
+  if (AI.hasSubstitutions()) {
+    if (!isCallerAndCalleeLayoutConstraintsCompatible(AI) &&
+        // TODO: revisit why we can make an exception for inline-always
+        // functions. Some tests depend on it.
+        Callee->getInlineStrategy() != AlwaysInline && !Callee->isTransparent())
       return nullptr;
   }
 

branches/tensorflow/stdlib/public/runtime/MetadataLookup.cpp

@@ -2011,8 +2011,6 @@ void swift::gatherWrittenGenericArgs(
                              const TypeContextDescriptor *description,
                              SmallVectorImpl<const Metadata *> &allGenericArgs,
                              Demangler &BorrowFrom) {
-  if (!description)
-    return;
   auto generics = description->getGenericContext();
   if (!generics)
     return;

branches/tensorflow/test/Generics/Inputs/generic-nested-in-extension-on-objc-class.swift

@@ -0,0 +1,34 @@
+// RUN: %target-swift-frontend -parse-as-library -O -emit-sil  %s | %FileCheck %s
+// REQUIRES: swift_stdlib_no_asserts,optimized_stdlib
+
+@inline(never)
+func useit<T>(_ t: T) {
+  print(t)
+}
+
+// Check that we inline the Array.subscript.read coroutine
+
+// CHECK-LABEL: sil @{{.*}}testit
+// CHECK-NOT:     begin_apply
+// CHECK-NOT:     end_apply
+// CHECK:       } // end sil function {{.*}}testit
+public func testit<T>(_ a: [T]) {
+  for t in a {
+    useit(t)
+  }
+}
+
+// Check that we inline the ManagedBufferPointer.header.read coroutine
+
+public final class MyBuffer<Element> {
+    typealias Manager = ManagedBufferPointer<Int, Element>
+
+    // CHECK-LABEL: sil @{{.*}}MyBuffer{{.*}}countSivg
+    // CHECK-NOT:     begin_apply
+    // CHECK-NOT:     end_apply
+    // CHECK:       } // end sil function {{.*}}MyBuffer{{.*}}countSivg
+    public var count: Int {
+        return Manager(unsafeBufferObject: self).header
+    }
+}
+

branches/tensorflow/test/Generics/generic-nested-in-extension-on-objc-class.swift

@@ -1,5 +1,4 @@
 // RUN: %target-swift-frontend -enable-experimental-static-assert -emit-sil %s -verify
-// RUN: %target-swift-frontend -enable-experimental-static-assert -enable-ownership-stripping-after-serialization -emit-sil %s -verify
 
 // REQUIRES: optimized_stdlib
 // REQUIRES: asserts
@@ -68,6 +67,18 @@ 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}}
+  return a == 0 ? 0 : recursive(a: a-1)
+}
+
+func test_recursive() {
+  // expected-error @+2 {{#assert condition not constant}}
+  // expected-note @+1 {{exceeded instruction limit: 512 when evaluating the expression at compile time}}
+  #assert(recursive(a: 20000) > 42)
+}
+
 func conditional(_ x: Int) -> Int {
   if x < 0 {
     return 0

branches/tensorflow/test/SILOptimizer/inline_generic_coroutines.swift

@@ -838,21 +838,3 @@ bb0(%0 : @guaranteed $NativeObjectPair):
   apply %func(%4) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> MyNever
   unreachable
 }
-
-// Just make sure that we do not crash on this. We should be able to eliminate
-// everything here.
-//
-// CHECK-LABEL: sil [ossa] @copy_value_with_debug_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () {
-// CHECK: bb0
-// CHECK-NEXT:  tuple
-// CHECK-NEXT:  return
-// CHECK-NEXT: } // end sil function 'copy_value_with_debug_user'
-sil [ossa] @copy_value_with_debug_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () {
-bb0(%0 : @guaranteed $NativeObjectPair):
-  %1 = struct_extract %0 : $NativeObjectPair, #NativeObjectPair.obj1
-  %2 = copy_value %1 : $Builtin.NativeObject
-  debug_value %2 : $Builtin.NativeObject, let, name "myField"
-  destroy_value %2 : $Builtin.NativeObject
-  %9999 = tuple()
-  return %9999 : $()
-}