Revert "LibWasm: Some more performance stuff (#8812)"

This reverts commit 35394dbfaa.
I pushed the wrong button again, hopefully this will be the last of
such incidents.

Tests/LibWasm/test-wasm.cpp

@@ -34,7 +34,6 @@ public:
     explicit WebAssemblyModule(JS::Object& prototype)
         : JS::Object(prototype)
     {
-        m_machine.enable_instruction_count_limit();
     }
 
     static Wasm::AbstractMachine& machine() { return m_machine; }

Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp

@@ -128,8 +128,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
     module.for_each_section_of_type<GlobalSection>([&](auto& global_section) {
         for (auto& entry : global_section.entries()) {
             Configuration config { m_store };
-            if (m_should_limit_instruction_count)
-                config.enable_instruction_count_limit();
             config.set_frame(Frame {
                 auxiliary_instance,
                 Vector<Value> {},
@@ -155,8 +153,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
             Vector<Reference> references;
             for (auto& entry : segment.init) {
                 Configuration config { m_store };
-                if (m_should_limit_instruction_count)
-                    config.enable_instruction_count_limit();
                 config.set_frame(Frame {
                     main_module_instance,
                     Vector<Value> {},
@@ -208,8 +204,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
                 return IterationDecision::Break;
             }
             Configuration config { m_store };
-            if (m_should_limit_instruction_count)
-                config.enable_instruction_count_limit();
             config.set_frame(Frame {
                 main_module_instance,
                 Vector<Value> {},
@@ -268,8 +262,6 @@ InstantiationResult AbstractMachine::instantiate(Module const& module, Vector<Ex
             segment.value().visit(
                 [&](DataSection::Data::Active const& data) {
                     Configuration config { m_store };
-                    if (m_should_limit_instruction_count)
-                        config.enable_instruction_count_limit();
                     config.set_frame(Frame {
                         main_module_instance,
                         Vector<Value> {},
@@ -447,8 +439,6 @@ Result AbstractMachine::invoke(FunctionAddress address, Vector<Value> arguments)
 Result AbstractMachine::invoke(Interpreter& interpreter, FunctionAddress address, Vector<Value> arguments)
 {
     Configuration configuration { m_store };
-    if (m_should_limit_instruction_count)
-        configuration.enable_instruction_count_limit();
     return configuration.call(interpreter, address, move(arguments));
 }
 

Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h

@@ -130,26 +130,26 @@ public:
         }
     }
 
-    ALWAYS_INLINE Value(Value const& value)
+    Value(Value const& value)
         : m_value(AnyValueType { value.m_value })
         , m_type(value.m_type)
     {
     }
 
-    ALWAYS_INLINE Value(Value&& value)
+    Value(Value&& value)
         : m_value(move(value.m_value))
         , m_type(move(value.m_type))
     {
     }
 
-    ALWAYS_INLINE Value& operator=(Value&& value)
+    Value& operator=(Value&& value)
     {
         m_value = move(value.m_value);
         m_type = move(value.m_type);
         return *this;
     }
 
-    ALWAYS_INLINE Value& operator=(Value const& value)
+    Value& operator=(Value const& value)
     {
         m_value = value.m_value;
         m_type = value.m_type;
@@ -157,7 +157,7 @@ public:
     }
 
     template<typename T>
-    ALWAYS_INLINE Optional<T> to()
+    Optional<T> to()
     {
         Optional<T> result;
         m_value.visit(
@@ -505,13 +505,10 @@ public:
     auto& store() const { return m_store; }
     auto& store() { return m_store; }
 
-    void enable_instruction_count_limit() { m_should_limit_instruction_count = true; }
-
 private:
     Optional<InstantiationError> allocate_all_initial_phase(Module const&, ModuleInstance&, Vector<ExternValue>&, Vector<Value>& global_values);
     Optional<InstantiationError> allocate_all_final_phase(Module const&, ModuleInstance&, Vector<Vector<Reference>>& elements);
     Store m_store;
-    bool m_should_limit_instruction_count { false };
 };
 
 class Linker {

Userland/Libraries/LibWasm/AbstractMachine/BytecodeInterpreter.cpp

@@ -37,15 +37,12 @@ void BytecodeInterpreter::interpret(Configuration& configuration)
     auto& instructions = configuration.frame().expression().instructions();
     auto max_ip_value = InstructionPointer { instructions.size() };
     auto& current_ip_value = configuration.ip();
-    auto const should_limit_instruction_count = configuration.should_limit_instruction_count();
     u64 executed_instructions = 0;
 
     while (current_ip_value < max_ip_value) {
-        if (should_limit_instruction_count) {
+        if (executed_instructions++ >= Constants::max_allowed_executed_instructions_per_call) [[unlikely]] {
-            if (executed_instructions++ >= Constants::max_allowed_executed_instructions_per_call) [[unlikely]] {
+            m_trap = Trap { "Exceeded maximum allowed number of instructions" };
-                m_trap = Trap { "Exceeded maximum allowed number of instructions" };
+            return;
-                return;
-            }
         }
         auto& instruction = instructions[current_ip_value.value()];
         auto old_ip = current_ip_value;
@@ -1126,15 +1123,17 @@ void DebuggerBytecodeInterpreter::interpret(Configuration& configuration, Instru
         }
     }
 
-    BytecodeInterpreter::interpret(configuration, ip, instruction);
+    ScopeGuard guard { [&] {
-
+        if (post_interpret_hook) {
-    if (post_interpret_hook) {
+            auto result = post_interpret_hook(configuration, ip, instruction, *this);
-        auto result = post_interpret_hook(configuration, ip, instruction, *this);
+            if (!result) {
-        if (!result) {
+                m_trap = Trap { "Trapped by user request" };
-            m_trap = Trap { "Trapped by user request" };
+                return;
-            return;
+            }
         }
-    }
+    } };
+
+    BytecodeInterpreter::interpret(configuration, ip, instruction);
 }
 
 }

Userland/Libraries/LibWasm/AbstractMachine/BytecodeInterpreter.h

@@ -50,7 +50,7 @@ protected:
     T read_value(ReadonlyBytes data);
 
     Vector<Value> pop_values(Configuration& configuration, size_t count);
-    ALWAYS_INLINE bool trap_if_not(bool value, StringView reason)
+    bool trap_if_not(bool value, StringView reason)
     {
         if (!value)
             m_trap = Trap { reason };

Userland/Libraries/LibWasm/AbstractMachine/Configuration.h

@@ -61,9 +61,6 @@ public:
     Result call(Interpreter&, FunctionAddress, Vector<Value> arguments);
     Result execute(Interpreter&);
 
-    void enable_instruction_count_limit() { m_should_limit_instruction_count = true; }
-    bool should_limit_instruction_count() const { return m_should_limit_instruction_count; }
-
     void dump_stack();
 
 private:
@@ -72,7 +69,6 @@ private:
     Stack m_stack;
     size_t m_depth { 0 };
     InstructionPointer m_ip;
-    bool m_should_limit_instruction_count { false };
 };
 
 }

Userland/Libraries/LibWeb/WebAssembly/WebAssemblyObject.cpp

@@ -25,7 +25,6 @@ namespace Web::Bindings {
 WebAssemblyObject::WebAssemblyObject(JS::GlobalObject& global_object)
     : Object(*global_object.object_prototype())
 {
-    s_abstract_machine.enable_instruction_count_limit();
 }
 
 void WebAssemblyObject::initialize(JS::GlobalObject& global_object)

Userland/Utilities/wasm.cpp

@@ -512,16 +512,14 @@ int main(int argc, char* argv[])
             if (debug)
                 launch_repl();
 
-            if (result.is_trap()) {
+            if (result.is_trap())
-                warnln("Execution trapped: {}", result.trap().reason);
+                warnln("Execution trapped!");
-            } else {
+            if (!result.values().is_empty())
-                if (!result.values().is_empty())
+                warnln("Returned:");
-                    warnln("Returned:");
+            for (auto& value : result.values()) {
-                for (auto& value : result.values()) {
+                Wasm::Printer printer { stream };
-                    Wasm::Printer printer { stream };
+                g_stdout.write("  -> "sv.bytes());
-                    g_stdout.write("  -> "sv.bytes());
+                g_printer.print(value);
-                    g_printer.print(value);
-                }
             }
         }
     }