address comments

Author: Marc Rasi

include/swift/SIL/SILConstants.h

@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This defines an interface to represent SIL level structured constants in an
+// This defines an interface to represent SIL level structured constants in a
 // memory efficient way.
 //
 //===----------------------------------------------------------------------===//
@@ -19,6 +19,8 @@
 #define SWIFT_SIL_CONSTANTS_H
 
 #include "swift/SIL/SILValue.h"
+#include "llvm/Support/CommandLine.h"
+
 
 namespace swift {
 class SingleValueInstruction;
@@ -31,6 +33,8 @@ struct ArraySymbolicValue;
 struct EnumWithPayloadSymbolicValue;
 struct UnknownSymbolicValue;
 
+extern llvm::cl::opt<unsigned> ConstExprLimit;
+
 /// When we fail to constant fold a value, this captures a reason why,
 /// allowing the caller to produce a specific diagnostic.  The "Unknown"
 /// SymbolicValue representation also includes a pointer to the SILNode in
@@ -85,8 +89,8 @@ class SymbolicValue {
     /// This value is represented with an inline integer representation.
     RK_IntegerInline,
 
-    /// This value is an array, struct, or tuple of constants.  This is
-    /// tracked by the "aggregate" member of the value union.
+    /// This value is a struct or tuple of constants.  This is tracked by the
+    /// "aggregate" member of the value union.
     RK_Aggregate,
   };
 
@@ -159,7 +163,7 @@ class SymbolicValue {
 
   static SymbolicValue getUnknown(SILNode *node, UnknownReason reason,
                                   llvm::ArrayRef<SourceLoc> callStack,
-                                  llvm::BumpPtrAllocator &allocator);
+                                  ASTContext &astContext);
 
   /// Return true if this represents an unknown result.
   bool isUnknown() const { return getKind() == Unknown; }
@@ -200,15 +204,15 @@ class SymbolicValue {
 
   static SymbolicValue getInteger(int64_t value, unsigned bitWidth);
   static SymbolicValue getInteger(const APInt &value,
-                                  llvm::BumpPtrAllocator &allocator);
+                                  ASTContext &astContext);
 
   APInt getIntegerValue() const;
   unsigned getIntegerValueBitWidth() const;
 
   /// This returns an aggregate value with the specified elements in it.  This
-  /// copies the elements into the specified allocator.
+  /// copies the elements into the specified ASTContext.
   static SymbolicValue getAggregate(ArrayRef<SymbolicValue> elements,
-                                    llvm::BumpPtrAllocator &allocator);
+                                    ASTContext &astContext);
 
   ArrayRef<SymbolicValue> getAggregateValue() const;
 
