Inlining: Handle local dependencies when splitting (#8064)

In pattern B there, we handle stuff like

  if (..) { .. }
  return x;

We split out the if body if it is large-enough, which allows inlining the if
condition + the return (efficient if the condition rarely happens). This did
not handle local effects: imagine that the if body contains x = 42, then
after splitting it out to another function, that value is not picked up in
the return of x. Fix that by checking local dependencies.

More detailed example:

  function foo(x) {
    if (..) {
      work();
      x = 42;
    }
    return x;
  }

  function caller() {
    foo(1);
  }

  => the incorrect optimization before =>

  function caller() {
    // inlined call, but split: just the condition + return.
    var x = 1; // inlined value sent in call
    if (..) {
      outlinedCode();
    }
    x = x;
  }

  function outlinedCode() {
    // The setting of x to 42 is done here, and not picked up
    // in the caller.
    var x;
    work();
    x = 42;
  }

After this PR, we do not do such split inlining.

Author: kripken

src/passes/Inlining.cpp

@@ -978,7 +978,19 @@ struct FunctionSplitter {
     if (finalItem && getItem(body, numIfs + 1)) {
       return InliningMode::Uninlineable;
     }
-    // This has the general shape we seek. Check each if.
+    // This has the general shape we seek. Check each if: it must be in the
+    // form mentioned above (simple condition, no returns in body). We must also
+    // have no sets of locals that the final item notices, as then we could
+    // have this:
+    //
+    //  if (A) {
+    //    x = 10;
+    //  }
+    //  return x;
+    //
+    // We cannot split out the if in such a case because of the local
+    // dependency.
+    std::unordered_set<Index> writtenLocals;
     for (Index i = 0; i < numIfs; i++) {
       auto* iff = getIf(body, i);
       // The if must have a simple condition and no else arm.
@@ -995,7 +1007,21 @@ struct FunctionSplitter {
         // unreachable, and we ruled out none before.
         assert(iff->ifTrue->type == Type::unreachable);
       }
+      if (finalItem) {
+        for (auto* set : FindAll<LocalSet>(iff).list) {
+          writtenLocals.insert(set->index);
+        }
+      }
     }
+    // Finish the locals check mentioned above.
+    if (finalItem) {
+      for (auto* get : FindAll<LocalGet>(finalItem).list) {
+        if (writtenLocals.count(get->index)) {
+          return InliningMode::Uninlineable;
+        }
+      }
+    }
+
     // Success, this matches the pattern.
 
     // If the outlined function will be worth inlining normally, skip the