Add comments to SwiftCompilerSources for shouldExpand()

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DeadStoreElimination.swift

@@ -75,6 +75,9 @@ let deadStoreElimination = FunctionPass(name: "dead-store-elimination") {
 }
 
 private func tryEliminate(store: StoreInst, complexityBudget: inout Int, _ context: FunctionPassContext) {
+  // Check if the type can be expanded without a significant increase to code
+  // size. This pass splits values into its consitutent parts which effectively
+  // expands the value into projections which can increase code size.
   if !store.hasValidOwnershipForDeadStoreElimination || !store.source.type.shouldExpand(context) {
     return
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -97,6 +97,12 @@ private func eliminateRedundantLoads(in function: Function, ignoreArrays: Bool,
         {
           continue
         }
+        // Check if the type can be expanded without a significant increase to
+        // code size.
+        // We block redundant load elimination because it might increase
+        // register pressure for large values. Furthermore, this pass also
+        // splits values into its projections (e.g
+        // shrinkMemoryLifetimeAndSplit).
         if !load.type.shouldExpand(context) {
            continue
         }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -811,6 +811,19 @@ extension CheckedCastAddrBranchInst {
 }
 
 extension Type {
+  /// True if a type can be expanded without a significant increase to code
+  /// size.
+  /// Expanding a type can mean expressing it as a SSA value (which ultimately
+  /// is represented as multiple SSA values in LLVM IR) instead of indirectly
+  /// via memory operations (copy_addr), or exploding an SSA value into its
+  /// constituent projections.
+  /// Once a value is represented as its projections we don't "reconstitute" the
+  /// aggregate value anymore leading to register pressure and code size bloat.
+  /// Therefore, we try to keep "larger" values indirect and not exploated
+  /// throughout the pipeline.
+  ///
+  /// False if expanding a type is invalid. For example, expanding a
+  /// struct-with-deinit drops the deinit.
   func shouldExpand(_ context: some Context) -> Bool {
     if !context.options.useAggressiveReg2MemForCodeSize {
       return true