@@ -225,9 +229,9 @@ class SymbolicValue {
   /// reason, we fall back to using the specified location.
   void emitUnknownDiagnosticNotes(SILLocation fallbackLoc);
 
-  /// Clone this SymbolicValue into the specified allocator and return the new
+  /// Clone this SymbolicValue into the specified ASTContext and return the new
   /// version.  This only works for valid constants.
-  SymbolicValue cloneInto(llvm::BumpPtrAllocator &allocator) const;
+  SymbolicValue cloneInto(ASTContext &astContext) const;
 
   void print(llvm::raw_ostream &os, unsigned indent = 0) const;
   void dump() const;

include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -15,9 +15,9 @@
 // with the goal of standardization in a future version of Swift.
 //
 // Constant expressions are functions without side effects that take constant
-// values and return constant values.  These constants may be integer, floating
-// point, and string values, or arrays thereof (up to 1024 elements).  We allow
-// abstractions to be built out of fragile structs and tuples.
+// values and return constant values.  These constants may be integer, and
+// floating point values.   We allow abstractions to be built out of fragile
+// structs and tuples.
 //
 //===----------------------------------------------------------------------===//
 
@@ -30,6 +30,7 @@
 
 namespace swift {
 class ApplyInst;
+class ASTContext;
 class Operand;
 class SILInstruction;
 class SILModule;
@@ -41,9 +42,10 @@ enum class UnknownReason;
 /// This class is the main entrypoint for evaluating constant expressions.  It
 /// also handles caching of previously computed constexpr results.
 class ConstExprEvaluator {
-  /// This is a long-lived bump pointer allocator that holds the arguments and
-  /// result values for the cached constexpr calls we have already analyzed.
-  llvm::BumpPtrAllocator &allocator;
+  /// We store arguments and result values for the cached constexpr calls we
+  /// have already analyzed in this ASTContext so that they are available even
+  /// after this ConstExprEvaluator is gone.
+  ASTContext &astContext;
 
   /// The current call stack, used for providing accurate diagnostics.
   llvm::SmallVector<SourceLoc, 4> callStack;
@@ -55,7 +57,7 @@ class ConstExprEvaluator {
   explicit ConstExprEvaluator(SILModule &m);
   ~ConstExprEvaluator();
 
-  llvm::BumpPtrAllocator &getAllocator() { return allocator; }
+  ASTContext &getASTContext() { return astContext; }
 
   void pushCallStack(SourceLoc loc) { callStack.push_back(loc); }
 

lib/SIL/SILConstants.cpp

@@ -17,6 +17,13 @@
 #include "llvm/Support/TrailingObjects.h"
 using namespace swift;
 
+namespace swift {
+llvm::cl::opt<unsigned>
+    ConstExprLimit("constexpr-limit", llvm::cl::init(512),
+                   llvm::cl::desc("Number of instructions interpreted in a"
+                                  " constexpr function"));
+}
+
 template <typename... T, typename... U>
 static InFlightDiagnostic diagnose(ASTContext &Context, SourceLoc loc,
                                    Diag<T...> diag, U &&... args) {
@@ -92,25 +99,26 @@ SymbolicValue::Kind SymbolicValue::getKind() const {
   }
 }
 
-/// Clone this SymbolicValue into the specified allocator and return the new
+/// Clone this SymbolicValue into the specified ASTContext and return the new
 /// version.  This only works for valid constants.
 SymbolicValue
-SymbolicValue::cloneInto(llvm::BumpPtrAllocator &allocator) const {
+SymbolicValue::cloneInto(ASTContext &astContext) const {
   auto thisRK = representationKind;
   switch (thisRK) {
   case RK_Unknown:
   case RK_Metatype:
   case RK_Function:
+    assert(0 && "cloning this representation kind is not supported");
   case RK_IntegerInline:
   case RK_Integer:
-    return SymbolicValue::getInteger(getIntegerValue(), allocator);
+    return SymbolicValue::getInteger(getIntegerValue(), astContext);
   case RK_Aggregate: {
     auto elts = getAggregateValue();
     SmallVector<SymbolicValue, 4> results;
     results.reserve(elts.size());
     for (auto elt : elts)
-      results.push_back(elt.cloneInto(allocator));
-    return getAggregate(results, allocator);
+      results.push_back(elt.cloneInto(astContext));
+    return getAggregate(results, astContext);
   }
   }
 }
@@ -128,14 +136,14 @@ SymbolicValue SymbolicValue::getInteger(int64_t value, unsigned bitWidth) {
 }
 
 SymbolicValue SymbolicValue::getInteger(const APInt &value,
-                                        llvm::BumpPtrAllocator &allocator) {
+                                        ASTContext &astContext) {
   // In the common case, we can form an inline representation.
   unsigned numWords = value.getNumWords();
   if (numWords == 1)
     return getInteger(value.getRawData()[0], value.getBitWidth());
 
   // Copy the integers from the APInt into the bump pointer.
-  auto *words = allocator.Allocate<uint64_t>(numWords);
+  auto *words = astContext.Allocate<uint64_t>(numWords).data();
   std::uninitialized_copy(value.getRawData(), value.getRawData() + numWords,
                           words);
 
@@ -173,9 +181,10 @@ unsigned SymbolicValue::getIntegerValueBitWidth() const {
 /// This returns a constant Symbolic value with the specified elements in it.
 /// This assumes that the elements lifetime has been managed for this.
 SymbolicValue SymbolicValue::getAggregate(ArrayRef<SymbolicValue> elements,
-                                          llvm::BumpPtrAllocator &allocator) {
-  // Copy the integers from the APInt into the bump pointer.
-  auto *resultElts = allocator.Allocate<SymbolicValue>(elements.size());
+                                          ASTContext &astContext) {
+  // Copy the elements into the bump pointer.
+  auto *resultElts =
+      astContext.Allocate<SymbolicValue>(elements.size()).data();
   std::uninitialized_copy(elements.begin(), elements.end(), resultElts);
 
   SymbolicValue result;
@@ -212,10 +221,10 @@ struct alignas(SourceLoc) UnknownSymbolicValue final
 
   static UnknownSymbolicValue *create(SILNode *node, UnknownReason reason,
                                       ArrayRef<SourceLoc> elements,
-                                      llvm::BumpPtrAllocator &allocator) {
+                                      ASTContext &astContext) {
     auto byteSize =
         UnknownSymbolicValue::totalSizeToAlloc<SourceLoc>(elements.size());
-    auto rawMem = allocator.Allocate(byteSize, alignof(UnknownSymbolicValue));
+    auto rawMem = astContext.Allocate(byteSize, alignof(UnknownSymbolicValue));
 
     // Placement-new the value inside the memory we just allocated.
     auto value = ::new (rawMem) UnknownSymbolicValue(
@@ -245,12 +254,12 @@ struct alignas(SourceLoc) UnknownSymbolicValue final
 
 SymbolicValue SymbolicValue::getUnknown(SILNode *node, UnknownReason reason,
                                         llvm::ArrayRef<SourceLoc> callStack,
-                                        llvm::BumpPtrAllocator &allocator) {
+                                        ASTContext &astContext) {
   assert(node && "node must be present");
   SymbolicValue result;
   result.representationKind = RK_Unknown;
   result.value.unknown =
-      UnknownSymbolicValue::create(node, reason, callStack, allocator);
+      UnknownSymbolicValue::create(node, reason, callStack, astContext);
   return result;
 }
 
@@ -284,8 +293,8 @@ static SILDebugLocation skipInternalLocations(SILDebugLocation loc) {
     return loc;
 
   // Zip through inlined call site information that came from the
-  // implementation guts of the tensor library.  We want to report the
-  // message inside the user's code, not in the guts we inlined through.
+  // implementation guts of the library.  We want to report the message inside
+  // the user's code, not in the guts we inlined through.
   for (; auto ics = ds->InlinedCallSite; ds = ics) {
     // If we found a valid inlined-into location, then we are good.
     if (ds->Loc.getSourceLoc().isValid())
@@ -351,7 +360,8 @@ void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
     break;
   case UnknownReason::TooManyInstructions:
     // TODO: Should pop up a level of the stack trace.
-    error = "expression is too large to evaluate at compile-time";
+    error = "exceeded instruction limit: " + std::to_string(ConstExprLimit) +
+            " when evaluating the expression at compile time";
     break;
   case UnknownReason::Loop:
     error = "control flow loop found";
@@ -377,7 +387,7 @@ void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
   unsigned originalDiagnosticLineNumber =
       SM.getLineNumber(fallbackLoc.getSourceLoc());
   for (auto &sourceLoc : llvm::reverse(getUnknownCallStack())) {
-    // Skip known sources.
+    // Skip unknown sources.
     if (!sourceLoc.isValid())
       continue;
     // Also skip notes that point to the same line as the original error, for

lib/SILOptimizer/Mandatory/DataflowDiagnostics.cpp

@@ -148,8 +148,11 @@ static void diagnosePoundAssert(const SILInstruction *I,
          "sema prevents non-int1 #assert condition");
   if (intValue.isNullValue()) {
     auto *message = cast<StringLiteralInst>(builtinInst->getArguments()[1]);
+    StringRef messageValue = message->getValue();
+    if (messageValue.empty())
+      messageValue = "assertion failed";
     diagnose(M.getASTContext(), I->getLoc().getSourceLoc(),
-             diag::pound_assert_failure, message->getValue());
+             diag::pound_assert_failure, messageValue);
     return;
   }
 }
@@ -165,13 +168,18 @@ class EmitDFDiagnostics : public SILFunctionTransform {
       return;
 
     SILModule &M = getFunction()->getModule();
-    ConstExprEvaluator constantEvaluator(M);
     for (auto &BB : *getFunction())
       for (auto &I : BB) {
         diagnoseUnreachable(&I, M.getASTContext());
         diagnoseStaticReports(&I, M);
-        diagnosePoundAssert(&I, M, constantEvaluator);
       }
+
+    if (M.getASTContext().LangOpts.EnableExperimentalStaticAssert) {
+      ConstExprEvaluator constantEvaluator(M);
+      for (auto &BB : *getFunction())
+        for (auto &I : BB)
+          diagnosePoundAssert(&I, M, constantEvaluator);
+    }
   }
 };
 } // end anonymous namespace