[Constant Evaluator] Support Array constants in the constant

evaluator. Add support for evaluating array initializations
and array append.

Author: Marc Rasi

include/swift/SIL/SILConstants.h

@@ -28,8 +28,7 @@ class SILValue;
 class SILBuilder;
 class SerializedSILLoader;
 
-struct APIntSymbolicValue;
-struct ArraySymbolicValue;
+struct SymbolicArrayStorage;
 struct DerivedAddressValue;
 struct EnumWithPayloadSymbolicValue;
 struct SymbolicValueMemoryObject;
@@ -256,6 +255,12 @@ class SymbolicValue {
 
     /// This represents an index *into* a memory object.
     RK_DerivedAddress,
+
+    /// This represents the internal storage of an array.
+    RK_ArrayStorage,
+
+    /// This represents an array.
+    RK_Array,
   };
 
   union {
@@ -299,6 +304,31 @@ class SymbolicValue {
     /// When this SymbolicValue is of "DerivedAddress" kind, this pointer stores
     /// information about the memory object and access path of the access.
     DerivedAddressValue *derivedAddress;
+
+    // The following fields are for representing an Array.
+    //
+    // In Swift, an array is a non-trivial struct that stores a reference to an
+    // internal storage: _ContiguousArrayStorage. Though arrays have value
+    // semantics in Swift, it is not the case in SIL. In SIL, an array can be
+    // mutated by taking the address of the internal storage i.e., through a
+    // shared, mutable pointer to the internal storage of the array. In fact,
+    // this is how an array initialization is lowered in SIL. Therefore, the
+    // symbolic representation of an array is an addressable "memory cell"
+    // (i.e., a SymbolicValueMemoryObject) containing the array storage. The
+    // array storage is modeled by the type: SymbolicArrayStorage. This
+    // representation of the array enables obtaining the address of the internal
+    // storage and modifying the array through that address. Array operations
+    // such as `append` that mutate an array must clone the internal storage of
+    // the array, following the semantics of the Swift implementation of those
+    // operations.
+
+    /// Representation of array storage (RK_ArrayStorage). SymbolicArrayStorage
+    /// is a container for a sequence of symbolic values.
+    SymbolicArrayStorage *arrayStorage;
+
+    /// When this symbolic value is of an "Array" kind, this stores a memory
+    /// object that contains a SymbolicArrayStorage value.
+    SymbolicValueMemoryObject *array;
   } value;
 
   RepresentationKind representationKind : 8;
@@ -348,6 +378,12 @@ class SymbolicValue {
     /// This value represents the address of, or into, a memory object.
     Address,
 
+    /// This represents an internal array storage.
+    ArrayStorage,
+
+    /// This represents an array value.
+    Array,
+
     /// These values are generally only seen internally to the system, external
     /// clients shouldn't have to deal with them.
     UninitMemory
@@ -471,6 +507,32 @@ class SymbolicValue {
   /// Return just the memory object for an address value.
   SymbolicValueMemoryObject *getAddressValueMemoryObject() const;
 
+  /// Create a symbolic array storage containing \c elements.
+  static SymbolicValue
+  getSymbolicArrayStorage(ArrayRef<SymbolicValue> elements, CanType elementType,
+                          SymbolicValueAllocator &allocator);
+
+  /// Create a symbolic array using the given symbolic array storage, which
+  /// contains the array elements.
+  static SymbolicValue getArray(Type arrayType, SymbolicValue arrayStorage,
+                                SymbolicValueAllocator &allocator);
+
+  /// Return the elements stored in this SymbolicValue of "ArrayStorage" kind.
+  ArrayRef<SymbolicValue> getStoredElements(CanType &elementType) const;
+
+  /// Return the symbolic value representing the internal storage of this array.
+  SymbolicValue getStorageOfArray() const;
+
+  /// Return the symbolic value representing the address of the element of this
+  /// array at the given \c index. The return value is a derived address whose
+  /// base is the memory object \c value.array (which contains the array
+  /// storage) and whose accesspath is \c index.
+  SymbolicValue getAddressOfArrayElement(SymbolicValueAllocator &allocator,
+                                         unsigned index) const;
+
+  /// Return the type of this array symbolic value.
+  Type getArrayType() const;
+
   //===--------------------------------------------------------------------===//
   // Helpers
 
@@ -545,7 +607,6 @@ struct SymbolicValueMemoryObject {
   SymbolicValueMemoryObject(const SymbolicValueMemoryObject &) = delete;
   void operator=(const SymbolicValueMemoryObject &) = delete;
 };
-
 } // end namespace swift
 
 #endif

lib/SIL/SILConstants.cpp

@@ -101,12 +101,32 @@ void SymbolicValue::print(llvm::raw_ostream &os, unsigned indent) const {
   case RK_DerivedAddress: {
     SmallVector<unsigned, 4> accessPath;
     SymbolicValueMemoryObject *memObject = getAddressValue(accessPath);
-    os << "Address[" << memObject->getType() << "] ";
+    os << "address[" << memObject->getType() << "] ";
     interleave(accessPath.begin(), accessPath.end(),
                [&](unsigned idx) { os << idx; }, [&]() { os << ", "; });
     os << "\n";
     break;
   }
+  case RK_ArrayStorage: {
+    CanType elementType;
+    ArrayRef<SymbolicValue> elements = getStoredElements(elementType);
+    os << "elements type: " << elementType << " size: " << elements.size();
+    switch (elements.size()) {
+    case 0:
+      os << " contents []\n";
+      return;
+    default:
+      os << " contents [\n";
+      for (auto elt : elements)
+        elt.print(os, indent + 2);
+      os.indent(indent) << "]\n";
+      return;
+    }
+  }
+  case RK_Array: {
+    os << getArrayType() << ": \n";
+    getStorageOfArray().print(os, indent);
+  }
   }
 }
 
@@ -138,11 +158,15 @@ SymbolicValue::Kind SymbolicValue::getKind() const {
   case RK_DirectAddress:
   case RK_DerivedAddress:
     return Address;
+  case RK_ArrayStorage:
+    return ArrayStorage;
+  case RK_Array:
+    return Array;
   }
   llvm_unreachable("covered switch");
 }
 
