---

yaml
---
r: 327539
b: refs/heads/tensorflow
c: 8e11010
h: refs/heads/master
i:
  327537: e3a530a
  327535: 38da48d

Author: gottesmm

[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: 0673530b5e6485aefb9c622bfd7a50c39b988d2e
+refs/heads/tensorflow: 8e110108d33c8eb24c974d180791c1e57f6d15ed
 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,6 +64,9 @@ 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/include/swift/SIL/SILInstructionWorklist.h

@@ -151,19 +151,17 @@ class SILInstructionWorklist : SILInstructionWorklistBase {
   /// \return whether the instruction was deleted or modified.
   bool replaceInstructionWithInstruction(SILInstruction *instruction,
                                          SILInstruction *result
-#ifndef NDEBUG
+#ifndef NDNEBUG
                                          ,
                                          std::string instructionDescription
 #endif
   ) {
     if (result == instruction) {
-#ifndef NDEBUG
       withDebugStream([&](llvm::raw_ostream &stream, StringRef loggingName) {
         stream << loggingName << ": Mod = " << instructionDescription << '\n'
                << "  "
                << "  New = " << *instruction << '\n';
       });
-#endif
 
       // If the instruction was modified, it's possible that it is now dead.
       // if so, remove it.

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

@@ -39,23 +39,6 @@
 
 using namespace swift;
 
-//===----------------------------------------------------------------------===//
-//                                  Utility
-//===----------------------------------------------------------------------===//
-
-/// \returns whether all the values are of trivial type in the provided
-///          function.
-template <typename Values>
-static bool areAllValuesTrivial(Values values, SILFunction &function) {
-  return llvm::all_of(values, [&](SILValue value) -> bool {
-    return value->getType().isTrivial(function);
-  });
-}
-
-//===----------------------------------------------------------------------===//
-//                        MandatoryCombiner Interface
-//===----------------------------------------------------------------------===//
-
 namespace {
 
 class MandatoryCombiner final
@@ -88,186 +71,182 @@ class MandatoryCombiner final
             [&](SILInstruction *instruction) { worklist.add(instruction); }),
         createdInstructions(createdInstructions){};
 
-  void addReachableCodeToWorklist(SILFunction &function);
-
-  /// \return whether a change was made.
-  bool doOneIteration(SILFunction &function, unsigned iteration);
+  /// Base visitor that does not do anything.
+  SILInstruction *visitSILInstruction(SILInstruction *) { return nullptr; }
 
-  void clear() {
-    iteration = 0;
-    worklist.resetChecked();
-    madeChange = false;
+  /// \returns whether all the values are of trivial type in the provided
+  ///          function.
+  template <typename Values>
+  static bool areAllValuesTrivial(Values values, SILFunction &function) {
+    return llvm::all_of(values, [&](SILValue value) -> bool {
+      return value->getType().isTrivial(function);
+    });
   }
 
-  /// Applies the MandatoryCombiner to the provided function.
-  ///
-  /// \param function the function to which to apply the MandatoryCombiner.
-  ///
-  /// \return whether a change was made.
-  bool runOnFunction(SILFunction &function) {
-    bool changed = false;
-
-    while (doOneIteration(function, iteration)) {
-      changed = true;
-      ++iteration;
+  SILInstruction *visitApplyInst(ApplyInst *instruction) {
+    // Apply this pass only to partial applies all of whose arguments are
+    // trivial.
+    auto calledValue = instruction->getCallee();
+    if (calledValue == nullptr) {
+      return nullptr;
+    }
+    auto fullApplyCallee = calledValue->getDefiningInstruction();
+    if (fullApplyCallee == nullptr) {
+      return nullptr;
+    }
+    auto partialApply = dyn_cast<PartialApplyInst>(fullApplyCallee);
+    if (partialApply == nullptr) {
+      return nullptr;
+    }
+    auto *function = partialApply->getCalleeFunction();
+    if (function == nullptr) {
+      return nullptr;
+    }
+    ApplySite fullApplySite(instruction);
+    auto fullApplyArguments = fullApplySite.getArguments();
+    if (!areAllValuesTrivial(fullApplyArguments, *function)) {
+      return nullptr;
+    }
+    auto partialApplyArguments = ApplySite(partialApply).getArguments();
+    if (!areAllValuesTrivial(partialApplyArguments, *function)) {
+      return nullptr;
     }
 
-    return changed;
-  }
+    auto callee = partialApply->getCallee();
 
-  /// Base visitor that does not do anything.
-  SILInstruction *visitSILInstruction(SILInstruction *) { return nullptr; }
-  SILInstruction *visitApplyInst(ApplyInst *instruction);
-};
+    ApplySite partialApplySite(partialApply);
 
-} // end anonymous namespace
+    SmallVector<SILValue, 8> argsVec;
+    llvm::copy(fullApplyArguments, std::back_inserter(argsVec));
+    llvm::copy(partialApplyArguments, std::back_inserter(argsVec));
 
-//===----------------------------------------------------------------------===//
-//               MandatoryCombiner Non-Visitor Utility Methods
-//===----------------------------------------------------------------------===//
+    SILBuilderWithScope builder(instruction, &createdInstructions);
+    ApplyInst *replacement = builder.createApply(
+        /*Loc=*/instruction->getDebugLocation().getLocation(), /*Fn=*/callee,
+        /*Subs=*/partialApply->getSubstitutionMap(),
+        /*Args*/ argsVec,
+        /*isNonThrowing=*/instruction->isNonThrowing(),
+        /*SpecializationInfo=*/partialApply->getSpecializationInfo());
 
-void MandatoryCombiner::addReachableCodeToWorklist(SILFunction &function) {
-  SmallBlotSetVector<SILBasicBlock *, 32> blockWorklist;
-  SmallBlotSetVector<SILBasicBlock *, 32> blocksVisited;
-  SmallVector<SILInstruction *, 128> instructions;
-
-  blockWorklist.insert(&*function.begin());
-  while (!blockWorklist.empty()) {
-    auto *block = blockWorklist.pop_back_val().getValueOr(nullptr);
-    if (block == nullptr) {
-      continue;
-    }
+    worklist.replaceInstructionWithInstruction(instruction, replacement
+#ifndef NDEBUG
+                                               ,
+                                               /*instructionDescription=*/""
+#endif
+    );
+    tryDeleteDeadClosure(partialApply, instModCallbacks);
+    return nullptr;
+  }
 
-    if (!blocksVisited.insert(block).second) {
-      continue;
-    }
+  void addReachableCodeToWorklist(SILFunction &function) {
+    SmallBlotSetVector<SILBasicBlock *, 32> blockWorklist;
+    SmallBlotSetVector<SILBasicBlock *, 32> blocksVisited;
+    SmallVector<SILInstruction *, 128> instructions;
 
-    for (auto iterator = block->begin(), end = block->end(); iterator != end;) {
-      auto *instruction = &*iterator;
-      ++iterator;
+    blockWorklist.insert(&*function.begin());
+    while (!blockWorklist.empty()) {
+      auto *block = blockWorklist.pop_back_val().getValueOr(nullptr);
+      if (block == nullptr) {
+        continue;
+      }
 
-      if (isInstructionTriviallyDead(instruction)) {
+      if (!blocksVisited.insert(block).second) {
         continue;
       }
 
-      instructions.push_back(instruction);
+      for (auto iterator = block->begin(), end = block->end(); iterator != end;) {
+        auto *instruction = &*iterator;
+        ++iterator;
+
+        if (isInstructionTriviallyDead(instruction)) {
+          continue;
+        }
+
+        instructions.push_back(instruction);
+      }
+
+      for_each(block->getSuccessorBlocks(), [&](SILBasicBlock *block) {
+        blockWorklist.insert(block);
+      });
     }
 
-    for_each(block->getSuccessorBlocks(),
-             [&](SILBasicBlock *block) { blockWorklist.insert(block); });
+    worklist.addInitialGroup(instructions);
   }
 
-  worklist.addInitialGroup(instructions);
-}
-
-bool MandatoryCombiner::doOneIteration(SILFunction &function,
-                                       unsigned iteration) {
-  madeChange = false;
+  /// \return whether a change was made.
+  bool doOneIteration(SILFunction &function, unsigned iteration) {
+    madeChange = false;
 
-  addReachableCodeToWorklist(function);
+    addReachableCodeToWorklist(function);
 
-  while (!worklist.isEmpty()) {
-    auto *instruction = worklist.pop_back_val();
-    if (instruction == nullptr) {
-      continue;
-    }
+    while (!worklist.isEmpty()) {
+      auto *instruction = worklist.pop_back_val();
+      if (instruction == nullptr) {
+        continue;
+      }
 
 #ifndef NDEBUG
-    std::string instructionDescription;
+      std::string instructionDescription;
 #endif
-    LLVM_DEBUG(llvm::raw_string_ostream SS(instructionDescription);
-               instruction->print(SS); instructionDescription = SS.str(););
-    LLVM_DEBUG(llvm::dbgs()
-               << "MC: Visiting: " << instructionDescription << '\n');
+      LLVM_DEBUG(llvm::raw_string_ostream SS(instructionDescription);
+                 instruction->print(SS); instructionDescription = SS.str(););
+      LLVM_DEBUG(llvm::dbgs()
+                 << "MC: Visiting: " << instructionDescription << '\n');
 
-    if (auto replacement = visit(instruction)) {
-      worklist.replaceInstructionWithInstruction(instruction, replacement
+      if (auto replacement = visit(instruction)) {
+        worklist.replaceInstructionWithInstruction(instruction, replacement
 #ifndef NDEBUG
-                                                 ,
-                                                 instructionDescription
+            , instructionDescription
 #endif
-      );
-    }
+          );
+      }
 
-    for (SILInstruction *instruction : instructionsPendingDeletion) {
-      worklist.eraseInstFromFunction(*instruction);
-    }
-    instructionsPendingDeletion.clear();
-
-    // Our tracking list has been accumulating instructions created by the
-    // SILBuilder during this iteration. Go through the tracking list and add
-    // its contents to the worklist and then clear said list in preparation
-    // for the next iteration.
-    for (SILInstruction *instruction : createdInstructions) {
-      LLVM_DEBUG(llvm::dbgs() << "MC: add " << *instruction
-                              << " from tracking list to worklist\n");
-      worklist.add(instruction);
+      for (SILInstruction *instruction : instructionsPendingDeletion) {
+        worklist.eraseInstFromFunction(*instruction);
+      }
+      instructionsPendingDeletion.clear();
+
+      // Our tracking list has been accumulating instructions created by the
+      // SILBuilder during this iteration. Go through the tracking list and add
+      // its contents to the worklist and then clear said list in preparation
+      // for the next iteration.
+      for (SILInstruction *instruction : createdInstructions) {
+        LLVM_DEBUG(llvm::dbgs() << "MC: add " << *instruction
+                                << " from tracking list to worklist\n");
+        worklist.add(instruction);
+      }
+      createdInstructions.clear();
     }
-    createdInstructions.clear();
-  }
-
-  worklist.resetChecked();
-  return madeChange;
-}
 
-//===----------------------------------------------------------------------===//
-//                     MandatoryCombiner Visitor Methods
-//===----------------------------------------------------------------------===//
-
-SILInstruction *MandatoryCombiner::visitApplyInst(ApplyInst *instruction) {
-  // Apply this pass only to partial applies all of whose arguments are
-  // trivial.
-  auto calledValue = instruction->getCallee();
-  if (calledValue == nullptr) {
-    return nullptr;
-  }
-  auto fullApplyCallee = calledValue->getDefiningInstruction();
-  if (fullApplyCallee == nullptr) {
-    return nullptr;
-  }
-  auto partialApply = dyn_cast<PartialApplyInst>(fullApplyCallee);
-  if (partialApply == nullptr) {
-    return nullptr;
-  }
-  auto *function = partialApply->getCalleeFunction();
-  if (function == nullptr) {
-    return nullptr;
-  }
-  ApplySite fullApplySite(instruction);
-  auto fullApplyArguments = fullApplySite.getArguments();
-  if (!areAllValuesTrivial(fullApplyArguments, *function)) {
-    return nullptr;
+    worklist.resetChecked();
+    return madeChange;
   }
-  auto partialApplyArguments = ApplySite(partialApply).getArguments();
-  if (!areAllValuesTrivial(partialApplyArguments, *function)) {
-    return nullptr;
+
+  void clear() {
+    iteration = 0;
+    worklist.resetChecked();
+    madeChange = false;
   }
 
-  auto callee = partialApply->getCallee();
 
-  ApplySite partialApplySite(partialApply);
+  /// Applies the MandatoryCombiner to the provided function.
+  ///
+  /// \param function the function to which to apply the MandatoryCombiner.
+  ///
+  /// \return whether a change was made.
+  bool runOnFunction(SILFunction &function) {
+    bool changed = false;
 
-  SmallVector<SILValue, 8> argsVec;
-  llvm::copy(fullApplyArguments, std::back_inserter(argsVec));
-  llvm::copy(partialApplyArguments, std::back_inserter(argsVec));
+    while (doOneIteration(function, iteration)) {
+      changed = true;
+      ++iteration;
+    }
 
-  SILBuilderWithScope builder(instruction, &createdInstructions);
-  ApplyInst *replacement = builder.createApply(
-      /*Loc=*/instruction->getDebugLocation().getLocation(), /*Fn=*/callee,
-      /*Subs=*/partialApply->getSubstitutionMap(),
-      /*Args*/ argsVec,
-      /*isNonThrowing=*/instruction->isNonThrowing(),
-      /*SpecializationInfo=*/partialApply->getSpecializationInfo());
+    return changed;
+  }
+};
 
-  worklist.replaceInstructionWithInstruction(instruction, replacement
-#ifndef NDEBUG
-                                             ,
-                                             /*instructionDescription=*/""
-#endif
-  );
-  tryDeleteDeadClosure(partialApply, instModCallbacks);
-  return nullptr;
-}
+} // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 //                            Top Level Entrypoint