RedundantLoadElim: Fix invalid destructure_struct emission without aggressive reg2mem

The `shouldExpand` in `OptUtils.swift` was incorrectly returning `true`
unconditionally when `useAggressiveReg2MemForCodeSize` was disabled. The
expansion might be invalid for types with addr-only types and structs
with deinit, but we didn't check them before. This could lead to invalid
`destructure_struct` instructions without `drop_deinit` being emitted.

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -1100,9 +1100,6 @@ extension Type {
   /// 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
-    }
     return context.bridgedPassContext.shouldExpand(self.bridged)
   }
 }

lib/SIL/Utils/InstructionUtils.cpp

@@ -1486,10 +1486,18 @@ bool swift::shouldExpand(SILModule &module, SILType ty) {
     if (nominalTy->getValueTypeDestructor())
       return false;
   }
+
+  // At this point we know it's valid to expand the type, next decide if we
+  // "should" expand it.
+
   if (EnableExpandAll) {
     return true;
   }
 
+  if (!module.getOptions().UseAggressiveReg2MemForCodeSize) {
+    return false;
+  }
+
   unsigned numFields = module.Types.countNumberOfFields(ty, expansion);
   return (numFields <= 6);
 }

test/SILOptimizer/redundant_load_elim_struct_deinit.sil

@@ -0,0 +1,44 @@
+// RUN: %target-sil-opt -module-name Swift -sil-print-types -enforce-exclusivity=none -enable-sil-verify-all %s -redundant-load-elimination | %FileCheck %s
+// RUN: %target-sil-opt -module-name Swift -sil-print-types -enforce-exclusivity=none -enable-sil-verify-all %s -redundant-load-elimination -disable-aggressive-reg2mem | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+
+import Builtin
+
+@_marker protocol Copyable {}
+
+final class C1 {}
+
+struct S1 {}
+
+struct StructWithDeinit : ~Copyable {
+  // stored class-instance to ensure this struct has a non-trivial
+  var f1: C1
+  var f2: S1
+  deinit
+}
+
+// CHECK-LABEL: sil [ossa] @test : $@convention(thin) (@owned StructWithDeinit, @owned S1) -> ()
+// CHECK:   %[[STACK:.*]] = alloc_stack $StructWithDeinit
+// CHECK:   load [take] %[[STACK]] : $*StructWithDeinit
+// CHECK: } // end sil function 'test'
+sil [ossa] @test : $@convention(thin) (@owned StructWithDeinit, @owned S1) -> () {
+bb0(%0 : @owned $StructWithDeinit, %1 : $S1):
+  %2 = alloc_stack $StructWithDeinit
+  store %0 to [init] %2
+  // partial store into f2
+  %3 = struct_element_addr %2, #StructWithDeinit.f2
+  store %1 to [trivial] %3
+
+  // redundant load of the whole struct
+  %4 = load [take] %2
+  destroy_value %4
+
+  dealloc_stack %2
+  %5 = tuple ()
+  return %5
+}
+
+sil @s1_deinit : $@convention(method) (@owned StructWithDeinit) -> ()
+sil_moveonlydeinit StructWithDeinit { @s1_deinit }
+