-/// Clone this SymbolicValue into the specified ASTContext and return the new
+/// Clone this SymbolicValue into the specified allocator and return the new
 /// version.  This only works for valid constants.
 SymbolicValue
 SymbolicValue::cloneInto(SymbolicValueAllocator &allocator) const {
@@ -169,16 +193,32 @@ SymbolicValue::cloneInto(SymbolicValueAllocator &allocator) const {
       results.push_back(elt.cloneInto(allocator));
     return getAggregate(results, allocator);
   }
-  case RK_EnumWithPayload:
-    return getEnumWithPayload(getEnumValue(), getEnumPayloadValue(), allocator);
+  case RK_EnumWithPayload: {
+    return getEnumWithPayload(
+        getEnumValue(), getEnumPayloadValue().cloneInto(allocator), allocator);
+  }
   case RK_DirectAddress:
   case RK_DerivedAddress: {
     SmallVector<unsigned, 4> accessPath;
     auto *memObject = getAddressValue(accessPath);
     auto *newMemObject = SymbolicValueMemoryObject::create(
-        memObject->getType(), memObject->getValue(), allocator);
+        memObject->getType(), memObject->getValue().cloneInto(allocator),
+        allocator);
     return getAddress(newMemObject, accessPath, allocator);
   }
+  case RK_ArrayStorage: {
+    CanType elementType;
+    ArrayRef<SymbolicValue> oldElements = getStoredElements(elementType);
+    SmallVector<SymbolicValue, 4> clonedElements;
+    clonedElements.reserve(oldElements.size());
+    for (auto elem : oldElements)
+      clonedElements.push_back(elem.cloneInto(allocator));
+    return getSymbolicArrayStorage(clonedElements, elementType, allocator);
+  }
+  case RK_Array: {
+    SymbolicValue clonedStorage = getStorageOfArray().cloneInto(allocator);
+    return getArray(getArrayType(), clonedStorage, allocator);
+  }
   }
   llvm_unreachable("covered switch");
 }
@@ -522,6 +562,105 @@ SymbolicValueMemoryObject *SymbolicValue::getAddressValueMemoryObject() const {
   return value.derivedAddress->memoryObject;
 }
 
