---

yaml
---
r: 347629
b: refs/heads/master
c: 178406c
h: refs/heads/master
i:
  347627: 0e9a280

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 0e60b633b58e48c255912dec1fb0356d6cb42d49
+refs/heads/master: 178406c9c2eff4787bc712370ca7e0c5a4bde455
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/DiagnosticsSIL.def

@@ -339,16 +339,57 @@ ERROR(pound_assert_condition_not_constant,none,
 ERROR(pound_assert_failure,none,
        "%0", (StringRef))
 
-NOTE(constexpr_unknown_reason_default,none, "could not fold operation", ())
+NOTE(constexpr_unknown_reason_default,none,
+    "cannot evaluate expression as constant here", ())
+NOTE(constexpr_unevaluable_operation,none,
+    "cannot constant evaluate operation", ())
+
 NOTE(constexpr_too_many_instructions,none,
-     "exceeded instruction limit: %0 when evaluating the expression at compile "
-     "time", (unsigned))
-NOTE(constexpr_loop,none, "control flow loop found", ())
+     "exceeded instruction limit: %0 when evaluating the expression "
+     "at compile time", (unsigned))
+NOTE(constexpr_limit_exceeding_instruction,none, "limit exceeded here", ())
+
+NOTE(constexpr_loop_found_note,none,
+    "control-flow loop found during evaluation ", ())
+NOTE(constexpr_loop_instruction,none, "found loop here", ())
+
 NOTE(constexpr_overflow,none, "integer overflow detected", ())
+NOTE(constexpr_overflow_operation,none, "operation overflows", ())
+
 NOTE(constexpr_trap,none, "trap detected", ())
