[ctor-eval] Partial evaluation (#4438)

This lets us eval part of a function but not all, which is necessary to handle
real-world things like __wasm_call_ctors in LLVM output, as that is the
single ctor that is exported and it has calls to the actual ctors.

To do so, we look for a toplevel block and execute its items one by one, in
a FunctionScope. If we stop in the middle, then we are performing a partial
eval. In that case, we only remove the parts of the function that we removed,
and we also serialize the locals whose values we read from the
FunctionScope.

For example, consider this:

function foo() {
  return 10;
}

function __wasm_call_ctors() {
  var x;
  x = foo();
  x++;
  // We stop evalling here.
  import1();
  import2(x);
}

We can eval x = foo() and x++, but we must stop evalling when
we reach the first of those imports. The partially-evalled function
then looks like this:

function __wasm_call_ctors() {
  var x;
  x = 11;
  import1();
  import2(x);
}

That is, we evalled two lines of executing code and simply removed
them, and then we wrote out the value of the local at that point, and then
the rest of the code in the function is as it used to be.

1 files changed, 38 insertions, 0 deletions

diff --git a/test/ctor-eval/partial-locals-tee.wast b/test/ctor-eval/partial-locals-tee.wast
new file mode 100644
index 000000000..37dac176a
--- /dev/null
+++ b/test/ctor-eval/partial-locals-tee.wast
@@ -0,0 +1,38 @@
+(module
+  (import "import" "import" (func $import (param i32 i32)))
+
+  (memory 256 256)
+  (data (i32.const 10) "_________________")
+
+  (export "test1" $test1)
+
+  (func $test1
+    (local $temp i32)
+
+    ;; Increment $temp from 0 to 1, which we can eval.
+    (local.set $temp
+      (i32.add
+        (local.get $temp)
+        (i32.const 1)
+      )
+    )
+
+    ;; A safe store that will be evalled and alter memory.
+    (i32.store8 (i32.const 12) (i32.const 115))
+
+    ;; A call to an import, which prevents evalling. We will stop here. The
+    ;; 'tee' instruction should *not* have any effect, that is, we should not
+    ;; partially eval this line in the block - we should eval none of it.
+    ;; TODO: We should support such partial line evalling, with more careful
+    ;;       management of locals.
+    (call $import
+      (local.get $temp) ;; The value sent here should be '1'.
+      (local.tee $temp
+        (i32.const 50)
+      )
+    )
+
+    ;; A safe store that we never reach
+    (i32.store8 (i32.const 13) (i32.const 115))
+  )
+)