[turbofan] Add control input to Load and LoadElements.

test/unittests/compiler/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/unittests/compiler/compiler-test-utils.h"
@@ skipping 69 matching lines @@
   Matcher<Node*> IsAllocateHeapNumber(const Matcher<Node*>& effect_matcher,
                                       const Matcher<Node*>& control_matcher) {
     return IsCall(
         _, IsHeapConstant(Unique<HeapObject>::CreateImmovable(
                CEntryStub(isolate(), 1).GetCode())),
         IsExternalConstant(ExternalReference(
             Runtime::FunctionForId(Runtime::kAllocateHeapNumber), isolate())),
         IsInt32Constant(0), IsNumberConstant(0.0), effect_matcher,
         control_matcher);
   }
+  Matcher<Node*> IsLoadHeapNumber(const Matcher<Node*>& value_matcher,
+                                  const Matcher<Node*>& control_matcher) {
+    return IsLoad(kMachFloat64, value_matcher,
+                  IsInt32Constant(HeapNumberValueOffset()), graph()->start(),
+                  control_matcher);
+  }
   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 119 matching lines @@
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch, if_true;
   EXPECT_THAT(
       phi,
       IsPhi(
-          kMachFloat64,
-          IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
-                 IsControlEffect(CaptureEq(&if_true))),
+          kMachFloat64, IsLoadHeapNumber(val, CaptureEq(&if_true)),
           IsChangeInt32ToFloat64(
               IsWord32Sar(val, IsInt32Constant(SmiShiftAmount()))),
           IsMerge(
               AllOf(CaptureEq(&if_true),
                     IsIfTrue(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start())))),
               IsIfFalse(CaptureEq(&branch)))));
 }
 
 
 TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToInt32) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch, if_true;
   EXPECT_THAT(
       phi,
       IsPhi(kMachInt32,
-            IsChangeFloat64ToInt32(IsLoad(
-                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
-                IsControlEffect(CaptureEq(&if_true)))),
+            IsChangeFloat64ToInt32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
             IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
             IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                     IsIfFalse(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start()))))));
 }
 
 
 TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToUint32) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToUint32(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch, if_true;
   EXPECT_THAT(
       phi,
       IsPhi(kMachUint32,
-            IsChangeFloat64ToUint32(IsLoad(
-                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
-                IsControlEffect(CaptureEq(&if_true)))),
+            IsChangeFloat64ToUint32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
             IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
             IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                     IsIfFalse(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start()))))));
 }
 
 
 TARGET_TEST_F(ChangeLowering32Test, ChangeUint32ToTagged) {
@@ skipping 59 matching lines @@
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToFloat64(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch, if_true;
   EXPECT_THAT(
       phi,
       IsPhi(
-          kMachFloat64,
-          IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
-                 IsControlEffect(CaptureEq(&if_true))),
+          kMachFloat64, IsLoadHeapNumber(val, CaptureEq(&if_true)),
           IsChangeInt32ToFloat64(IsTruncateInt64ToInt32(
               IsWord64Sar(val, IsInt32Constant(SmiShiftAmount())))),
           IsMerge(
               AllOf(CaptureEq(&if_true),
                     IsIfTrue(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start())))),
               IsIfFalse(CaptureEq(&branch)))));
 }
 
 
 TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToInt32) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch, if_true;
   EXPECT_THAT(
       phi,
       IsPhi(kMachInt32,
-            IsChangeFloat64ToInt32(IsLoad(
-                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
-                IsControlEffect(CaptureEq(&if_true)))),
+            IsChangeFloat64ToInt32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
             IsTruncateInt64ToInt32(
                 IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
             IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                     IsIfFalse(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start()))))));
 }
 
 
 TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToUint32) {
   STATIC_ASSERT(kSmiTag == 0);
   STATIC_ASSERT(kSmiTagSize == 1);
 
   Node* val = Parameter(0);
   Node* node = graph()->NewNode(simplified()->ChangeTaggedToUint32(), val);
   Reduction reduction = Reduce(node);
   ASSERT_TRUE(reduction.Changed());
 
   Node* phi = reduction.replacement();
   Capture<Node*> branch, if_true;
   EXPECT_THAT(
       phi,
       IsPhi(kMachUint32,
-            IsChangeFloat64ToUint32(IsLoad(
-                kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
-                IsControlEffect(CaptureEq(&if_true)))),
+            IsChangeFloat64ToUint32(IsLoadHeapNumber(val, CaptureEq(&if_true))),
             IsTruncateInt64ToInt32(
                 IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
             IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
                     IsIfFalse(AllOf(
                         CaptureEq(&branch),
                         IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
                                  graph()->start()))))));
 }
 
 
@@ skipping 24 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