+//===----------------------------------------------------------------------===//
+// Arrays
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+
+/// Representation of the internal storage of an array. This is a container for
+/// a sequence of symbolic values corresponding to the elements of an array.
+struct SymbolicArrayStorage final
+    : private llvm::TrailingObjects<SymbolicArrayStorage, SymbolicValue> {
+  friend class llvm::TrailingObjects<SymbolicArrayStorage, SymbolicValue>;
+
+  const CanType elementType;
+
+  const unsigned numElements;
+
+  static SymbolicArrayStorage *create(ArrayRef<SymbolicValue> elements,
+                                      CanType elementType,
+                                      SymbolicValueAllocator &allocator) {
+    auto byteSize =
+        SymbolicArrayStorage::totalSizeToAlloc<SymbolicValue>(elements.size());
+    auto rawMem = allocator.allocate(byteSize, alignof(SymbolicArrayStorage));
+
+    //  Placement initialize the object.
+    auto *storage =
+        ::new (rawMem) SymbolicArrayStorage(elementType, elements.size());
+    std::uninitialized_copy(elements.begin(), elements.end(),
+                            storage->getTrailingObjects<SymbolicValue>());
+    return storage;
+  }
+
+  /// Return the stored elements.
+  ArrayRef<SymbolicValue> getElements() const {
+    return {getTrailingObjects<SymbolicValue>(), numElements};
+  }
+
+  // This is used by the llvm::TrailingObjects base class.
+  size_t numTrailingObjects(OverloadToken<SymbolicValue>) const {
+    return numElements;
+  }
+
+private:
+  SymbolicArrayStorage() = delete;
+  SymbolicArrayStorage(const SymbolicArrayStorage &) = delete;
+  SymbolicArrayStorage(CanType elementType, unsigned numElements)
+      : elementType(elementType), numElements(numElements) {}
+};
+} // namespace swift
+// end namespace swift
+
+SymbolicValue
+SymbolicValue::getSymbolicArrayStorage(ArrayRef<SymbolicValue> elements,
+                                       CanType elementType,
+                                       SymbolicValueAllocator &allocator) {
+  // TODO: Could compress the empty array representation if there were a reason
+  // to.
+  auto *arrayStorage =
+      SymbolicArrayStorage::create(elements, elementType, allocator);
+  SymbolicValue result;
+  result.representationKind = RK_ArrayStorage;
+  result.value.arrayStorage = arrayStorage;
+  return result;
+}
+
+ArrayRef<SymbolicValue>
+SymbolicValue::getStoredElements(CanType &elementType) const {
+  assert(getKind() == ArrayStorage);
+  elementType = value.arrayStorage->elementType;
+  return value.arrayStorage->getElements();
+}
+
+SymbolicValue SymbolicValue::getArray(Type arrayType,
+                                      SymbolicValue arrayStorage,
+                                      SymbolicValueAllocator &allocator) {
+  assert(arrayStorage.getKind() == ArrayStorage);
+  SymbolicValue result;
+  result.representationKind = RK_Array;
+  result.value.array =
+      SymbolicValueMemoryObject::create(arrayType, arrayStorage, allocator);
+  return result;
+}
+
+SymbolicValue
+SymbolicValue::getAddressOfArrayElement(SymbolicValueAllocator &allocator,
+                                        unsigned index) const {
+  assert(getKind() == Array);
+  return SymbolicValue::getAddress(value.array, {index}, allocator);
+}
+
+SymbolicValue SymbolicValue::getStorageOfArray() const {
+  assert(getKind() == Array);
+  return value.array->getValue();
+}
+
+Type SymbolicValue::getArrayType() const {
+  assert(getKind() == Array);
+  return value.array->getType();
+}
+
 //===----------------------------------------------------------------------===//
 // Higher level code
 //===----------------------------------------------------------------------===//
