LibJS: Remove the concept of bytecode optimization levels

While this would be useful in the future for implementing a multi-tiered
optimization strategy, currently a binary on/off is enough for us. This
removes the confusingly on-by-default `OptimizationLevel::None` option
which made the optimization pipeline a no-op even if
`Bytecode::Interpreter::set_optimizations_enabled` had been called.

Fixes #15982

Userland/Libraries/LibJS/Bytecode/Interpreter.cpp

@@ -394,21 +394,10 @@ VM::InterpreterExecutionScope Interpreter::ast_interpreter_scope(Realm& realm)
     return { *m_ast_interpreter };
 }
 
-AK::Array<OwnPtr<PassManager>, static_cast<UnderlyingType<Interpreter::OptimizationLevel>>(Interpreter::OptimizationLevel::__Count)> Interpreter::s_optimization_pipelines {};
-
-Bytecode::PassManager& Interpreter::optimization_pipeline(Interpreter::OptimizationLevel level)
+Bytecode::PassManager& Interpreter::optimization_pipeline()
 {
-    auto underlying_level = to_underlying(level);
-    VERIFY(underlying_level <= to_underlying(Interpreter::OptimizationLevel::__Count));
-    auto& entry = s_optimization_pipelines[underlying_level];
-
-    if (entry)
-        return *entry;
-
-    auto pm = make<PassManager>();
-    if (level == OptimizationLevel::None) {
-        // No optimization.
-    } else if (level == OptimizationLevel::Optimize) {
+    static auto s_optimization_pipeline = [] {
+        auto pm = make<Bytecode::PassManager>();
         pm->add<Passes::GenerateCFG>();
         pm->add<Passes::UnifySameBlocks>();
         pm->add<Passes::GenerateCFG>();
@@ -420,14 +409,9 @@ Bytecode::PassManager& Interpreter::optimization_pipeline(Interpreter::Optimizat
         pm->add<Passes::GenerateCFG>();
         pm->add<Passes::PlaceBlocks>();
         pm->add<Passes::EliminateLoads>();
-    } else {
-        VERIFY_NOT_REACHED();
-    }
-
-    auto& passes = *pm;
-    entry = move(pm);
-
-    return passes;
+        return pm;
+    }();
+    return *s_optimization_pipeline;
 }
 
 size_t Interpreter::pc() const
@@ -448,12 +432,16 @@ ThrowCompletionOr<NonnullOwnPtr<Bytecode::Executable>> compile(VM& vm, ASTNode c
 
     auto bytecode_executable = executable_result.release_value();
     bytecode_executable->name = name;
-    auto& passes = Bytecode::Interpreter::optimization_pipeline();
-    passes.perform(*bytecode_executable);
-    if constexpr (JS_BYTECODE_DEBUG) {
-        dbgln("Optimisation passes took {}us", passes.elapsed());
-        dbgln("Compiled Bytecode::Block for function '{}':", name);
+
+    if (s_optimizations_enabled) {
+        auto& passes = Bytecode::Interpreter::optimization_pipeline();
+        passes.perform(*bytecode_executable);
+        if constexpr (JS_BYTECODE_DEBUG) {
+            dbgln("Optimisation passes took {}us", passes.elapsed());
+            dbgln("Compiled Bytecode::Block for function '{}':", name);
+        }
     }
+
     if (Bytecode::g_dump_bytecode)
         bytecode_executable->dump();
 

Userland/Libraries/LibJS/Bytecode/Interpreter.h

@@ -86,13 +86,7 @@ public:
     size_t pc() const;
     DeprecatedString debug_position() const;
 
-    enum class OptimizationLevel {
-        None,
-        Optimize,
-        __Count,
-        Default = None,
-    };
-    static Bytecode::PassManager& optimization_pipeline(OptimizationLevel = OptimizationLevel::Default);
+    static Bytecode::PassManager& optimization_pipeline();
 
     VM::InterpreterExecutionScope ast_interpreter_scope(Realm&);
 
@@ -109,8 +103,6 @@ private:
 
     MarkedVector<Value>& registers() { return window().registers; }
 
-    static AK::Array<OwnPtr<PassManager>, static_cast<UnderlyingType<Interpreter::OptimizationLevel>>(Interpreter::OptimizationLevel::__Count)> s_optimization_pipelines;
-
     VM& m_vm;
     Vector<Variant<NonnullOwnPtr<RegisterWindow>, RegisterWindow*>> m_register_windows;
     Optional<BasicBlock const*> m_pending_jump;