[turbofan] Optimize BooleanNot conditions to Branch nodes.

test/unittests/compiler/common-operator-reducer-unittest.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/common-operator-reducer.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/machine-type.h"
 #include "src/compiler/operator.h"
+#include "src/compiler/simplified-operator.h"
 #include "test/unittests/compiler/graph-reducer-unittest.h"
 #include "test/unittests/compiler/graph-unittest.h"
 #include "test/unittests/compiler/node-test-utils.h"
 
 using testing::StrictMock;
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class CommonOperatorReducerTest : public GraphTest {
  public:
   explicit CommonOperatorReducerTest(int num_parameters = 1)
-      : GraphTest(num_parameters), machine_(zone()) {}
+      : GraphTest(num_parameters), machine_(zone()), simplified_(zone()) {}
   ~CommonOperatorReducerTest() override {}
 
  protected:
   Reduction Reduce(
       AdvancedReducer::Editor* editor, Node* node,
       MachineOperatorBuilder::Flags flags = MachineOperatorBuilder::kNoFlags) {
     MachineOperatorBuilder machine(zone(), kMachPtr, flags);
     CommonOperatorReducer reducer(editor, graph(), common(), &machine);
     return reducer.Reduce(node);
   }
 
   Reduction Reduce(Node* node, MachineOperatorBuilder::Flags flags =
                                    MachineOperatorBuilder::kNoFlags) {
     StrictMock<MockAdvancedReducerEditor> editor;
     return Reduce(&editor, node, flags);
   }
 
   MachineOperatorBuilder* machine() { return &machine_; }
+  SimplifiedOperatorBuilder* simplified() { return &simplified_; }
 
  private:
   MachineOperatorBuilder machine_;
+  SimplifiedOperatorBuilder simplified_;
 };
 
 
 namespace {
 
 const BranchHint kBranchHints[] = {BranchHint::kNone, BranchHint::kFalse,
                                    BranchHint::kTrue};
 
 
 const MachineType kMachineTypes[] = {
@@ skipping 107 matching lines @@
     StrictMock<MockAdvancedReducerEditor> editor;
     EXPECT_CALL(editor, Replace(if_true, control));
     EXPECT_CALL(editor, Replace(if_false, IsDead()));
     Reduction const r = Reduce(&editor, branch);
     ASSERT_TRUE(r.Changed());
     EXPECT_THAT(r.replacement(), IsDead());
   }
 }
 
 
+TEST_F(CommonOperatorReducerTest, BranchWithBooleanNot) {
+  Node* const value = Parameter(0);
+  TRACED_FOREACH(BranchHint, hint, kBranchHints) {
+    Node* const control = graph()->start();
+    Node* const branch = graph()->NewNode(
+        common()->Branch(hint),
+        graph()->NewNode(simplified()->BooleanNot(), value), control);
+    Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
+    Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
+    Reduction const r = Reduce(branch);
+    ASSERT_TRUE(r.Changed());
+    EXPECT_EQ(branch, r.replacement());
+    EXPECT_THAT(branch, IsBranch(value, control));
+    EXPECT_THAT(if_false, IsIfTrue(branch));
+    EXPECT_THAT(if_true, IsIfFalse(branch));
+  }
+}
+
+
 // -----------------------------------------------------------------------------
 // Merge
 
 
 TEST_F(CommonOperatorReducerTest, MergeOfUnusedDiamond0) {
   Node* const value = Parameter(0);
   Node* const control = graph()->start();
   Node* const branch = graph()->NewNode(common()->Branch(), value, control);
   Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
   Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
@@ skipping 372 matching lines @@
   Node* select =
       graph()->NewNode(common()->Select(kMachFloat64), check, p0, p1);
   Reduction r = Reduce(select, MachineOperatorBuilder::kFloat64Min);
   ASSERT_TRUE(r.Changed());
   EXPECT_THAT(r.replacement(), IsFloat64Min(p0, p1));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8