Push struct.new down to make it more likely that heap stores can be optimized.

src/passes/OptimizeInstructions.cpp

@@ -1882,17 +1882,33 @@ struct OptimizeInstructions
 
       // This local.set of a struct.new looks good. Find struct.sets after it
       // to optimize.
-      for (Index j = i + 1; j < list.size(); j++) {
+      Index localSetIndex = i;
+      for (Index j = localSetIndex + 1; j < list.size(); j++) {
         auto* structSet = list[j]->dynCast<StructSet>();
+        // Any time the pattern no longer matches, we try to push the
+        // struct.new further down but if it is not possible we stop
+        // optimizing possible struct.sets for this struct.new.
+
         if (!structSet) {
-          // Any time the pattern no longer matches, stop optimizing possible
-          // struct.sets for this struct.new.
+          if (trySwap(list, localSetIndex, j)) {
+            // Update the index an continue to try again.
+            localSetIndex = j;
+            continue;
+          }
           break;
         }
+
         auto* localGet = structSet->ref->dynCast<LocalGet>();
         if (!localGet || localGet->index != localSet->index) {
+          if (trySwap(list, localSetIndex, j)) {
+            // Update the index an continue to try again.
+            localSetIndex = j;
+            continue;
+          }
           break;
         }
+
+        // The pattern matches, try to optimize.
         if (!optimizeSubsequentStructSet(new_, structSet, localGet->index)) {
           break;
         } else {
@@ -1904,6 +1920,39 @@ struct OptimizeInstructions
     }
   }
 
+  // Tries pushing the struct.new down so that it is closer
+  // to a potential struct.set.
+  bool trySwap(ExpressionList& list, Index i, Index j) {
+    if (j == list.size() - 1) {
+      // There is no reason to swap with the last element
+      // of the list as it won't match the pattern.
+      return false;
+    }
+
+    if (list[j]->is<LocalSet>() &&
+        list[j]->dynCast<LocalSet>()->value->is<StructNew>()) {
+      // Don't swap two struct.new instructions to avoid going back and forth.
+      return false;
+    }
+    // Check if the local is referencenced by the instruction we want to
+    // swap it with,
+    auto* localSet = list[i]->dynCast<LocalSet>();
+    auto otherEffects = effects(list[j]);
+    if (otherEffects.localsRead.count(localSet->index) ||
+        otherEffects.localsWritten.count(localSet->index)) {
+      return false;
+    }
+    // or if the effects don't permit moving one past the other.
+    auto structNewEffects = effects(localSet->value);
+    if (otherEffects.invalidates(structNewEffects)) {
+      return false;
+    }
+
+    list[i] = list[j];
+    list[j] = localSet;
+    return true;
+  }
+
   // Given a struct.new and a struct.set that occurs right after it, and that
   // applies to the same data, try to apply the set during the new. This can be
   // either with a nested tee:

test/lit/passes/optimize-instructions-gc-heap.wast

@@ -1,5 +1,5 @@
 ;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
-;; RUN: wasm-opt %s --remove-unused-names --optimize-instructions -all -S -o - \
+;; RUN: wasm-opt %s --remove-unused-names --optimize-instructions  -all -S -o - \
 ;; RUN:   | filecheck %s
 ;;
 ;; --remove-unused-names allows the optimizer to see that the blocks have no
@@ -9,11 +9,10 @@
   ;; CHECK:      (type $struct (struct (field (mut i32))))
   (type $struct (struct (field (mut i32))))
 
-  ;; CHECK:      (type $struct3 (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))
-
   ;; CHECK:      (type $struct2 (struct (field (mut i32)) (field (mut i32))))
   (type $struct2 (struct (field (mut i32)) (field (mut i32))))
 
+  ;; CHECK:      (type $struct3 (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))
   (type $struct3 (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))
 
   ;; CHECK:      (func $tee (type $1)
@@ -272,26 +271,31 @@
 
   ;; CHECK:      (func $pattern-breaker (type $1)
   ;; CHECK-NEXT:  (local $ref (ref null $struct))
+  ;; CHECK-NEXT:  (local $ref2 (ref null $struct))
   ;; CHECK-NEXT:  (local.set $ref
   ;; CHECK-NEXT:   (struct.new $struct
   ;; CHECK-NEXT:    (i32.const 10)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
-  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (local.set $ref2
+  ;; CHECK-NEXT:   (local.get $ref)
+  ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (struct.set $struct 0
   ;; CHECK-NEXT:   (local.get $ref)
   ;; CHECK-NEXT:   (i32.const 20)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $pattern-breaker
     (local $ref (ref null $struct))
+    (local $ref2 (ref null $struct))
     (local.set $ref
       (struct.new $struct
         (i32.const 10)
       )
     )
-    ;; Anything that we don't recognize breaks the pattern.
-    (nop)
+    ;; Any instruction that can not be swapped and is not
+    ;; the expected struct.set breaks the pattern.
+    (local.set $ref2 (local.get $ref))
     (struct.set $struct 0
       (local.get $ref)
       (i32.const 20)
@@ -611,20 +615,17 @@
   ;; CHECK:      (func $many-news (type $1)
   ;; CHECK-NEXT:  (local $ref (ref null $struct3))
   ;; CHECK-NEXT:  (local $ref2 (ref null $struct3))
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (nop)
+  ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT:  (local.set $ref
   ;; CHECK-NEXT:   (struct.new $struct3
   ;; CHECK-NEXT:    (i32.const 40)
   ;; CHECK-NEXT:    (i32.const 50)
-  ;; CHECK-NEXT:    (i32.const 30)
+  ;; CHECK-NEXT:    (i32.const 60)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
-  ;; CHECK-NEXT:  (nop)
-  ;; CHECK-NEXT:  (nop)
-  ;; CHECK-NEXT:  (struct.set $struct3 2
-  ;; CHECK-NEXT:   (local.get $ref)
-  ;; CHECK-NEXT:   (i32.const 60)
-  ;; CHECK-NEXT:  )
-  ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT:  (local.set $ref
   ;; CHECK-NEXT:   (struct.new $struct3
   ;; CHECK-NEXT:    (i32.const 400)