[turbofan] Initial import of SimplifiedOperatorReducer.

test/compiler-unittests/change-lowering-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/change-lowering.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/typer.h"
 #include "test/compiler-unittests/graph-unittest.h"
@@ skipping 87 matching lines @@
   Matcher<Node*> IsAllocateHeapNumber(const Matcher<Node*>& effect_matcher,
                                       const Matcher<Node*>& control_matcher) {
     return IsCall(
         _, IsHeapConstant(PrintableUnique<HeapObject>::CreateImmovable(
                zone(), CEntryStub(isolate(), 1).GetCode())),
         IsExternalConstant(ExternalReference(
             Runtime::FunctionForId(Runtime::kAllocateHeapNumber), isolate())),
         IsInt32Constant(0), IsNumberConstant(0.0), effect_matcher,
         control_matcher);
   }
-  Matcher<Node*> IsFalse() {
-    return IsHeapConstant(PrintableUnique<HeapObject>::CreateImmovable(
-        zone(), factory()->false_value()));
-  }
-  Matcher<Node*> IsTrue() {
-    return IsHeapConstant(PrintableUnique<HeapObject>::CreateImmovable(
-        zone(), factory()->true_value()));
-  }
   Matcher<Node*> IsWordEqual(const Matcher<Node*>& lhs_matcher,
                              const Matcher<Node*>& rhs_matcher) {
     return Is32() ? IsWord32Equal(lhs_matcher, rhs_matcher)
                   : IsWord64Equal(lhs_matcher, rhs_matcher);
   }
 
  private:
   SimplifiedOperatorBuilder simplified_;
 };
 
@@ skipping 16 matching lines @@
 
 TARGET_TEST_P(ChangeLoweringCommonTest, ChangeBitToBool) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeBitToBool(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch;
   EXPECT_THAT(phi,
-              IsPhi(IsTrue(), IsFalse(),
+              IsPhi(IsTrueConstant(), IsFalseConstant(),
                     IsMerge(IsIfTrue(AllOf(CaptureEq(&branch),
                                            IsBranch(val, graph()->start()))),
                             IsIfFalse(CaptureEq(&branch)))));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, ChangeBoolToBit) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
-  EXPECT_THAT(reduction.replacement(), IsWordEqual(val, IsTrue()));
+  EXPECT_THAT(reduction.replacement(), IsWordEqual(val, IsTrueConstant()));
 }
 
 
 TARGET_TEST_P(ChangeLoweringCommonTest, ChangeFloat64ToTagged) {
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeFloat64ToTagged(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* finish = reduction.replacement();
@@ skipping 301 matching lines @@
               IsIfTrue(AllOf(CaptureEq(&branch),
                              IsBranch(IsUint32LessThanOrEqual(
                                           val, IsInt32Constant(SmiMaxValue())),
                                       graph()->start()))),
               AllOf(CaptureEq(&if_false), IsIfFalse(CaptureEq(&branch))))));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8