-NOTE(constexpr_called_from,none, "when called from here", ())
-NOTE(constexpr_not_evaluable,none,
-     "expression not evaluable as constant here", ())
+NOTE(constexpr_trap_operation,none, "operation traps", ())
+
+NOTE(constexpr_invalid_operand_seen, none,
+    "operation with invalid operands encountered during evaluation",())
+NOTE(constexpr_operand_invalid_here, none,
+    "operation with invalid operands encountered here",())
+
+NOTE(constexpr_value_unknown_at_top_level,none,
+    "cannot evaluate top-level value as constant here",())
+NOTE(constexpr_multiple_writers_found_at_top_level,none,
+     "top-level value has multiple assignments",())
+
+NOTE(constexpr_unsupported_instruction_found, none,
+    "encountered operation not supported by the evaluator", ())
+NOTE(constexpr_unsupported_instruction_found_here,none,
+    "operation not supported by the evaluator", ())
+
+NOTE(constexpr_unknown_function_called, none,
+    "encountered call to a function whose body is not available", ())
+NOTE(constexpr_unknown_function_called_here, none,
+    "call to a function whose body is not available", ())
+
+NOTE(constexpr_untracked_sil_value_use_found, none,
+    "encountered use of a variable not tracked by the evaluator", ())
+NOTE(constexpr_untracked_sil_value_used_here, none,
+    "untracked variable used here", ())
+
+NOTE(constexpr_witness_call_with_no_conformance_found, none,
+    "cannot find concrete conformance for a witness method call", ())
+NOTE(constexpr_witness_call_with_no_target_found, none,
+    "cannot resolve a witness method call to a concrete function", ())
+NOTE(constexpr_witness_call_found_here, none,
+    "witness method call found here", ())
 
 ERROR(non_physical_addressof,none,
       "addressof only works with purely physical lvalues; "

trunk/include/swift/SIL/SILConstants.h

@@ -58,6 +58,38 @@ enum class UnknownReason {
 
   /// Unspecified trap detected.
   Trap,
+
+  /// An operation was applied over operands whose symbolic values were
+  /// constants but were not valid for the operation.
+  InvalidOperandValue,
+
+  /// Encountered an instruction not supported by the interpreter.
+  UnsupportedInstruction,
+
+  /// Encountered a function call where the body of the called function is
+  /// not available.
+  CalleeImplementationUnknown,
+
+  /// Attempted to load from/store into a SIL value that was not tracked by
+  /// the interpreter.
+  UntrackedSILValue,
+
+  /// Attempted to find a concrete protocol conformance for a witness method
+  /// and failed.
+  UnknownWitnessMethodConformance,
+
+  /// Attempted to determine the SIL function of a witness method (based on a
+  /// concrete protocol conformance) and failed.
+  UnresolvableWitnessMethod,
+
+  /// The value of a top-level variable cannot be determined to be a constant.
+  /// This is only relevant in the backward evaluation mode, which is used by
+  /// #assert.
+  NotTopLevelConstant,
+
+  /// A top-level value has multiple writers. This is only relevant in the
+  /// non-flow-sensitive evaluation mode,  which is used by #assert.
+  MutipleTopLevelWriters,
 };
 
 /// An abstract class that exposes functions for allocating symbolic values.

trunk/include/swift/SILOptimizer/PassManager/Passes.def

@@ -110,6 +110,8 @@ PASS(ComputeLoopInfo, "compute-loop-info",
      "Compute Loop Information for Testing")
 PASS(ConditionForwarding, "condition-forwarding",
      "Conditional Branch Forwarding to Fold SIL switch_enum")
+PASS(ConstantEvaluatorTester, "test-constant-evaluator",
+      "Test constant evaluator")
 PASS(CopyForwarding, "copy-forwarding",
      "Copy Forwarding to Remove Redundant Copies")
 PASS(CopyPropagation, "copy-propagation",

trunk/include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -26,17 +26,18 @@
 
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceLoc.h"
+#include "swift/SIL/SILBasicBlock.h"
+#include "llvm/ADT/SmallPtrSet.h"
 
 namespace swift {
-class ApplyInst;
 class ASTContext;
 class Operand;
-class SILInstruction;
+class SILFunction;
 class SILModule;
 class SILNode;
-class SILValue;
 class SymbolicValue;
 class SymbolicValueAllocator;
+class ConstExprFunctionState;
 enum class UnknownReason;
 
 /// This class is the main entrypoint for evaluating constant expressions.  It
@@ -47,13 +48,14 @@ class ConstExprEvaluator {
   /// The current call stack, used for providing accurate diagnostics.
   llvm::SmallVector<SourceLoc, 4> callStack;
 
-  ConstExprEvaluator(const ConstExprEvaluator &) = delete;
   void operator=(const ConstExprEvaluator &) = delete;
 
 public:
   explicit ConstExprEvaluator(SymbolicValueAllocator &alloc);
   ~ConstExprEvaluator();
 
+  explicit ConstExprEvaluator(const ConstExprEvaluator &other);
+
   SymbolicValueAllocator &getAllocator() { return allocator; }
 
   void pushCallStack(SourceLoc loc) { callStack.push_back(loc); }
@@ -81,5 +83,52 @@ class ConstExprEvaluator {
                              SmallVectorImpl<SymbolicValue> &results);
 };
 
+/// A constant-expression evaluator that can be used to step through a control
+/// flow graph (SILFunction body) by evaluating one instruction at a time.
+class ConstExprStepEvaluator {
+private:
+  ConstExprEvaluator evaluator;
+
+  ConstExprFunctionState *internalState;
+
+  unsigned stepsEvaluated = 0;
+
+  /// Targets of branches that were visited. This is used to detect loops during
+  /// evaluation.
+  SmallPtrSet<SILBasicBlock *, 8> visitedBlocks;
+
+  Optional<SymbolicValue>
+  incrementStepsAndCheckLimit(SILInstruction *inst,
+                              bool includeInInstructionLimit);
+
+  ConstExprStepEvaluator(const ConstExprEvaluator &) = delete;
+  void operator=(const ConstExprEvaluator &) = delete;
+
+public:
+  /// Constructs a step evaluator given an allocator and a non-null pointer to a
+  /// SILFunction.
+  explicit ConstExprStepEvaluator(SymbolicValueAllocator &alloc,
+                                  SILFunction *fun);
+  ~ConstExprStepEvaluator();
+
+  /// Evaluate an instruction in the current interpreter state.
+  /// \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 is the iterator to the next instruction from where
+  ///   the evaluation can continue, if the evaluation is successful.
+  ///   Otherwise, it is None.
+  ///
+  ///   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);
+
+  Optional<SymbolicValue> lookupConstValue(SILValue value);
+
+  bool isKnownFunction(SILFunction *fun);
+};
+
 } // end namespace swift
 #endif

trunk/lib/SIL/SILConstants.cpp

@@ -14,6 +14,7 @@
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/Demangling/Demangle.h"
 #include "swift/SIL/SILBuilder.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/Support/TrailingObjects.h"
 using namespace swift;
 
@@ -567,74 +568,116 @@ SymbolicValue SymbolicValue::lookThroughSingleElementAggregates() const {
   }
 }
 
-/// Emits an explanatory note if there is useful information to note or if there
-/// is an interesting SourceLoc to point at.
-/// Returns true if a diagnostic was emitted.
-static bool emitNoteDiagnostic(SILInstruction *badInst, UnknownReason reason,
-                               SILLocation fallbackLoc) {
-  auto loc = skipInternalLocations(badInst->getDebugLocation()).getLocation();
-  if (loc.isNull()) {
-    // If we have important clarifying information, make sure to emit it.
-    if (reason == UnknownReason::Default || fallbackLoc.isNull())
-      return false;
-    loc = fallbackLoc;
+/// 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.
+void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
+  auto unknownNode = getUnknownNode();
+  auto unknownReason = getUnknownReason();
+  auto errorCallStack = getUnknownCallStack();
+
+  ASTContext &ctx = unknownNode->getModule()->getASTContext();
+
+  // Extract the location of the instruction/construct that triggered the error
+  // during interpretation, if available.
+  Optional<SourceLoc> triggerLoc = None;
+  if (auto badInst = dyn_cast<SILInstruction>(unknownNode)) {
+    triggerLoc = skipInternalLocations(badInst->getDebugLocation())
+                     .getLocation()
+                     .getSourceLoc();
+  }
+
+  // Determine the top-level expression where the error happens and use it as
+  // the location to emit diagnostics. Specifically, if the call-stack is
+  // non-empty, use the first call in the sequence as the error location as the
+  // error happens only in the context of this call. Use the fallback loc if
+  // the faulty top-level expression location cannot be found.
+  auto diagLoc =
+      errorCallStack.empty()
+          ? (triggerLoc ? triggerLoc.getValue() : fallbackLoc.getSourceLoc())
+          : errorCallStack.front();
+  if (diagLoc.isInvalid()) {
+    return;
   }
 
-  auto &ctx = badInst->getModule().getASTContext();
-  auto sourceLoc = loc.getSourceLoc();
-  switch (reason) {
+  // Emit a note at the trigger location as well if it is different from the
+  // top-level expression.
+  bool emitTriggerLocInDiag =
+      triggerLoc ? diagLoc != triggerLoc.getValue() : false;
+
+  switch (unknownReason) {
   case UnknownReason::Default:
-    diagnose(ctx, sourceLoc, diag::constexpr_unknown_reason_default)
-        .highlight(loc.getSourceRange());
-    break;
+    diagnose(ctx, diagLoc, diag::constexpr_unknown_reason_default);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_unevaluable_operation);
+    return;
   case UnknownReason::TooManyInstructions:
-    // TODO: Should pop up a level of the stack trace.
-    diagnose(ctx, sourceLoc, diag::constexpr_too_many_instructions,
-             ConstExprLimit)
-        .highlight(loc.getSourceRange());
-    break;
+    diagnose(ctx, diagLoc, diag::constexpr_too_many_instructions,
+             ConstExprLimit);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_limit_exceeding_instruction);
+    return;
   case UnknownReason::Loop:
-    diagnose(ctx, sourceLoc, diag::constexpr_loop)
-        .highlight(loc.getSourceRange());
-    break;
+    diagnose(ctx, diagLoc, diag::constexpr_loop_found_note);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_loop_instruction);
+    return;
   case UnknownReason::Overflow:
-    diagnose(ctx, sourceLoc, diag::constexpr_overflow)
-        .highlight(loc.getSourceRange());
-    break;
+    diagnose(ctx, diagLoc, diag::constexpr_overflow);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_overflow_operation);
+    return;
   case UnknownReason::Trap:
-    diagnose(ctx, sourceLoc, diag::constexpr_trap)
-        .highlight(loc.getSourceRange());
-    break;
-  }
-  return true;
-}
-
-/// Given that this is an 'Unknown' value, emit diagnostic notes providing
-/// context about what the problem is.
-void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
-  auto badInst = dyn_cast<SILInstruction>(getUnknownNode());
-  if (!badInst)
+    diagnose(ctx, diagLoc, diag::constexpr_trap);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_trap_operation);
     return;
