Merge pull request #63935 from aschwaighofer/resolve_rebranch

Merge remote-tracking branch 'origin/main' into rebranch

Author: aschwaighofer

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -98,14 +98,14 @@ struct AliasAnalysis {
       },
 
       // isAddrVisibleFromObj
-      { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue) -> Bool in
+      { (bridgedCtxt: BridgedPassContext, bridgedAddr: BridgedValue, bridgedObj: BridgedValue, complexityBudget: Int) -> Bool in
         let context = FunctionPassContext(_bridged: bridgedCtxt)
         let addr = bridgedAddr.value.at(AliasAnalysis.getPtrOrAddressPath(for: bridgedAddr.value))
 
         // This is similar to `canReferenceSameFieldFn`, except that all addresses of all objects are
         // considered which are transitively visible from `bridgedObj`.
         let anythingReachableFromObj = bridgedObj.value.at(SmallProjectionPath(.anything))
-        return addr.canAddressAlias(with: anythingReachableFromObj, context)
+        return addr.canAddressAlias(with: anythingReachableFromObj, complexityBudget: complexityBudget, context)
       },
 
       // canReferenceSameFieldFn

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -75,8 +75,9 @@ extension ProjectedValue {
   /// the walk. See `EscapeVisitor` for details.
   ///
   func isEscaping(using visitor: some EscapeVisitor = DefaultVisitor(),
+                  complexityBudget: Int = Int.max,
                   _ context: some Context) -> Bool {
-    var walker = EscapeWalker(visitor: visitor, context)
+    var walker = EscapeWalker(visitor: visitor, complexityBudget: complexityBudget, context)
     return walker.walkUp(addressOrValue: value, path: path.escapePath) == .abortWalk
   }
 
@@ -287,9 +288,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
                                                     AddressUseDefWalker {
   typealias Path = EscapeUtilityTypes.EscapePath
 
-  init(visitor: V, _ context: some Context) {
+  init(visitor: V, complexityBudget: Int = Int.max, _ context: some Context) {
     self.calleeAnalysis = context.calleeAnalysis
     self.visitor = visitor
+    self.complexityBudget = complexityBudget
   }
 
   //===--------------------------------------------------------------------===//
@@ -313,6 +315,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkDown(value: Operand, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(value.value) {
+      return .abortWalk
+    }
     if hasRelevantType(value.value, at: path.projectionPath) {
       switch visitor.visitUse(operand: value, path: path) {
       case .continueWalk:
@@ -409,6 +414,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkDown(address: Operand, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(address.value) {
+      return .abortWalk
+    }
     if hasRelevantType(address.value, at: path.projectionPath) {
       switch visitor.visitUse(operand: address, path: path) {
       case .continueWalk:
@@ -508,7 +516,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
       return .continueWalk
     }
     if !visitor.followLoads && p.matches(pattern: SmallProjectionPath(.anyValueFields).push(.anyClassField)) {
-      // Any address of a class property of the object to destroy cannot esacpe the destructor.
+      // Any address of a class property of the object to destroy cannot escape the destructor.
       // (Whereas a value stored in such a property could escape.)
       return .continueWalk
     }
@@ -644,6 +652,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkUp(value: Value, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(value) {
+      return .abortWalk
+    }
     if hasRelevantType(value, at: path.projectionPath) {
       switch visitor.visitDef(def: value, path: path) {
       case .continueWalkUp:
@@ -697,6 +708,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   }
 
   mutating func walkUp(address: Value, path: Path) -> WalkResult {
+    if complexityBudgetExceeded(address) {
+      return .abortWalk
+    }
     if hasRelevantType(address, at: path.projectionPath) {
       switch visitor.visitDef(def: address, path: path) {
       case .continueWalkUp:
@@ -785,6 +799,10 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
   var walkDownCache = WalkerCache<Path>()
   var walkUpCache = WalkerCache<Path>()
 
+  // Only this number of up/and down walks are done until the walk aborts.
+  // Used to avoid quadratic complexity in some scenarios.
+  var complexityBudget: Int
+
   private let calleeAnalysis: CalleeAnalysis
 
   //===--------------------------------------------------------------------===//
@@ -825,6 +843,14 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     return path.popLastClassAndValuesFromTail()
   }
 
+  private mutating func complexityBudgetExceeded(_ v: Value) -> Bool {
+    if complexityBudget <= 0 {
+      return true
+    }
+    complexityBudget = complexityBudget &- 1
+    return false
+  }
+
   // Set a breakpoint here to debug when a value is escaping.
   private var isEscaping: WalkResult { .abortWalk }
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -221,15 +221,15 @@ extension ProjectedValue {
   /// `%s`.canAddressAlias(with: `%2`) -> true
   /// `%1`.canAddressAlias(with: `%2`) -> false
   ///
-  func canAddressAlias(with rhs: ProjectedValue, _ context: some Context) -> Bool {
+  func canAddressAlias(with rhs: ProjectedValue, complexityBudget: Int = Int.max, _ context: some Context) -> Bool {
     // self -> rhs will succeed (= return false) if self is a non-escaping "local" object,
     // but not necessarily rhs.
-    if !isEscaping(using: EscapesToValueVisitor(target: rhs), context) {
+    if !isEscaping(using: EscapesToValueVisitor(target: rhs), complexityBudget: complexityBudget, context) {
       return false
     }
     // The other way round: rhs -> self will succeed if rhs is a non-escaping "local" object,
     // but not necessarily self.
-    if !rhs.isEscaping(using: EscapesToValueVisitor(target: self), context) {
+    if !rhs.isEscaping(using: EscapesToValueVisitor(target: self), complexityBudget: complexityBudget, context) {
       return false
     }
     return true

docs/ABI/Mangling.rst

@@ -887,8 +887,10 @@ now codified into the ABI; the index 0 is therefore reserved.
 
 ::
 
-  generic-signature ::= requirement* 'l'     // one generic parameter
-  generic-signature ::= requirement* 'r' GENERIC-PARAM-COUNT* 'l'
+  generic-signature ::= requirement* generic-param-pack-marker* 'l'     // one generic parameter
+  generic-signature ::= requirement* generic-param-pack-marker* 'r' GENERIC-PARAM-COUNT* 'l'
+
+  generic-param-pack-marker ::= 'Rv' GENERIC_PARAM-INDEX   // generic parameter pack marker
 
   GENERIC-PARAM-COUNT ::= 'z'                // zero parameters
   GENERIC-PARAM-COUNT ::= INDEX              // N+1 parameters
@@ -931,9 +933,11 @@ now codified into the ABI; the index 0 is therefore reserved.
   LAYOUT-SIZE ::= INDEX // Size only
   LAYOUT-SIZE-AND-ALIGNMENT ::= INDEX INDEX // Size followed by alignment
 
+A generic signature begins with an optional list of requirements.
 
+This is followed by an optional list of generic-param-pack-markers to record
+which generic parameters are packs (variadic).
 
-A generic signature begins with an optional list of requirements.
 The ``<GENERIC-PARAM-COUNT>`` describes the number of generic parameters at
 each depth of the signature. As a special case, no ``<GENERIC-PARAM-COUNT>``
 values indicates a single generic parameter at the outermost depth::

docs/proposals/RuntimeValueWitness.rst

@@ -58,6 +58,7 @@ copied, but do not need to be released or retained.
    I16 = 's',
    I32 = 'l',
    I64 = 'L',
+   I128 = 'Q',
 
 We also have reference types. While they are all 64bit sized, we need to
 differentiate between them because they have different ways of being

include/swift/ABI/Metadata.h

@@ -116,6 +116,15 @@ struct MetadataDependency {
   }
 };
 
+/// Prefix of a metadata header, containing a pointer to the
+/// type layout string.
+template <typename Runtime>
+struct TargetTypeMetadataLayoutPrefix {
+    TargetSignedPointer<Runtime, const uint8_t *
+                                      __ptrauth_swift_type_layout_string>
+        layoutString;
+};
+
 /// The header before a metadata object which appears on all type
 /// metadata.  Note that heap metadata are not necessarily type
 /// metadata, even for objects of a heap type: for example, objects of
@@ -124,11 +133,25 @@ struct MetadataDependency {
 /// This case can be distinguished using the isTypeMetadata() flag
 /// on ClassMetadata.
 template <typename Runtime>
-struct TargetTypeMetadataHeader {
+struct TargetTypeMetadataHeaderBase {
   /// A pointer to the value-witnesses for this type.  This is only
   /// present for type metadata.
   TargetPointer<Runtime, const ValueWitnessTable> ValueWitnesses;
 };
+
+template <typename Runtime>
+struct TargetTypeMetadataHeader
+    : TargetTypeMetadataLayoutPrefix<Runtime>,
+      TargetTypeMetadataHeaderBase<Runtime> {
+
+  TargetTypeMetadataHeader() = default;
+  constexpr TargetTypeMetadataHeader(
+    const TargetTypeMetadataLayoutPrefix<Runtime> &layout,
+    const TargetTypeMetadataHeaderBase<Runtime> &header)
+      : TargetTypeMetadataLayoutPrefix<Runtime>(layout),
+        TargetTypeMetadataHeaderBase<Runtime>(header) {}
+};
+
 using TypeMetadataHeader = TargetTypeMetadataHeader<InProcess>;
 
 /// A "full" metadata pointer is simply an adjusted address point on a
@@ -284,6 +307,17 @@ struct TargetMetadata {
     return isAnyKindOfClass(getKind());
   }
 
+  const uint8_t *getLayoutString() const {
+    assert(hasLayoutString());
+    if (isAnyClass()) {
+      return asFullMetadata(
+                 reinterpret_cast<const TargetAnyClassMetadata<Runtime> *>(
+                     this))
+          ->layoutString;
+    }
+    return asFullMetadata(this)->layoutString;
+  }
+
   const ValueWitnessTable *getValueWitnesses() const {
     return asFullMetadata(this)->ValueWitnesses;
   }
@@ -295,6 +329,19 @@ struct TargetMetadata {
   void setValueWitnesses(const ValueWitnessTable *table) {
     asFullMetadata(this)->ValueWitnesses = table;
   }
+
+  void setLayoutString(const uint8_t *layoutString) {
+    if (isAnyClass()) {
+      asFullMetadata(reinterpret_cast<TargetAnyClassMetadata<Runtime> *>(this))
+          ->layoutString = layoutString;
+    } else {
+      asFullMetadata(this)->layoutString = layoutString;
+    }
+  }
+
+  bool hasLayoutString() const {
+    return getTypeContextDescriptor()->hasLayoutString();
+  }
 
   // Define forwarders for value witnesses. These invoke this metadata's value
   // witness table with itself as the 'self' parameter.
@@ -445,7 +492,7 @@ struct TargetMetadata {
 /// The common structure of opaque metadata.  Adds nothing.
 template <typename Runtime>
 struct TargetOpaqueMetadata {
-  typedef TargetTypeMetadataHeader<Runtime> HeaderType;
+  typedef TargetTypeMetadataHeaderBase<Runtime> HeaderType;
 
   // We have to represent this as a member so we can list-initialize it.
   TargetMetadata<Runtime> base;
@@ -469,13 +516,16 @@ using HeapMetadataHeaderPrefix =
 /// The header present on all heap metadata.
 template <typename Runtime>
 struct TargetHeapMetadataHeader
-    : TargetHeapMetadataHeaderPrefix<Runtime>,
-      TargetTypeMetadataHeader<Runtime> {
+    : TargetTypeMetadataLayoutPrefix<Runtime>,
+      TargetHeapMetadataHeaderPrefix<Runtime>,
+      TargetTypeMetadataHeaderBase<Runtime> {
   constexpr TargetHeapMetadataHeader(
+      const TargetTypeMetadataLayoutPrefix<Runtime> &typeLayoutPrefix,
       const TargetHeapMetadataHeaderPrefix<Runtime> &heapPrefix,
-      const TargetTypeMetadataHeader<Runtime> &typePrefix)
-    : TargetHeapMetadataHeaderPrefix<Runtime>(heapPrefix),
-      TargetTypeMetadataHeader<Runtime>(typePrefix) {}
+      const TargetTypeMetadataHeaderBase<Runtime> &typePrefix)
+    : TargetTypeMetadataLayoutPrefix<Runtime>(typeLayoutPrefix),
+      TargetHeapMetadataHeaderPrefix<Runtime>(heapPrefix),
+      TargetTypeMetadataHeaderBase<Runtime>(typePrefix) {}
 };
 using HeapMetadataHeader =
   TargetHeapMetadataHeader<InProcess>;
@@ -1511,6 +1561,7 @@ using MetatypeMetadata = TargetMetatypeMetadata<InProcess>;
 template <typename Runtime>
 struct TargetTupleTypeMetadata : public TargetMetadata<Runtime> {
   using StoredSize = typename Runtime::StoredSize;
+  using HeaderType = TargetTypeMetadataHeaderBase<Runtime>;
   TargetTupleTypeMetadata() = default;
   constexpr TargetTupleTypeMetadata(const TargetMetadata<Runtime> &base,
                                     uint32_t numElements,
@@ -1696,6 +1747,7 @@ struct TargetExistentialTypeMetadata
       TargetExistentialTypeMetadata<Runtime>,
       ConstTargetMetadataPointer<Runtime, TargetMetadata>,
       TargetProtocolDescriptorRef<Runtime>> {
+  using HeaderType = TargetTypeMetadataHeaderBase<Runtime>;
 
 private:
   using ProtocolDescriptorRef = TargetProtocolDescriptorRef<Runtime>;
@@ -3642,6 +3694,10 @@ class TargetTypeContextDescriptor
     return getTypeContextDescriptorFlags().hasCanonicalMetadataPrespecializations();
   }
 
+  bool hasLayoutString() const {
+    return getTypeContextDescriptorFlags().hasLayoutString();
+  }
+
   /// Given that this type has foreign metadata initialization, return the
   /// control structure for it.
   const TargetForeignMetadataInitialization<Runtime> &

include/swift/ABI/MetadataValues.h

@@ -1445,6 +1445,8 @@ namespace SpecialPointerAuthDiscriminators {
 
   // Relative protocol witness table descriminator
   const uint16_t RelativeProtocolWitnessTable = 0xb830; // = 47152
+
+  const uint16_t TypeLayoutString = 0x8b65; // = 35685
 }
 
 /// The number of arguments that will be passed directly to a generic
@@ -1598,6 +1600,9 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
     /// prespecializations.
     HasCanonicalMetadataPrespecializations = 3,
 
+    /// Set if the metadata contains a pointer to a layout string
+    HasLayoutString = 4,
+
     // Type-specific flags:
 
     /// Set if the class is an actor.
@@ -1680,6 +1685,10 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
 
   FLAGSET_DEFINE_FLAG_ACCESSORS(HasCanonicalMetadataPrespecializations, hasCanonicalMetadataPrespecializations, setHasCanonicalMetadataPrespecializations)
 
+  FLAGSET_DEFINE_FLAG_ACCESSORS(HasLayoutString,
+                                hasLayoutString,
+                                setHasLayoutString)
+
   FLAGSET_DEFINE_FLAG_ACCESSORS(Class_HasVTable,
                                 class_hasVTable,
                                 class_setHasVTable)

include/swift/AST/GenericEnvironment.h

@@ -38,8 +38,10 @@ class OpaqueTypeDecl;
 class ElementArchetypeType;
 class OpenedArchetypeType;
 class PackArchetypeType;
+class PackExpansionType;
 class SILModule;
 class SILType;
+template <class> class CanTypeWrapper;
 
 /// Query function suitable for use as a \c TypeSubstitutionFn that queries
 /// the mapping of interface types to archetypes.
@@ -310,6 +312,23 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   SWIFT_DEBUG_DUMP;
 };
+
+/// A pair of an opened-element generic signature and an opened-element
+/// generic environment.
+struct OpenedElementContext {
+  /// The opened-element environment for this expansion.
+  GenericEnvironment *environment;
+
+  /// The opened-element signature for this expansion.
+  CanGenericSignature signature;
+
+  /// Create a fresh opened element context from a contextual pack
+  /// expansion type.  This is useful when writing code that needs to
+  /// break down the components of a pack expansion.
+  static OpenedElementContext
+  createForContextualExpansion(ASTContext &ctx,
+                   CanTypeWrapper<PackExpansionType> expansionType);
+};
 
 } // end namespace swift
 

include/swift/AST/IRGenOptions.h

@@ -207,6 +207,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
 
   /// Relative protocol witness table descriminator.
   PointerAuthSchema RelativeProtocolWitnessTable;
+
+  /// Type layout string descriminator.
+  PointerAuthSchema TypeLayoutString;
 };
 
 enum class JITDebugArtifact : unsigned {
@@ -422,6 +425,9 @@ class IRGenOptions {
   /// Collocate metadata functions in their own section.
   unsigned CollocatedMetadataFunctions : 1;
 
+  /// Colocate type descriptors in their own section.
+  unsigned ColocateTypeDescriptors : 1;
+
   /// Use relative (and constant) protocol witness tables.
   unsigned UseRelativeProtocolWitnessTables : 1;
 
@@ -497,6 +503,7 @@ class IRGenOptions {
         EmitGenericRODatas(false), NoPreallocatedInstantiationCaches(false),
         DisableReadonlyStaticObjects(false),
         CollocatedMetadataFunctions(false),
+        ColocateTypeDescriptors(true),
         UseRelativeProtocolWitnessTables(false), CmdArgs(),
         SanitizeCoverage(llvm::SanitizerCoverageOptions()),
         TypeInfoFilter(TypeInfoDumpFilter::All) {