LibJS: Let bytecode instructions know whether they are in strict mode

This commits puts the strict mode flag in the header of every bytecode
instruction. This allows us to check for strict mode without looking at
the currently running execution context.

Author: awesomekling

Libraries/LibJS/Bytecode/Executable.cpp

@@ -25,15 +25,15 @@ Executable::Executable(
     size_t number_of_property_lookup_caches,
     size_t number_of_global_variable_caches,
     size_t number_of_registers,
-    bool is_strict_mode)
+    Strict strict)
     : bytecode(move(bytecode))
     , string_table(move(string_table))
     , identifier_table(move(identifier_table))
     , regex_table(move(regex_table))
     , constants(move(constants))
     , source_code(move(source_code))
     , number_of_registers(number_of_registers)
-    , is_strict_mode(is_strict_mode)
+    , is_strict_mode(strict == Strict::Yes)
 {
     property_lookup_caches.resize(number_of_property_lookup_caches);
     global_variable_caches.resize(number_of_global_variable_caches);

Libraries/LibJS/Bytecode/Executable.h

@@ -75,7 +75,7 @@ class JS_API Executable final : public Cell {
         size_t number_of_property_lookup_caches,
         size_t number_of_global_variable_caches,
         size_t number_of_registers,
-        bool is_strict_mode);
+        Strict);
 
     virtual ~Executable() override;
 

Libraries/LibJS/Bytecode/Generator.cpp

@@ -218,6 +218,14 @@ CodeGenerationErrorOr<void> Generator::emit_function_declaration_instantiation(E
 CodeGenerationErrorOr<GC::Ref<Executable>> Generator::compile(VM& vm, ASTNode const& node, FunctionKind enclosing_function_kind, GC::Ptr<ECMAScriptFunctionObject const> function, MustPropagateCompletion must_propagate_completion, Vector<LocalVariable> local_variable_names)
 {
     Generator generator(vm, function, must_propagate_completion);
+
+    if (is<Program>(node))
+        generator.m_strict = static_cast<Program const&>(node).is_strict_mode() ? Strict::Yes : Strict::No;
+    else if (is<FunctionBody>(node))
+        generator.m_strict = static_cast<FunctionBody const&>(node).in_strict_mode() ? Strict::Yes : Strict::No;
+    else if (is<FunctionDeclaration>(node))
+        generator.m_strict = static_cast<FunctionDeclaration const&>(node).is_strict_mode() ? Strict::Yes : Strict::No;
+
     generator.m_local_variables = local_variable_names;
 
     generator.switch_to_basic_block(generator.make_block());
@@ -260,14 +268,6 @@ CodeGenerationErrorOr<GC::Ref<Executable>> Generator::compile(VM& vm, ASTNode co
         }
     }
 
-    bool is_strict_mode = false;
-    if (is<Program>(node))
-        is_strict_mode = static_cast<Program const&>(node).is_strict_mode();
-    else if (is<FunctionBody>(node))
-        is_strict_mode = static_cast<FunctionBody const&>(node).in_strict_mode();
-    else if (is<FunctionDeclaration>(node))
-        is_strict_mode = static_cast<FunctionDeclaration const&>(node).is_strict_mode();
-
     size_t size_needed = 0;
     for (auto& block : generator.m_root_basic_blocks) {
         size_needed += block->size();
@@ -453,7 +453,7 @@ CodeGenerationErrorOr<GC::Ref<Executable>> Generator::compile(VM& vm, ASTNode co
         generator.m_next_property_lookup_cache,
         generator.m_next_global_variable_cache,
         generator.m_next_register,
-        is_strict_mode);
+        generator.m_strict);
 
     Vector<Executable::ExceptionHandlers> linked_exception_handlers;
 

Libraries/LibJS/Bytecode/Generator.h

@@ -93,6 +93,7 @@ class Generator {
         grow(sizeof(OpType));
         void* slot = m_current_basic_block->data() + slot_offset;
         new (slot) OpType(forward<Args>(args)...);
+        static_cast<OpType*>(slot)->set_strict(m_strict);
         if constexpr (OpType::IsTerminator)
             m_current_basic_block->terminate({});
         m_current_basic_block->add_source_map_entry(slot_offset, { m_current_ast_node->start_offset(), m_current_ast_node->end_offset() });
@@ -110,6 +111,7 @@ class Generator {
         grow(size_to_allocate);
         void* slot = m_current_basic_block->data() + slot_offset;
         new (slot) OpType(forward<Args>(args)...);
+        static_cast<OpType*>(slot)->set_strict(m_strict);
         if constexpr (OpType::IsTerminator)
             m_current_basic_block->terminate({});
         m_current_basic_block->add_source_map_entry(slot_offset, { m_current_ast_node->start_offset(), m_current_ast_node->end_offset() });
@@ -383,6 +385,8 @@ class Generator {
         Vector<FlyString> language_label_set;
     };
 
+    Strict m_strict { Strict::No };
+
     BasicBlock* m_current_basic_block { nullptr };
     ASTNode const* m_current_ast_node { nullptr };
     UnwindContext const* m_current_unwind_context { nullptr };

Libraries/LibJS/Bytecode/Instruction.h

@@ -188,7 +188,7 @@ class alignas(void*) Instruction {
     constexpr static bool IsTerminator = false;
     static constexpr bool IsVariableLength = false;
 
-    enum class Type {
+    enum class Type : u8 {
 #define __BYTECODE_OP(op) \
     op,
         ENUMERATE_BYTECODE_OPS(__BYTECODE_OP)
@@ -202,6 +202,9 @@ class alignas(void*) Instruction {
     void visit_operands(Function<void(Operand&)> visitor);
     static void destroy(Instruction&);
 
+    Strict strict() const { return m_strict; }
+    void set_strict(Strict strict) { m_strict = strict; }
+
 protected:
     explicit Instruction(Type type)
         : m_type(type)
@@ -213,6 +216,7 @@ class alignas(void*) Instruction {
 
 private:
     Type m_type {};
+    Strict m_strict {};
 };
 
 class InstructionStreamIterator {