-
-  bool emittedFirstNote = emitNoteDiagnostic(badInst, getUnknownReason(),
-                                             fallbackLoc);
-
-  auto sourceLoc = fallbackLoc.getSourceLoc();
-  auto &module = badInst->getModule();
-  if (sourceLoc.isInvalid()) {
-    diagnose(module.getASTContext(), sourceLoc, diag::constexpr_not_evaluable);
+  case UnknownReason::InvalidOperandValue:
+    diagnose(ctx, diagLoc, diag::constexpr_invalid_operand_seen);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_operand_invalid_here);
+    return;
+  case UnknownReason::NotTopLevelConstant: {
+    // For top-level errors, trigger loc is better than diagLoc.
+    auto loc = emitTriggerLocInDiag ? *triggerLoc : diagLoc;
+    diagnose(ctx, loc, diag::constexpr_value_unknown_at_top_level);
     return;
   }
-  for (auto &sourceLoc : llvm::reverse(getUnknownCallStack())) {
-    // Skip unknown sources.
-    if (!sourceLoc.isValid())
-      continue;
-
-    auto diag = emittedFirstNote ? diag::constexpr_called_from
-                                 : diag::constexpr_not_evaluable;
-    diagnose(module.getASTContext(), sourceLoc, diag);
-    emittedFirstNote = true;
+  case UnknownReason::MutipleTopLevelWriters: {
+    // For top-level errors, trigger loc is better than diagLoc.
+    auto loc = emitTriggerLocInDiag ? *triggerLoc : diagLoc;
+    diagnose(ctx, loc, diag::constexpr_multiple_writers_found_at_top_level);
+    return;
+  }
+  case UnknownReason::UnsupportedInstruction:
+    diagnose(ctx, diagLoc, diag::constexpr_unsupported_instruction_found);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc,
+               diag::constexpr_unsupported_instruction_found_here);
+    return;
+  case UnknownReason::CalleeImplementationUnknown:
+    diagnose(ctx, diagLoc, diag::constexpr_unknown_function_called);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_unknown_function_called_here);
+    return;
+  case UnknownReason::UntrackedSILValue:
+    diagnose(ctx, diagLoc, diag::constexpr_untracked_sil_value_use_found);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_untracked_sil_value_used_here);
+    return;
+  case UnknownReason::UnknownWitnessMethodConformance:
+    diagnose(ctx, diagLoc,
+             diag::constexpr_witness_call_with_no_conformance_found);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_witness_call_found_here);
+    return;
+  case UnknownReason::UnresolvableWitnessMethod:
+    diagnose(ctx, diagLoc, diag::constexpr_witness_call_with_no_target_found);
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, *triggerLoc, diag::constexpr_witness_call_found_here);
+    return;
   }
+  // TODO: print the call-stack in a controlled way if needed.
 }
 
 /// Returns the element of `aggregate` specified by the access path.