Merge pull request swiftlang#28114 from ravikandhadai/constexpr-aggregate-types

Author: swift-ci

include/swift/SIL/SILConstants.h

@@ -28,6 +28,7 @@ class SILValue;
 class SILBuilder;
 class SerializedSILLoader;
 
+struct AggregateSymbolicValue;
 struct SymbolicArrayStorage;
 struct DerivedAddressValue;
 struct EnumWithPayloadSymbolicValue;
@@ -307,8 +308,8 @@ class SymbolicValue {
     const char *string;
 
     /// When this SymbolicValue is of "Aggregate" kind, this pointer stores
-    /// information about the array elements and count.
-    const SymbolicValue *aggregate;
+    /// information about the aggregate elements, its type and count.
+    const AggregateSymbolicValue *aggregate;
 
     /// When this SymbolicValue is of "Enum" kind, this pointer stores
     /// information about the enum case type.
@@ -365,9 +366,6 @@ class SymbolicValue {
 
     /// This is the number of bytes for an RK_String representation.
     unsigned stringNumBytes;
-
-    /// This is the number of elements for an RK_Aggregate representation.
-    unsigned aggregateNumElements;
   } auxInfo;
 
 public:
@@ -488,11 +486,15 @@ class SymbolicValue {
   StringRef getStringValue() 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,
+  /// copies the member values into the specified Allocator.
+  static SymbolicValue getAggregate(ArrayRef<SymbolicValue> members,
+                                    Type aggregateType,
                                     SymbolicValueAllocator &allocator);
 
-  ArrayRef<SymbolicValue> getAggregateValue() const;
+  ArrayRef<SymbolicValue> getAggregateMembers() const;
+
+  /// Return the type of this aggregate symbolic value.
+  Type getAggregateType() const;
 
   /// This returns a constant Symbolic value for the enum case in `decl`, which
   /// must not have an associated value.
@@ -617,7 +619,12 @@ struct SymbolicValueMemoryObject {
   Type getType() const { return type; }
 
   SymbolicValue getValue() const { return value; }
-  void setValue(SymbolicValue newValue) { value = newValue; }
+  void setValue(SymbolicValue newValue) {
+    assert((newValue.getKind() != SymbolicValue::Aggregate ||
+            newValue.getAggregateType()->isEqual(type)) &&
+           "Memory object type does not match the type of the symbolic value");
+    value = newValue;
+  }
 
   /// Create a new memory object whose overall type is as specified.
   static SymbolicValueMemoryObject *create(Type type, SymbolicValue value,

lib/SIL/SILConstants.cpp

@@ -66,7 +66,7 @@ void SymbolicValue::print(llvm::raw_ostream &os, unsigned indent) const {
     os << "string: \"" << getStringValue() << "\"\n";
     return;
   case RK_Aggregate: {
-    ArrayRef<SymbolicValue> elements = getAggregateValue();
+    ArrayRef<SymbolicValue> elements = getAggregateMembers();
     switch (elements.size()) {
     case 0:
       os << "agg: 0 elements []\n";
@@ -211,12 +211,12 @@ SymbolicValue::cloneInto(SymbolicValueAllocator &allocator) const {
   case RK_String:
     return SymbolicValue::getString(getStringValue(), allocator);
   case RK_Aggregate: {
-    auto elts = getAggregateValue();
+    auto elts = getAggregateMembers();
     SmallVector<SymbolicValue, 4> results;
     results.reserve(elts.size());
     for (auto elt : elts)
       results.push_back(elt.cloneInto(allocator));
-    return getAggregate(results, allocator);
+    return getAggregate(results, getAggregateType(), allocator);
   }
   case RK_EnumWithPayload: {
     return getEnumWithPayload(
@@ -350,24 +350,71 @@ StringRef SymbolicValue::getStringValue() const {
 // Aggregates
 //===----------------------------------------------------------------------===//
 
-/// 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,
-                                          SymbolicValueAllocator &allocator) {
-  // Copy the elements into the bump pointer.
-  auto *resultElts = allocator.allocate<SymbolicValue>(elements.size());
-  std::uninitialized_copy(elements.begin(), elements.end(), resultElts);
+namespace swift {
+
+/// Representation of a constant aggregate namely a struct or a tuple.
+struct AggregateSymbolicValue final
+    : private llvm::TrailingObjects<AggregateSymbolicValue, SymbolicValue> {
+  friend class llvm::TrailingObjects<AggregateSymbolicValue, SymbolicValue>;
+
+  const Type aggregateType;
+
+  const unsigned numElements;
+
+  static AggregateSymbolicValue *create(ArrayRef<SymbolicValue> members,
+                                        Type aggregateType,
+                                        SymbolicValueAllocator &allocator) {
+    auto byteSize =
+        AggregateSymbolicValue::totalSizeToAlloc<SymbolicValue>(members.size());
+    auto rawMem = allocator.allocate(byteSize, alignof(AggregateSymbolicValue));
+
+    //  Placement initialize the object.
+    auto *aggregate =
+        ::new (rawMem) AggregateSymbolicValue(aggregateType, members.size());
+    std::uninitialized_copy(members.begin(), members.end(),
+                            aggregate->getTrailingObjects<SymbolicValue>());
+    return aggregate;
+  }
+
+  /// Return the type of the aggregate.
+  Type getAggregateType() const { return aggregateType; }
 
+  /// Return the symbolic values of members.
+  ArrayRef<SymbolicValue> getMemberValues() const {
+    return {getTrailingObjects<SymbolicValue>(), numElements};
+  }
+
+  // This is used by the llvm::TrailingObjects base class.
+  size_t numTrailingObjects(OverloadToken<SymbolicValue>) const {
+    return numElements;
+  }
+
+private:
+  AggregateSymbolicValue() = delete;
+  AggregateSymbolicValue(const AggregateSymbolicValue &) = delete;
+  AggregateSymbolicValue(Type aggregateType, unsigned numElements)
+      : aggregateType(aggregateType), numElements(numElements) {}
+};
+} // namespace swift
+
+SymbolicValue SymbolicValue::getAggregate(ArrayRef<SymbolicValue> members,
+                                          Type aggregateType,
+                                          SymbolicValueAllocator &allocator) {
   SymbolicValue result;
   result.representationKind = RK_Aggregate;
-  result.value.aggregate = resultElts;
-  result.auxInfo.aggregateNumElements = elements.size();
+  result.value.aggregate =
+      AggregateSymbolicValue::create(members, aggregateType, allocator);
   return result;
 }
 
-ArrayRef<SymbolicValue> SymbolicValue::getAggregateValue() const {
+ArrayRef<SymbolicValue> SymbolicValue::getAggregateMembers() const {
   assert(getKind() == Aggregate);
-  return ArrayRef<SymbolicValue>(value.aggregate, auxInfo.aggregateNumElements);
+  return value.aggregate->getMemberValues();
+}
+
+Type SymbolicValue::getAggregateType() const {
+  assert(getKind() == Aggregate);
+  return value.aggregate->getAggregateType();
 }
 
 //===----------------------------------------------------------------------===//
@@ -770,7 +817,7 @@ SymbolicValue SymbolicValue::lookThroughSingleElementAggregates() const {
   while (1) {
     if (result.getKind() != Aggregate)
       return result;
-    auto elts = result.getAggregateValue();
+    auto elts = result.getAggregateMembers();
     if (elts.size() != 1)
       return result;
     result = elts[0];
@@ -1009,7 +1056,7 @@ static SymbolicValue getIndexedElement(SymbolicValue aggregate,
     elt = aggregate.getStoredElements(arrayEltTy)[elementNo];
     eltType = arrayEltTy;
   } else {
-    elt = aggregate.getAggregateValue()[elementNo];
+    elt = aggregate.getAggregateMembers()[elementNo];
     if (auto *decl = type->getStructOrBoundGenericStruct()) {
       eltType = decl->getStoredProperties()[elementNo]->getType();
     } else if (auto tuple = type->getAs<TupleType>()) {
@@ -1063,7 +1110,7 @@ static SymbolicValue setIndexedElement(SymbolicValue aggregate,
 
     SmallVector<SymbolicValue, 4> newElts(numMembers,
                                           SymbolicValue::getUninitMemory());
-    aggregate = SymbolicValue::getAggregate(newElts, allocator);
+    aggregate = SymbolicValue::getAggregate(newElts, type, allocator);
   }
 
   assert((aggregate.getKind() == SymbolicValue::Aggregate ||
@@ -1080,7 +1127,7 @@ static SymbolicValue setIndexedElement(SymbolicValue aggregate,
     oldElts = aggregate.getStoredElements(arrayEltTy);
     eltType = arrayEltTy;
   } else {
-    oldElts = aggregate.getAggregateValue();
+    oldElts = aggregate.getAggregateMembers();
     if (auto *decl = type->getStructOrBoundGenericStruct()) {
       eltType = decl->getStoredProperties()[elementNo]->getType();
     } else if (auto tuple = type->getAs<TupleType>()) {
@@ -1097,8 +1144,12 @@ static SymbolicValue setIndexedElement(SymbolicValue aggregate,
       setIndexedElement(newElts[elementNo], accessPath.drop_front(), newElement,
                         eltType, allocator);
 
-  if (aggregate.getKind() == SymbolicValue::Aggregate)
-    return SymbolicValue::getAggregate(newElts, allocator);
+  if (aggregate.getKind() == SymbolicValue::Aggregate) {
+    Type aggregateType = aggregate.getAggregateType();
+    assert(aggregateType->isEqual(type) &&
+           "input type does not match the type of the aggregate");
+    return SymbolicValue::getAggregate(newElts, aggregateType, allocator);
+  }
 
   return aggregate = SymbolicValue::getSymbolicArrayStorage(
              newElts, eltType->getCanonicalType(), allocator);

lib/SILOptimizer/Mandatory/OSLogOptimization.cpp

@@ -722,7 +722,7 @@ static bool checkOSLogMessageIsConstant(SingleValueInstruction *osLogMessage,
   // The first (and only) property of OSLogMessage is the OSLogInterpolation
   // instance.
   SymbolicValue osLogInterpolationValue =
-      osLogMessageValueOpt->getAggregateValue()[0];
+      osLogMessageValueOpt->getAggregateMembers()[0];
   if (!osLogInterpolationValue.isConstant()) {
     diagnose(astContext, sourceLoc, diag::oslog_non_constant_interpolation);
     return true;
@@ -743,7 +743,7 @@ static bool checkOSLogMessageIsConstant(SingleValueInstruction *osLogMessage,
 
   auto propertyDecls = interpolationStruct->getStoredProperties();
   ArrayRef<SymbolicValue> propertyValues =
-      osLogInterpolationValue.getAggregateValue();
+      osLogInterpolationValue.getAggregateMembers();
   auto propValueI = propertyValues.begin();
   bool errorDetected = false;