Revert "LibJS/Bytecode: Fuse [Not, JumpIf] instructions into JumpIfNot"

This reverts commit 795149e5855945061707b4351132920f61ff0949.

Userland/Libraries/LibJS/Bytecode/Instruction.h

@@ -69,7 +69,6 @@
     O(IteratorToArray)                 \
     O(Jump)                            \
     O(JumpIf)                          \
-    O(JumpIfNot)                       \
     O(JumpGreaterThan)                 \
     O(JumpGreaterThanEquals)           \
     O(JumpLessThan)                    \

Userland/Libraries/LibJS/Bytecode/Interpreter.cpp

@@ -360,12 +360,6 @@ void Interpreter::run_bytecode()
                 else
                     m_current_block = &static_cast<Op::JumpIf const&>(instruction).false_target()->block();
                 goto start;
-            case Instruction::Type::JumpIfNot:
-                if (!get(static_cast<Op::JumpIfNot const&>(instruction).condition()).to_boolean())
-                    m_current_block = &static_cast<Op::JumpIfNot const&>(instruction).true_target()->block();
-                else
-                    m_current_block = &static_cast<Op::JumpIfNot const&>(instruction).false_target()->block();
-                goto start;
 
 #define JS_HANDLE_FUSABLE_BINARY_JUMP(PreOp, int32_operator, slow_case) \
     case Instruction::Type::Jump##PreOp: {                              \
@@ -1288,12 +1282,6 @@ ThrowCompletionOr<void> JumpIf::execute_impl(Bytecode::Interpreter&) const
     __builtin_unreachable();
 }
 
-ThrowCompletionOr<void> JumpIfNot::execute_impl(Bytecode::Interpreter&) const
-{
-    // Handled in the interpreter loop.
-    __builtin_unreachable();
-}
-
 #define JS_DEFINE_FUSABLE_BINARY_OP(PreOp, ...)                                                                  \
     ThrowCompletionOr<void> Jump##PreOp::execute_impl(Bytecode::Interpreter&) const { __builtin_unreachable(); } \
                                                                                                                  \
@@ -1974,14 +1962,6 @@ ByteString JumpIf::to_byte_string_impl(Bytecode::Executable const& executable) c
         true_string, false_string);
 }
 
-ByteString JumpIfNot::to_byte_string_impl(Bytecode::Executable const& executable) const
-{
-    return ByteString::formatted("JumpIfNot {}, \033[32mtrue\033[0m:{} \033[32mfalse\033[0m:{}",
-        format_operand("condition"sv, m_condition, executable),
-        *m_true_target,
-        *m_false_target);
-}
-
 ByteString JumpNullish::to_byte_string_impl(Bytecode::Executable const& executable) const
 {
     auto true_string = m_true_target.has_value() ? ByteString::formatted("{}", *m_true_target) : "<empty>";

Userland/Libraries/LibJS/Bytecode/Op.h

@@ -1123,23 +1123,6 @@ private:
     Operand m_condition;
 };
 
-class JumpIfNot final : public Jump {
-public:
-    explicit JumpIfNot(Operand condition, Label true_target, Label false_target)
-        : Jump(Type::JumpIfNot, move(true_target), move(false_target), sizeof(*this))
-        , m_condition(condition)
-    {
-    }
-
-    ThrowCompletionOr<void> execute_impl(Bytecode::Interpreter&) const;
-    ByteString to_byte_string_impl(Bytecode::Executable const&) const;
-
-    Operand condition() const { return m_condition; }
-
-private:
-    Operand m_condition;
-};
-
 // NOTE: The raw operator is used for comparing two Int32 values.
 #define JS_ENUMERATE_FUSABLE_BINARY_OPS(X)        \
     X(GreaterThan, >, greater_than)               \

Userland/Libraries/LibJS/Bytecode/Pass/GenerateCFG.cpp

@@ -71,7 +71,6 @@ static void generate_cfg_for_block(BasicBlock const& current_block, PassPipeline
 #undef JS_ENUMERATE_FUSABLE_BINARY_OP
 
         case JumpIf:
-        case JumpIfNot:
         case JumpNullish:
         case JumpUndefined: {
             // FIXME: It would be nice if we could avoid this copy, if we know that the unwind context stays the same in both paths

Userland/Libraries/LibJS/Bytecode/Pass/Peephole.cpp

@@ -38,20 +38,6 @@ void Peephole::perform(PassPipelineExecutable& executable)
                 if (next_instruction.type() == Instruction::Type::JumpIf) {
                     auto const& jump = static_cast<Op::JumpIf const&>(next_instruction);
 
-                    if (instruction.type() == Instruction::Type::Not) {
-                        auto const& not_ = static_cast<Op::Not const&>(instruction);
-                        VERIFY(jump.condition() == not_.dst());
-                        new_block->append<Op::JumpIfNot>(
-                            not_.source_record().source_start_offset,
-                            not_.source_record().source_end_offset,
-                            not_.src(),
-                            *jump.true_target(),
-                            *jump.false_target());
-                        ++it;
-                        VERIFY(it.at_end());
-                        continue;
-                    }
-
 #define DO_FUSE_JUMP(PreOp, ...)                                          \
     if (instruction.type() == Instruction::Type::PreOp) {                 \
         auto const& compare = static_cast<Op::PreOp const&>(instruction); \