const evaluator part 1

Author: Marc Rasi

include/swift/AST/DiagnosticsSIL.def

@@ -311,6 +311,16 @@ ERROR(shifting_all_significant_bits,none,
 ERROR(static_report_error, none,
       "static report error", ())
 
+ERROR(pound_assert_condition_not_constant,none,
+       "#assert condition not constant", ())
+ERROR(pound_assert_failure,none,
+       "%0", (StringRef))
+
+NOTE(constexpr_unknown_reason, none, "%0", (StringRef))
+NOTE(constexpr_called_from, none, "when called from here", ())
+NOTE(constexpr_not_evaluable, none,
+     "expression not evaluable as constant here", ())
+
 ERROR(non_physical_addressof,none,
       "addressof only works with purely physical lvalues; "
       "use `withUnsafePointer` or `withUnsafeBytes` unless you're implementing "

include/swift/SIL/SILConstants.h

@@ -0,0 +1,246 @@
+//===--- SILConstants.h - SIL constant representation -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This defines an interface to represent SIL level structured constants in an
+// memory efficient way.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_CONSTANTS_H
+#define SWIFT_SIL_CONSTANTS_H
+
+#include "swift/SIL/SILValue.h"
+
+namespace swift {
+class SingleValueInstruction;
+class SILValue;
+class SILBuilder;
+class SerializedSILLoader;
+
+struct APIntSymbolicValue;
+struct ArraySymbolicValue;
+struct EnumWithPayloadSymbolicValue;
+struct UnknownSymbolicValue;
+
+/// 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
+/// question that was problematic.
+enum class UnknownReason {
+  // TODO: Eliminate the default code, by making classifications for each
+  // failure mode.
+  Default,
+
+  /// The constant expression was too big.  This is reported on a random
+  /// instruction within the constexpr that triggered the issue.
+  TooManyInstructions,
+
+  /// A control flow loop was found.
+  Loop,
+
+  /// Integer overflow detected.
+  Overflow,
+
+  /// Unspecified trap detected.
+  Trap,
+};
+
+/// This is the symbolic value tracked for each SILValue in a scope.  We
+/// support multiple representational forms for the constant node in order to
+/// avoid pointless memory bloat + copying.  This is intended to be a
+/// light-weight POD type we can put in hash tables and pass around by-value.
+///
+/// Internally, this value has multiple ways to represent the same sorts of
+/// symbolic values (e.g. to save memory).  It provides a simpler public
+/// interface though.
+class SymbolicValue {
+private:
+  enum RepresentationKind {
+    /// This symbolic value cannot be determined, carries multiple values
+    /// (i.e., varies dynamically at the top level), or is of some type that
+    /// we cannot analyze and propagate (e.g. NSObject).
+    ///
+    RK_Unknown,
+
+    /// This value is known to be a metatype reference.  The type is stored
+    /// in the "metatype" member.
+    RK_Metatype,
+
+    /// This value is known to be a function reference, e.g. through
+    /// function_ref directly, or a devirtualized method reference.
+    RK_Function,
+
+    /// This value is represented with a bump-pointer allocated APInt.
+    RK_Integer,
+
+    /// 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.
+    RK_Aggregate,
+  };
+
+  union {
+    /// When the value is Unknown, this contains information about the
+    /// unfoldable part of the computation.
+    UnknownSymbolicValue *unknown;
+
+    /// This is always a SILType with an object category.  This is the value
+    /// of the underlying instance type, not the MetatypeType.
+    TypeBase *metatype;
+
+    SILFunction *function;
+
+    /// When this SymbolicValue is of "Integer" kind, this pointer stores
+    /// the words of the APInt value it holds.
+    uint64_t *integer;
+
+    /// This holds the bits of an integer for an inline representation.
+    uint64_t integerInline;
+
+    /// When this SymbolicValue is of "Aggregate" kind, this pointer stores
+    /// information about the array elements and count.
+    const SymbolicValue *aggregate;
+  } value;
+
+  RepresentationKind representationKind : 8;
+
+  union {
+    /// This is the reason code for RK_Unknown values.
+    UnknownReason unknown_reason : 32;
+
+    /// This is the number of bits in an RK_Integer or RK_IntegerInline
+    /// representation, which makes the number of entries in the list derivable.
+    unsigned integer_bitwidth;
+
+    /// This is the number of elements for an RK_Aggregate representation.
+    unsigned aggregate_numElements;
+  } aux;
+
+public:
+  /// This enum is used to indicate the sort of value held by a SymbolicValue
+  /// independent of its concrete representation.  This is the public
+  /// interface to SymbolicValue.
+  enum Kind {
+    /// This is a value that isn't a constant.
+    Unknown,
+
+    /// This is a known metatype value.
+    Metatype,
+
+    /// This is a function, represented as a SILFunction.
+    Function,
+
+    /// This is an integer constant.
+    Integer,
+
+    /// This can be an array, struct, tuple, etc.
+    Aggregate,
+  };
+
+  /// For constant values, return the type classification of this value.
+  Kind getKind() const;
+
+  /// Return true if this represents a constant value.
+  bool isConstant() const {
+    auto kind = getKind();
+    return kind != Unknown;
+  }
+
+  static SymbolicValue getUnknown(SILNode *node, UnknownReason reason,
+                                  llvm::ArrayRef<SourceLoc> callStack,
+                                  llvm::BumpPtrAllocator &allocator);
+
+  /// Return true if this represents an unknown result.
+  bool isUnknown() const { return getKind() == Unknown; }
+
+  /// Return the call stack for an unknown result.
+  ArrayRef<SourceLoc> getUnknownCallStack() const;
+
+  /// Return the node that triggered an unknown result.
+  SILNode *getUnknownNode() const;
+
+  /// Return the reason an unknown result was generated.
+  UnknownReason getUnknownReason() const;
+
+  static SymbolicValue getMetatype(CanType type) {
+    SymbolicValue result;
+    result.representationKind = RK_Metatype;
+    result.value.metatype = type.getPointer();
+    return result;
+  }
+
+  CanType getMetatypeValue() const {
+    assert(representationKind == RK_Metatype);
+    return CanType(value.metatype);
+  }
+
+  static SymbolicValue getFunction(SILFunction *fn) {
+    assert(fn && "Function cannot be null");
+    SymbolicValue result;
+    result.representationKind = RK_Function;
+    result.value.function = fn;
+    return result;
+  }
+
+  SILFunction *getFunctionValue() const {
+    assert(getKind() == Function);
+    return value.function;
+  }
+
+  static SymbolicValue getInteger(int64_t value, unsigned bitWidth);
+  static SymbolicValue getInteger(const APInt &value,
+                                  llvm::BumpPtrAllocator &allocator);
+
+  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.
+  static SymbolicValue getAggregate(ArrayRef<SymbolicValue> elements,
+                                    llvm::BumpPtrAllocator &allocator);
+
+  ArrayRef<SymbolicValue> getAggregateValue() const;
+
+  //===--------------------------------------------------------------------===//
+  // Helpers
+
+  /// Dig through single element aggregates, return the ultimate thing inside of
+  /// it.  This is useful when dealing with integers and floats, because they
+  /// are often wrapped in single-element struct wrappers.
+  SymbolicValue lookThroughSingleElementAggregates() const;
+
+  /// Given that this is an 'Unknown' value, emit diagnostic notes providing
+  /// context about what the problem is.  If there is no location for some
+  /// reason, we fall back to using the specified location.
+  void emitUnknownDiagnosticNotes(SILLocation fallbackLoc);
+
+  /// Clone this SymbolicValue into the specified allocator and return the new
+  /// version.  This only works for valid constants.
+  SymbolicValue cloneInto(llvm::BumpPtrAllocator &allocator) const;
+
+  void print(llvm::raw_ostream &os, unsigned indent = 0) const;
+  void dump() const;
+};
+
+static_assert(sizeof(SymbolicValue) == 2 * sizeof(void *),
+              "SymbolicValue should stay small and POD");
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os, SymbolicValue val) {
+  val.print(os);
+  return os;
+}
+
+} // end namespace swift
+
+#endif

include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -0,0 +1,86 @@
+//===--- ConstExpr.h - Constant expression evaluator -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This defines an interface to evaluate Swift language level constant
+// expressions.  Its model is intended to be general and reasonably powerful,
+// 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.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILOPTIMIZER_CONSTEXPR_H
+#define SWIFT_SILOPTIMIZER_CONSTEXPR_H
+
+#include "swift/Basic/LLVM.h"
+#include "swift/Basic/SourceLoc.h"
+#include "llvm/Support/Allocator.h"
+
+namespace swift {
+class ApplyInst;
+class Operand;
+class SILInstruction;
+class SILModule;
+class SILNode;
+class SILValue;
+class SymbolicValue;
+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;
+
+  /// 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(SILModule &m);
+  ~ConstExprEvaluator();
+
+  llvm::BumpPtrAllocator &getAllocator() { return allocator; }
+
+  void pushCallStack(SourceLoc loc) { callStack.push_back(loc); }
+
+  void popCallStack() {
+    assert(!callStack.empty());
+    callStack.pop_back();
+  }
+
+  const llvm::SmallVector<SourceLoc, 4> &getCallStack() { return callStack; }
+
+  // As SymbolicValue::getUnknown(), but handles passing the call stack and
+  // allocator.
+  SymbolicValue getUnknown(SILNode *node, UnknownReason reason);
+
+  /// Analyze the specified values to determine if they are constant values.
+  /// This is done in code that is not necessarily itself a constexpr
+  /// function.  The results are added to the results list which is a parallel
+  /// structure to the input values.
+  ///
+  /// TODO: Return information about which callees were found to be
+  /// constexprs, which would allow the caller to delete dead calls to them
+  /// that occur after after folding them.
+  void computeConstantValues(ArrayRef<SILValue> values,
+                             SmallVectorImpl<SymbolicValue> &results);
+};
+
+} // end namespace swift
+#endif

lib/SIL/CMakeLists.txt

@@ -18,6 +18,7 @@ add_swift_library(swiftSIL STATIC
   SILArgument.cpp
   SILBasicBlock.cpp
   SILBuilder.cpp
+  SILConstants.cpp
   SILCoverageMap.cpp
   SILDebugScope.cpp
   SILDeclRef.cpp