[ctor-eval] Eval and store changes to globals (#4430)

This is necessary for being able to optimize real-world code, as it lets us
use the stack pointer for example. With this PR we allow changes to
globals, and we simply store the final state of the global in the global at
the end. Basically the same as we do for memory, but for globals.

Remove a test that now fails ("imported2"). Replace it with a nicer test
of saving the values of globals. Also add a test for an imported global,
which we do not allow (we never did, but I don't see a test for it).

Author: kripken

src/tools/wasm-ctor-eval.cpp

@@ -62,15 +62,6 @@ class EvallingGlobalManager {
 
   void seal() { sealed = true; }
 
-  // for equality purposes, we just care about the globals
-  // and whether they have changed
-  bool operator==(const EvallingGlobalManager& other) {
-    return globals == other.globals;
-  }
-  bool operator!=(const EvallingGlobalManager& other) {
-    return !(*this == other);
-  }
-
   Literals& operator[](Name name) {
     if (dangerousGlobals.count(name) > 0) {
       std::string extra;
@@ -110,6 +101,15 @@ class EvallingGlobalManager {
   }
 
   Iterator end() { return Iterator(); }
+
+  // Receives a module and applies the state of globals here into the globals
+  // in that module.
+  void applyToModule(Module& wasm) {
+    Builder builder(wasm);
+    for (const auto& [name, value] : globals) {
+      wasm.getGlobal(name)->init = builder.makeConstantExpression(value);
+    }
+  }
 };
 
 class EvallingModuleInstance
@@ -220,6 +220,8 @@ struct CtorEvalExternalInterface : EvallingModuleInstance::ExternalInterface {
     if (!memory.empty()) {
       applyMemoryToModule();
     }
+
+    instance->globals.applyToModule(*wasm);
   }
 
   void init(Module& wasm_, EvallingModuleInstance& instance_) override {
@@ -499,9 +501,6 @@ void evalCtors(Module& wasm, std::vector<std::string> ctors) {
     // TODO: if we knew priorities, we could reorder?
     for (auto& ctor : ctors) {
       std::cerr << "trying to eval " << ctor << '\n';
-      // snapshot globals (note that STACKTOP might be modified, but should
-      // be returned, so that works out)
-      auto globalsBefore = instance.globals;
       Export* ex = wasm.getExportOrNull(ctor);
       if (!ex) {
         Fatal() << "export not found: " << ctor;
@@ -514,10 +513,6 @@ void evalCtors(Module& wasm, std::vector<std::string> ctors) {
         std::cerr << "  ...stopping since could not eval: " << fail.why << "\n";
         return;
       }
-      if (instance.globals != globalsBefore) {
-        std::cerr << "  ...stopping since globals modified\n";
-        return;
-      }
       std::cerr << "  ...success on " << ctor << ".\n";
 
       // Success, the entire function was evalled! Apply the results of

test/ctor-eval/global-get-init.wast

@@ -0,0 +1,8 @@
+(module
+  (import "import" "global" (global $imported i32))
+  (func $test1 (export "test1")
+    ;; This should be safe to eval in theory, but the imported global stops us,
+    ;; so this function will not be optimized out.
+    ;; TODO: perhaps if we never use that global that is ok?
+  )
+)

test/ctor-eval/imported3.wast.ctors test/ctor-eval/global-get-init.wast.ctorstest/ctor-eval/imported3.wast.ctors renamed to test/ctor-eval/global-get-init.wast.ctors

@@ -0,0 +1,7 @@
+(module
+ (type $none_=>_none (func))
+ (export "test1" (func $test1))
+ (func $test1
+  (nop)
+ )
+)

test/ctor-eval/global-get-init.wast.out

@@ -0,0 +1,16 @@
+(module
+  (global $g1 (mut i32) (i32.const 10))
+  (global $g2 (mut i32) (i32.const 20))
+  (func $test1 (export "test1")
+    (global.set $g1 (i32.const 30))
+    (global.set $g2 (i32.const 40))
+    (global.set $g1 (i32.const 50)) ;; this overrides the previous 30
+  )
+  (func $keepalive (export "keepalive") (result i32)
+    ;; Keep the globals alive so we can see their values.
+    (i32.add
+      (global.get $g1)
+      (global.get $g2)
+    )
+  )
+)

test/ctor-eval/globals.wast

@@ -0,0 +1 @@
+test1

test/ctor-eval/globals.wast.ctors

@@ -0,0 +1,12 @@
+(module
+ (type $none_=>_i32 (func (result i32)))
+ (global $g1 (mut i32) (i32.const 50))
+ (global $g2 (mut i32) (i32.const 40))
+ (export "keepalive" (func $keepalive))
+ (func $keepalive (result i32)
+  (i32.add
+   (global.get $g1)
+   (global.get $g2)
+  )
+ )
+)

test/ctor-eval/globals.wast.out

@@ -0,0 +1 @@
+test1