[ctor-eval] Eval functions with a return value (#4443)

This is necessary for e.g. main() which returns an i32.

Author: kripken

src/tools/wasm-ctor-eval.cpp

@@ -489,27 +489,36 @@ struct CtorEvalExternalInterface : EvallingModuleInstance::ExternalInterface {
   }
 };
 
+struct EvalCtorOutcome {
+  // Whether we completely evalled the function (that is, we did not fail, and
+  // we did not only partially eval it).
+  bool evalledCompletely;
+
+  // If the function was evalled completely, and it returns something, that
+  // value is given here.
+  Literals results;
+
+  static EvalCtorOutcome incomplete() { return {false, Literals()}; }
+
+  static EvalCtorOutcome complete(Literals results) { return {true, results}; }
+};
+
 // Eval a single ctor function. Returns whether we succeeded to completely
-// evaluate the ctor, which means that the caller can proceed to try to eval
-// further ctors if there are any.
-bool evalCtor(EvallingModuleInstance& instance,
-              CtorEvalExternalInterface& interface,
-              Name funcName,
-              Name exportName) {
+// evaluate the ctor (which means that the caller can proceed to try to eval
+// further ctors if there are any), and if we did, the results if the function
+// returns any.
+EvalCtorOutcome evalCtor(EvallingModuleInstance& instance,
+                         CtorEvalExternalInterface& interface,
+                         Name funcName,
+                         Name exportName) {
   auto& wasm = instance.wasm;
   auto* func = wasm.getFunction(funcName);
 
   // We don't know the values of parameters, so give up if there are any.
   // TODO: Maybe use ignoreExternalInput?
   if (func->getNumParams() > 0) {
     std::cout << "  ...stopping due to params\n";
-    return false;
-  }
-
-  // TODO: Handle a return value by emitting a proper constant.
-  if (func->getResults() != Type::none) {
-    std::cout << "  ...stopping due to results\n";
-    return false;
+    return EvalCtorOutcome::incomplete();
   }
 
   // We want to handle the form of the global constructor function in LLVM. That
@@ -523,10 +532,10 @@ bool evalCtor(EvallingModuleInstance& instance,
   //
   // Some of those ctors may be inlined, however, which would mean that the
   // function could have locals, control flow, etc. However, we assume for now
-  // that it does not have parameters at least (whose values we can't tell),
-  // or results. And for now we look for a toplevel block and process its
-  // children one at a time. This allows us to eval some of the $ctor.*
-  // functions (or their inlined contents) even if not all.
+  // that it does not have parameters at least (whose values we can't tell).
+  // And for now we look for a toplevel block and process its children one at a
+  // time. This allows us to eval some of the $ctor.* functions (or their
+  // inlined contents) even if not all.
   //
   // TODO: Support complete partial evalling, that is, evaluate parts of an
   //       arbitrary function, and not just a sequence in a single toplevel
@@ -546,6 +555,7 @@ bool evalCtor(EvallingModuleInstance& instance,
     // an item in the block that we only partially evalled.
     EvallingModuleInstance::FunctionScope appliedScope(func, LiteralList());
 
+    Literals results;
     Index successes = 0;
     for (auto* curr : block->list) {
       Flow flow;
@@ -568,6 +578,10 @@ bool evalCtor(EvallingModuleInstance& instance,
       appliedScope = scope;
       successes++;
 
+      // Note the values here, if any. If we are exiting the function now then
+      // these will be returned.
+      results = flow.values;
+
       if (flow.breaking()) {
         // We are returning out of the function (either via a return, or via a
         // break to |block|, which has the same outcome. That means we don't
@@ -627,22 +641,27 @@ bool evalCtor(EvallingModuleInstance& instance,
 
     // Return true if we evalled the entire block. Otherwise, even if we evalled
     // some of it, the caller must stop trying to eval further things.
-    return successes == block->list.size();
+    if (successes == block->list.size()) {
+      return EvalCtorOutcome::complete(results);
+    } else {
+      return EvalCtorOutcome::incomplete();
+    }
   }
 
   // Otherwise, we don't recognize a pattern that allows us to do partial
   // evalling. So simply call the entire function at once and see if we can
   // optimize that.
+  Literals results;
   try {
-    instance.callFunction(funcName, LiteralList());
+    results = instance.callFunction(funcName, LiteralList());
   } catch (FailToEvalException& fail) {
     std::cout << "  ...stopping since could not eval: " << fail.why << "\n";
-    return false;
+    return EvalCtorOutcome::incomplete();
   }
 
   // Success! Apply the results.
   interface.applyToModule();
-  return true;
+  return EvalCtorOutcome::complete(results);
 }
 
 // Eval all ctors in a module.
@@ -677,12 +696,13 @@ void evalCtors(Module& wasm,
         Fatal() << "export not found: " << ctor;
       }
       auto funcName = ex->value;
-      if (!evalCtor(instance, interface, funcName, ctor)) {
+      auto outcome = evalCtor(instance, interface, funcName, ctor);
+      if (!outcome.evalledCompletely) {
         std::cout << "  ...stopping\n";
         return;
       }
 
-      // Success! Remove the export, and continue.
+      // Success! And we can continue to try more.
       std::cout << "  ...success on " << ctor << ".\n";
 
       // Remove the export if we should.
@@ -695,7 +715,12 @@ void evalCtors(Module& wasm,
         auto* func = wasm.getFunction(exp->value);
         auto copyName = Names::getValidFunctionName(wasm, func->name);
         auto* copyFunc = ModuleUtils::copyFunction(func, wasm, copyName);
-        copyFunc->body = Builder(wasm).makeNop();
+        if (func->getResults() == Type::none) {
+          copyFunc->body = Builder(wasm).makeNop();
+        } else {
+          copyFunc->body =
+            Builder(wasm).makeConstantExpression(outcome.results);
+        }
         wasm.getExport(exp->name)->value = copyName;
       }
     }

test/ctor-eval/results.wast

@@ -1,7 +1,11 @@
 (module
+  (import "import" "import" (func $import))
+
   (global $global1 (mut i32) (i32.const 1))
   (global $global2 (mut i32) (i32.const 2))
   (global $global3 (mut i32) (i32.const 3))
+  (global $global4 (mut i32) (i32.const 4))
+  (global $global5 (mut i32) (i32.const 5))
 
   (func $test1 (export "test1")
     ;; This function can be evalled. But in this test we keep this export,
@@ -24,14 +28,41 @@
   )
 
   (func $test3 (export "test3") (result i32)
-    ;; The presence of a result stops us from evalling this function (at least
-    ;; for now). Not even the global set will be evalled.
+    ;; The global.set can be evalled. We must then keep returning the 42.
     (global.set $global3
       (i32.const 13)
     )
     (i32.const 42)
   )
 
+  (func $test4 (export "test4") (result i32)
+    ;; Similar to the above, but not in a toplevel block format that we can
+    ;; eval one item at a time. We will eval this entire function at once, and
+    ;; we should succeed. After that we should keep returning the constant 55
+    (if (result i32)
+      (i32.const 1)
+      (block (result i32)
+        (global.set $global4
+          (i32.const 14)
+        )
+        (i32.const 55)
+      )
+      (i32.const 99)
+    )
+  )
+
+  (func $test5 (export "test5") (result i32)
+    ;; Tests partial evalling with a return value at the end. We never reach
+    ;; that return value, but we should eval the global.set.
+    (global.set $global5
+      (i32.const 15)
+    )
+
+    (call $import)
+
+    (i32.const 100)
+  )
+
   (func "keepalive" (result i32)
     ;; Keep everything alive to see the changes.
 
@@ -43,12 +74,27 @@
     (drop
       (call $test3)
     )
+    (drop
+      (call $test4)
+    )
+    (drop
+      (call $test5)
+    )
 
     ;; Keeping these alive should show the changes to the globals (that should
     ;; contain 11, 12, and 3).
     (i32.add
-      (global.get $global1)
-      (global.get $global2)
+      (i32.add
+        (global.get $global1)
+        (global.get $global2)
+      )
+      (i32.add
+        (global.get $global3)
+        (i32.add
+          (global.get $global4)
+          (global.get $global5)
+        )
+      )
     )
   )
 )

test/ctor-eval/results.wast.ctors

@@ -1 +1 @@
-test1,test2,test3
+test1,test2,test3,test4,test5

test/ctor-eval/results.wast.out

@@ -1,12 +1,16 @@
 (module
- (type $none_=>_none (func))
  (type $none_=>_i32 (func (result i32)))
+ (type $none_=>_none (func))
+ (import "import" "import" (func $import))
  (global $global1 (mut i32) (i32.const 11))
  (global $global2 (mut i32) (i32.const 12))
- (global $global3 (mut i32) (i32.const 3))
+ (global $global3 (mut i32) (i32.const 13))
+ (global $global4 (mut i32) (i32.const 14))
+ (global $global5 (mut i32) (i32.const 15))
  (export "test1" (func $test1_0))
- (export "test3" (func $test3))
- (export "keepalive" (func $3))
+ (export "test3" (func $test3_0))
+ (export "test5" (func $test5_0))
+ (export "keepalive" (func $5))
  (func $test1
   (global.set $global1
    (i32.const 11)
@@ -23,18 +27,53 @@
   )
   (i32.const 42)
  )
- (func $3 (result i32)
+ (func $test4 (result i32)
+  (global.set $global4
+   (i32.const 14)
+  )
+  (i32.const 55)
+ )
+ (func $test5 (result i32)
+  (global.set $global5
+   (i32.const 15)
+  )
+  (call $import)
+  (i32.const 100)
+ )
+ (func $5 (result i32)
   (call $test1)
   (call $test2)
   (drop
    (call $test3)
   )
+  (drop
+   (call $test4)
+  )
+  (drop
+   (call $test5)
+  )
   (i32.add
-   (global.get $global1)
-   (global.get $global2)
+   (i32.add
+    (global.get $global1)
+    (global.get $global2)
+   )
+   (i32.add
+    (global.get $global3)
+    (i32.add
+     (global.get $global4)
+     (global.get $global5)
+    )
+   )
   )
  )
  (func $test1_0
   (nop)
  )
+ (func $test3_0 (result i32)
+  (i32.const 42)
+ )
+ (func $test5_0 (result i32)
+  (call $import)
+  (i32.const 100)
+ )
 )