---

yaml
---
r: 319199
b: refs/heads/master-rebranch
c: e371ca2
h: refs/heads/master
i:
  319197: 8a70f4f
  319195: fc4eb3a
  319191: f5175b8
  319183: 312805b
  319167: a8d391d

Author: swift-ci

[refs]

@@ -1457,4 +1457,4 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-02-a: ddd2b2976aa9bfde5f20fe37f6bd2
 refs/tags/swift-DEVELOPMENT-SNAPSHOT-2019-08-03-a: 171cc166f2abeb5ca2a4003700a8a78a108bd300
 refs/heads/benlangmuir-patch-1: baaebaf39d52f3bf36710d4fe40cf212e996b212
 refs/heads/i-do-redeclare: 8c4e6d5de5c1e3f0a2cedccf319df713ea22c48e
-refs/heads/master-rebranch: 35623242dc9289b3d7b088af5df0a3f31bc83d88
+refs/heads/master-rebranch: e371ca2296ca82dc089693dd8ff5eb2f3ad3a79d

branches/master-rebranch/include/swift/AST/DiagnosticsSIL.def

@@ -395,6 +395,13 @@ NOTE(constexpr_witness_call_with_no_target_found, none,
 NOTE(constexpr_witness_call_found_here, none,
     "witness method call found here", ())
 
+NOTE(constexpr_unknown_control_flow_due_to_skip,none, "branch depends on "
+     "non-constant value produced by an unevaluated instructions", ())
+NOTE(constexpr_returned_by_unevaluated_instruction,none,
+     "return value of an unevaluated instruction is not a constant", ())
+NOTE(constexpr_mutated_by_unevaluated_instruction,none, "value mutable by an "
+    "unevaluated instruction is not a constant", ())
+
 ERROR(non_physical_addressof,none,
       "addressof only works with purely physical lvalues; "
       "use `withUnsafePointer` or `withUnsafeBytes` unless you're implementing "

branches/master-rebranch/include/swift/SIL/SILConstants.h

@@ -90,6 +90,14 @@ enum class UnknownReason {
   /// A top-level value has multiple writers. This is only relevant in the
   /// non-flow-sensitive evaluation mode,  which is used by #assert.
   MutipleTopLevelWriters,
+
+  /// Indicates the return value of an instruction that was not evaluated during
+  /// interpretation.
+  ReturnedByUnevaluatedInstruction,
+
+  /// Indicates that the value was possibly modified by an instruction
+  /// that was not evaluated during the interpretation.
+  MutatedByUnevaluatedInstruction,
 };
 
 /// An abstract class that exposes functions for allocating symbolic values.
@@ -416,6 +424,8 @@ class SymbolicValue {
   /// reason, we fall back to using the specified location.
   void emitUnknownDiagnosticNotes(SILLocation fallbackLoc);
 
+  bool isUnknownDueToUnevaluatedInstructions();
+
   /// Clone this SymbolicValue into the specified Allocator and return the new
   /// version. This only works for valid constants.
   SymbolicValue cloneInto(SymbolicValueAllocator &allocator) const;

branches/master-rebranch/include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -85,6 +85,8 @@ class ConstExprEvaluator {
 
 /// A constant-expression evaluator that can be used to step through a control
 /// flow graph (SILFunction body) by evaluating one instruction at a time.
+/// This evaluator can also "skip" instructions without evaluating them and
+/// only track constant values of variables whose values could be computed.
 class ConstExprStepEvaluator {
 private:
   ConstExprEvaluator evaluator;
@@ -97,10 +99,6 @@ class ConstExprStepEvaluator {
   /// evaluation.
   SmallPtrSet<SILBasicBlock *, 8> visitedBlocks;
 
-  Optional<SymbolicValue>
-  incrementStepsAndCheckLimit(SILInstruction *inst,
-                              bool includeInInstructionLimit);
-
   ConstExprStepEvaluator(const ConstExprEvaluator &) = delete;
   void operator=(const ConstExprEvaluator &) = delete;
 
@@ -122,12 +120,61 @@ class ConstExprStepEvaluator {
   ///   Second element is None, if the evaluation is successful.
   ///   Otherwise, is an unknown symbolic value that contains the error.
   std::pair<Optional<SILBasicBlock::iterator>, Optional<SymbolicValue>>
-  evaluate(SILBasicBlock::iterator instI,
-           bool includeInInstructionLimit = true);
+  evaluate(SILBasicBlock::iterator instI);
+
+  /// Skip the instruction without evaluating it and conservatively account for
+  /// the effects of the instruction on the internal state. This operation
+  /// resets to an unknown symbolic value any portion of a
+  /// SymbolicValueMemoryObject that could possibly be mutated by the given
+  /// instruction. This function preserves the soundness of the interpretation.
+  /// \param instI instruction to be skipped.
+  /// \returns a pair where the first and second elements are defined as
+  /// follows:
+  ///   The first element, if is not None, is the iterator to the next
+  ///   instruction from the where the evaluation must continue.
+  ///   The first element is None if the next instruction from where the
+  ///   evaluation must continue cannot be determined.
+  ///   This would be the case if `instI` is a branch like a `condbr`.
+  ///
+  ///   Second element is None if skipping the instruction is successful.
+  ///   Otherwise, it is an unknown symbolic value containing the error.
+  std::pair<Optional<SILBasicBlock::iterator>, Optional<SymbolicValue>>
+  skipByMakingEffectsNonConstant(SILBasicBlock::iterator instI);
+
+  /// Try evaluating an instruction and if the evaluation fails, skip the
+  /// instruction and make it effects non constant. Note that it may not always
+  /// be possible to skip an instruction whose evaluation failed and
+  /// continue evalution (e.g. a conditional branch).
+  /// See `evaluate` and `skipByMakingEffectsNonConstant` functions for their
+  /// semantics.
+  /// \param instI instruction to be evaluated in the current interpreter state.
+  /// \returns a pair where the first and second elements are defined as
+  /// follows:
+  ///   The first element, if is not None, is the iterator to the next
+  ///   instruction from the where the evaluation must continue.
+  ///   The first element is None iff both `evaluate` and `skip` functions
+  ///   failed to determine the next instruction to continue evaluation from.
+  ///
+  ///   Second element is None if the evaluation is successful.
+  ///   Otherwise, it is an unknown symbolic value containing the error.
+  std::pair<Optional<SILBasicBlock::iterator>, Optional<SymbolicValue>>
+  tryEvaluateOrElseMakeEffectsNonConstant(SILBasicBlock::iterator instI);
 
   Optional<SymbolicValue> lookupConstValue(SILValue value);
 
   bool isKnownFunction(SILFunction *fun);
+
+  /// Returns true if and only if `errorVal` denotes an error that requires
+  /// aborting interpretation and returning the error. Skipping an instruction
+  /// that produces such errors is not a valid behavior.
+  bool isFailStopError(SymbolicValue errorVal);
+
+  /// Return the number of instructions evaluated for the last `evaluate`
+  /// operation. This could be used by the clients to limit the number of
+  /// instructions that should be evaluated by the step-wise evaluator.
+  /// Note that 'skipByMakingEffectsNonConstant' operation is not considered
+  /// as an evaluation.
+  unsigned instructionsEvaluatedByLastEvaluation() { return stepsEvaluated; }
 };
 
 } // end namespace swift

branches/master-rebranch/lib/SIL/SILConstants.cpp

@@ -568,6 +568,12 @@ SymbolicValue SymbolicValue::lookThroughSingleElementAggregates() const {
   }
 }
 
+bool SymbolicValue::isUnknownDueToUnevaluatedInstructions() {
+  auto unknownReason = getUnknownReason();
+  return (unknownReason == UnknownReason::ReturnedByUnevaluatedInstruction ||
+          unknownReason == UnknownReason::MutatedByUnevaluatedInstruction);
+}
+
 /// Given that this is an 'Unknown' value, emit diagnostic notes providing
 /// context about what the problem is. Specifically, point to interesting
 /// source locations and function calls in the call stack.
@@ -676,6 +682,12 @@ void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
     if (emitTriggerLocInDiag)
       diagnose(ctx, *triggerLoc, diag::constexpr_witness_call_found_here);
     return;
+  case UnknownReason::ReturnedByUnevaluatedInstruction:
+    diagnose(ctx, diagLoc, diag::constexpr_returned_by_unevaluated_instruction);
+    break;
+  case UnknownReason::MutatedByUnevaluatedInstruction:
+    diagnose(ctx, diagLoc, diag::constexpr_mutated_by_unevaluated_instruction);
+    break;
   }
   // TODO: print the call-stack in a controlled way if needed.
 }

branches/master-rebranch/lib/SILOptimizer/UtilityPasses/ConstantEvaluatorTester.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #define DEBUG_TYPE "sil-constant-evaluation-tester"
+#include "swift/AST/DiagnosticsSIL.h"
 #include "swift/SIL/SILConstants.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
@@ -20,6 +21,12 @@ using namespace swift;
 
 namespace {
 
+template <typename... T, typename... U>
+static InFlightDiagnostic diagnose(ASTContext &Context, SourceLoc loc,
+                                   Diag<T...> diag, U &&... args) {
+  return Context.Diags.diagnose(loc, diag, std::forward<U>(args)...);
+}
+
 /// A compiler pass for testing constant evaluator in the step-wise evaluation
 /// mode. The pass evaluates SIL functions whose names start with "interpret"
 /// and outputs the constant value returned by the function or diagnostics if
@@ -31,6 +38,18 @@ class ConstantEvaluatorTester : public SILFunctionTransform {
     return fun->getName().startswith("interpret");
   }
 
+  bool shouldSkipInstruction(SILInstruction *inst) {
+    auto *applyInst = dyn_cast<ApplyInst>(inst);
+    if (!applyInst)
+      return false;
+
+    auto *callee = applyInst->getReferencedFunction();
+    if (!callee)
+      return false;
+
+    return callee->getName().startswith("skip");
+  }
+
   void run() override {
     SILFunction *fun = getFunction();
 
@@ -52,6 +71,7 @@ class ConstantEvaluatorTester : public SILFunctionTransform {
         if (!returnVal) {
           llvm::errs() << "Returns unknown"
                        << "\n";
+          break;
         }
         llvm::errs() << "Returns " << returnVal.getValue() << "\n";
         break;
@@ -60,15 +80,33 @@ class ConstantEvaluatorTester : public SILFunctionTransform {
       Optional<SILBasicBlock::iterator> nextInstOpt;
       Optional<SymbolicValue> errorVal;
 
-      std::tie(nextInstOpt, errorVal) = stepEvaluator.evaluate(currI);
-      if (errorVal.hasValue()) {
-        // Diagnose the error.
-        assert(errorVal->getKind() == SymbolicValue::Unknown);
+      // If the instruction is marked as skip, skip it and make its effects
+      // non-constant. Otherwise, try evaluating the instruction and if the
+      // evaluation fails due to a previously skipped instruction,
+      // skip the current instruction.
+      if (shouldSkipInstruction(inst)) {
+        std::tie(nextInstOpt, errorVal) =
+            stepEvaluator.skipByMakingEffectsNonConstant(currI);
+      } else {
+        std::tie(nextInstOpt, errorVal) =
+            stepEvaluator.tryEvaluateOrElseMakeEffectsNonConstant(currI);
+      }
+
+      // Diagnose errors in the evaluation. Unknown symbolic values produced
+      // by skipping instructions are not considered errors.
+      if (errorVal.hasValue() &&
+          !errorVal->isUnknownDueToUnevaluatedInstructions()) {
+        errorVal->emitUnknownDiagnosticNotes(inst->getLoc());
+        break;
+      }
+
+      if (!nextInstOpt) {
+        diagnose(fun->getASTContext(), inst->getLoc().getSourceLoc(),
+                 diag::constexpr_unknown_control_flow_due_to_skip);
         errorVal->emitUnknownDiagnosticNotes(inst->getLoc());
         break;
       }
 
-      assert(nextInstOpt);
       currI = nextInstOpt.getValue();
     }
   }