diff options
| -rw-r--r-- | src/tools/wasm-ctor-eval.cpp | 73 | ||||
| -rw-r--r-- | test/ctor-eval/results.wast | 54 | ||||
| -rw-r--r-- | test/ctor-eval/results.wast.ctors | 2 | ||||
| -rw-r--r-- | test/ctor-eval/results.wast.out | 53 |
4 files changed, 146 insertions, 36 deletions
diff --git a/src/tools/wasm-ctor-eval.cpp b/src/tools/wasm-ctor-eval.cpp index 3923d137c..a117474a5 100644 --- a/src/tools/wasm-ctor-eval.cpp +++ b/src/tools/wasm-ctor-eval.cpp @@ -489,13 +489,28 @@ private: } }; +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); @@ -503,13 +518,7 @@ bool evalCtor(EvallingModuleInstance& instance, // 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; } } diff --git a/test/ctor-eval/results.wast b/test/ctor-eval/results.wast index a01904149..bbc48db3c 100644 --- a/test/ctor-eval/results.wast +++ b/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) + ) + ) ) ) ) diff --git a/test/ctor-eval/results.wast.ctors b/test/ctor-eval/results.wast.ctors index c7060ede5..94f950267 100644 --- a/test/ctor-eval/results.wast.ctors +++ b/test/ctor-eval/results.wast.ctors @@ -1 +1 @@ -test1,test2,test3 +test1,test2,test3,test4,test5 diff --git a/test/ctor-eval/results.wast.out b/test/ctor-eval/results.wast.out index b4c947eb7..ae5172324 100644 --- a/test/ctor-eval/results.wast.out +++ b/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) + ) ) |