@@ -766,20 +905,29 @@ static SymbolicValue getIndexedElement(SymbolicValue aggregate,
   if (aggregate.getKind() == SymbolicValue::UninitMemory)
     return SymbolicValue::getUninitMemory();
 
-  assert(aggregate.getKind() == SymbolicValue::Aggregate &&
+  assert((aggregate.getKind() == SymbolicValue::Aggregate ||
+          aggregate.getKind() == SymbolicValue::ArrayStorage) &&
          "the accessPath is invalid for this type");
 
   unsigned elementNo = accessPath.front();
 
-  SymbolicValue elt = aggregate.getAggregateValue()[elementNo];
+  SymbolicValue elt;
   Type eltType;
-  if (auto *decl = type->getStructOrBoundGenericStruct()) {
-    eltType = decl->getStoredProperties()[elementNo]->getType();
-  } else if (auto tuple = type->getAs<TupleType>()) {
-    assert(elementNo < tuple->getNumElements() && "invalid index");
-    eltType = tuple->getElement(elementNo).getType();
+
+  if (aggregate.getKind() == SymbolicValue::ArrayStorage) {
+    CanType arrayEltTy;
+    elt = aggregate.getStoredElements(arrayEltTy)[elementNo];
+    eltType = arrayEltTy;
   } else {
-    llvm_unreachable("the accessPath is invalid for this type");
+    elt = aggregate.getAggregateValue()[elementNo];
+    if (auto *decl = type->getStructOrBoundGenericStruct()) {
+      eltType = decl->getStoredProperties()[elementNo]->getType();
+    } else if (auto tuple = type->getAs<TupleType>()) {
+      assert(elementNo < tuple->getNumElements() && "invalid index");
+      eltType = tuple->getElement(elementNo).getType();
+    } else {
+      llvm_unreachable("the accessPath is invalid for this type");
+    }
   }
 
   return getIndexedElement(elt, accessPath.drop_front(), eltType);
@@ -828,20 +976,29 @@ static SymbolicValue setIndexedElement(SymbolicValue aggregate,
     aggregate = SymbolicValue::getAggregate(newElts, allocator);
   }
 
-  assert(aggregate.getKind() == SymbolicValue::Aggregate &&
+  assert((aggregate.getKind() == SymbolicValue::Aggregate ||
+          aggregate.getKind() == SymbolicValue::ArrayStorage) &&
          "the accessPath is invalid for this type");
 
   unsigned elementNo = accessPath.front();
 
-  ArrayRef<SymbolicValue> oldElts = aggregate.getAggregateValue();
+  ArrayRef<SymbolicValue> oldElts;
   Type eltType;
-  if (auto *decl = type->getStructOrBoundGenericStruct()) {
-    eltType = decl->getStoredProperties()[elementNo]->getType();
-  } else if (auto tuple = type->getAs<TupleType>()) {
-    assert(elementNo < tuple->getNumElements() && "invalid index");
-    eltType = tuple->getElement(elementNo).getType();
+
+  if (aggregate.getKind() == SymbolicValue::ArrayStorage) {
+    CanType arrayEltTy;
+    oldElts = aggregate.getStoredElements(arrayEltTy);
+    eltType = arrayEltTy;
   } else {
-    llvm_unreachable("the accessPath is invalid for this type");
+    oldElts = aggregate.getAggregateValue();
+    if (auto *decl = type->getStructOrBoundGenericStruct()) {
+      eltType = decl->getStoredProperties()[elementNo]->getType();
+    } else if (auto tuple = type->getAs<TupleType>()) {
+      assert(elementNo < tuple->getNumElements() && "invalid index");
+      eltType = tuple->getElement(elementNo).getType();
+    } else {
+      llvm_unreachable("the accessPath is invalid for this type");
+    }
   }
 
   // Update the indexed element of the aggregate.
@@ -850,7 +1007,11 @@ static SymbolicValue setIndexedElement(SymbolicValue aggregate,
       setIndexedElement(newElts[elementNo], accessPath.drop_front(), newElement,
                         eltType, allocator);
 
-  aggregate = SymbolicValue::getAggregate(newElts, allocator);
+  if (aggregate.getKind() == SymbolicValue::Aggregate)
+    return SymbolicValue::getAggregate(newElts, allocator);
+
+  return aggregate = SymbolicValue::getSymbolicArrayStorage(
+             newElts, eltType->getCanonicalType(), allocator);
   return aggregate;
 }