[turbofan] Add new ControlEffect and Finish operators.

test/compiler-unittests/graph-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 "test/compiler-unittests/graph-unittest.h"
 
 #include <ostream>  // NOLINT(readability/streams)
 
 #include "src/compiler/node-properties-inl.h"
 
 using testing::MakeMatcher;
 using testing::MatcherInterface;
 using testing::MatchResultListener;
 using testing::StringMatchResultListener;
 
 namespace v8 {
 namespace internal {
 
 // TODO(bmeurer): Find a new home for these functions.
 template <typename T>
 inline std::ostream& operator<<(std::ostream& os,
                                 const PrintableUnique<T>& value) {
   return os << value.string();
 }
+inline std::ostream& operator<<(std::ostream& os,
+                                const ExternalReference& value) {
+  OStringStream ost;
+  compiler::StaticParameterTraits<ExternalReference>::PrintTo(ost, value);
+  return os << ost.c_str();
+}
 
 namespace compiler {
 
 GraphTest::GraphTest(int num_parameters) : graph_(zone()) {
   graph()->SetStart(graph()->NewNode(common()->Start(num_parameters)));
 }
 
 
 GraphTest::~GraphTest() {}
 
@@ skipping 24 matching lines @@
     *os << "is a " << IrOpcode::Mnemonic(opcode_) << " node";
   }
 
   virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
       V8_OVERRIDE {
     if (node == NULL) {
       *listener << "which is NULL";
       return false;
     }
     if (node->opcode() != opcode_) {
-      *listener << "whose opcode is " << IrOpcode::Mnemonic(node->opcode());
+      *listener << "whose opcode is " << IrOpcode::Mnemonic(node->opcode())
+                << " but should have been " << IrOpcode::Mnemonic(opcode_);
       return false;
     }
     return true;
   }
 
  private:
   const IrOpcode::Value opcode_;
 };
 
 
@@ skipping 54 matching lines @@
             PrintMatchAndExplain(NodeProperties::GetControlInput(node, 1),
                                  "control1", control1_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> control0_matcher_;
   const Matcher<Node*> control1_matcher_;
 };
 
 
-class IsIfTrueMatcher V8_FINAL : public NodeMatcher {
+class IsControl1Matcher V8_FINAL : public NodeMatcher {
  public:
-  explicit IsIfTrueMatcher(const Matcher<Node*>& control_matcher)
-      : NodeMatcher(IrOpcode::kIfTrue), control_matcher_(control_matcher) {}
+  IsControl1Matcher(IrOpcode::Value opcode,
+                    const Matcher<Node*>& control_matcher)
+      : NodeMatcher(opcode), control_matcher_(control_matcher) {}
 
   virtual void DescribeTo(std::ostream* os) const V8_OVERRIDE {
     NodeMatcher::DescribeTo(os);
     *os << " whose control (";
     control_matcher_.DescribeTo(os);
     *os << ")";
   }
 
   virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
       V8_OVERRIDE {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetControlInput(node),
                                  "control", control_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> control_matcher_;
 };
 
 
-class IsIfFalseMatcher V8_FINAL : public NodeMatcher {
+class IsFinishMatcher V8_FINAL : public NodeMatcher {
  public:
-  explicit IsIfFalseMatcher(const Matcher<Node*>& control_matcher)
-      : NodeMatcher(IrOpcode::kIfFalse), control_matcher_(control_matcher) {}
+  IsFinishMatcher(const Matcher<Node*>& value_matcher,
+                  const Matcher<Node*>& effect_matcher)
+      : NodeMatcher(IrOpcode::kFinish),
+        value_matcher_(value_matcher),
+        effect_matcher_(effect_matcher) {}
 
   virtual void DescribeTo(std::ostream* os) const V8_OVERRIDE {
     NodeMatcher::DescribeTo(os);
-    *os << " whose control (";
-    control_matcher_.DescribeTo(os);
+    *os << " whose value (";
+    value_matcher_.DescribeTo(os);
+    *os << ") and effect (";
+    effect_matcher_.DescribeTo(os);
     *os << ")";
   }
 
   virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
       V8_OVERRIDE {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
-            PrintMatchAndExplain(NodeProperties::GetControlInput(node),
-                                 "control", control_matcher_, listener));
+            PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
+                                 "value", value_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+                                 effect_matcher_, listener));
   }
 
  private:
-  const Matcher<Node*> control_matcher_;
+  const Matcher<Node*> value_matcher_;
+  const Matcher<Node*> effect_matcher_;
 };
 
 
 template <typename T>
 class IsConstantMatcher V8_FINAL : public NodeMatcher {
  public:
   IsConstantMatcher(IrOpcode::Value opcode, const Matcher<T>& value_matcher)
       : NodeMatcher(opcode), value_matcher_(value_matcher) {}
 
   virtual void DescribeTo(std::ostream* os) const V8_OVERRIDE {
@@ skipping 79 matching lines @@
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "base",
                                  base_matcher_, listener));
   }
 
  private:
   const Matcher<int32_t> index_matcher_;
   const Matcher<Node*> base_matcher_;
 };
 
 
+class IsCallMatcher V8_FINAL : public NodeMatcher {
+ public:
+  IsCallMatcher(const Matcher<CallDescriptor*>& descriptor_matcher,
+                const Matcher<Node*>& value0_matcher,
+                const Matcher<Node*>& value1_matcher,
+                const Matcher<Node*>& value2_matcher,
+                const Matcher<Node*>& value3_matcher,
+                const Matcher<Node*>& effect_matcher,
+                const Matcher<Node*>& control_matcher)
+      : NodeMatcher(IrOpcode::kCall),
+        descriptor_matcher_(descriptor_matcher),
+        value0_matcher_(value0_matcher),
+        value1_matcher_(value1_matcher),
+        value2_matcher_(value2_matcher),
+        value3_matcher_(value3_matcher),
+        effect_matcher_(effect_matcher),
+        control_matcher_(control_matcher) {}
+
+  virtual void DescribeTo(std::ostream* os) const V8_OVERRIDE {
+    NodeMatcher::DescribeTo(os);
+    *os << " whose value0 (";
+    value0_matcher_.DescribeTo(os);
+    *os << ") and value1 (";
+    value1_matcher_.DescribeTo(os);
+    *os << ") and value2 (";
+    value2_matcher_.DescribeTo(os);
+    *os << ") and value3 (";
+    value3_matcher_.DescribeTo(os);
+    *os << ") and effect (";
+    effect_matcher_.DescribeTo(os);
+    *os << ") and control (";
+    control_matcher_.DescribeTo(os);
+    *os << ")";
+  }
+
+  virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const
+      V8_OVERRIDE {
+    return (NodeMatcher::MatchAndExplain(node, listener) &&
+            PrintMatchAndExplain(OpParameter<CallDescriptor*>(node),
+                                 "descriptor", descriptor_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
+                                 "value0", value0_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1),
+                                 "value1", value1_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetValueInput(node, 2),
+                                 "value2", value2_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetValueInput(node, 3),
+                                 "value3", value3_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+                                 effect_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+                                 "control", control_matcher_, listener));
+  }
+
+ private:
+  const Matcher<CallDescriptor*> descriptor_matcher_;
+  const Matcher<Node*> value0_matcher_;
+  const Matcher<Node*> value1_matcher_;
+  const Matcher<Node*> value2_matcher_;
+  const Matcher<Node*> value3_matcher_;
+  const Matcher<Node*> effect_matcher_;
+  const Matcher<Node*> control_matcher_;
+};
+
+
 class IsLoadMatcher V8_FINAL : public NodeMatcher {
  public:
   IsLoadMatcher(const Matcher<MachineType>& type_matcher,
                 const Matcher<Node*>& base_matcher,
                 const Matcher<Node*>& index_matcher,
                 const Matcher<Node*>& effect_matcher)
       : NodeMatcher(IrOpcode::kLoad),
         type_matcher_(type_matcher),
         base_matcher_(base_matcher),
         index_matcher_(index_matcher),
@@ skipping 165 matching lines @@
 }
 
 
 Matcher<Node*> IsMerge(const Matcher<Node*>& control0_matcher,
                        const Matcher<Node*>& control1_matcher) {
   return MakeMatcher(new IsMergeMatcher(control0_matcher, control1_matcher));
 }
 
 
 Matcher<Node*> IsIfTrue(const Matcher<Node*>& control_matcher) {
-  return MakeMatcher(new IsIfTrueMatcher(control_matcher));
+  return MakeMatcher(new IsControl1Matcher(IrOpcode::kIfTrue, control_matcher));
 }
 
 
 Matcher<Node*> IsIfFalse(const Matcher<Node*>& control_matcher) {
-  return MakeMatcher(new IsIfFalseMatcher(control_matcher));
+  return MakeMatcher(
+      new IsControl1Matcher(IrOpcode::kIfFalse, control_matcher));
 }
 
 
-Matcher<Node*> IsInt32Constant(const Matcher<int32_t>& value_matcher) {
+Matcher<Node*> IsControlEffect(const Matcher<Node*>& control_matcher) {
   return MakeMatcher(
-      new IsConstantMatcher<int32_t>(IrOpcode::kInt32Constant, value_matcher));
+      new IsControl1Matcher(IrOpcode::kControlEffect, control_matcher));
 }
 
 
+Matcher<Node*> IsFinish(const Matcher<Node*>& value_matcher,
+                        const Matcher<Node*>& effect_matcher) {
+  return MakeMatcher(new IsFinishMatcher(value_matcher, effect_matcher));
+}
+
+
+Matcher<Node*> IsExternalConstant(
+    const Matcher<ExternalReference>& value_matcher) {
+  return MakeMatcher(new IsConstantMatcher<ExternalReference>(
+      IrOpcode::kExternalConstant, value_matcher));
+}
+
+
 Matcher<Node*> IsHeapConstant(
     const Matcher<PrintableUnique<HeapObject> >& value_matcher) {
   return MakeMatcher(new IsConstantMatcher<PrintableUnique<HeapObject> >(
       IrOpcode::kHeapConstant, value_matcher));
 }
 
 
+Matcher<Node*> IsInt32Constant(const Matcher<int32_t>& value_matcher) {
+  return MakeMatcher(
+      new IsConstantMatcher<int32_t>(IrOpcode::kInt32Constant, value_matcher));
+}
+
+
+Matcher<Node*> IsNumberConstant(const Matcher<double>& value_matcher) {
+  return MakeMatcher(
+      new IsConstantMatcher<double>(IrOpcode::kNumberConstant, value_matcher));
+}
+
+
 Matcher<Node*> IsPhi(const Matcher<Node*>& value0_matcher,
                      const Matcher<Node*>& value1_matcher,
                      const Matcher<Node*>& merge_matcher) {
   return MakeMatcher(
       new IsPhiMatcher(value0_matcher, value1_matcher, merge_matcher));
 }
 
 
 Matcher<Node*> IsProjection(const Matcher<int32_t>& index_matcher,
                             const Matcher<Node*>& base_matcher) {
   return MakeMatcher(new IsProjectionMatcher(index_matcher, base_matcher));
 }
 
 
+Matcher<Node*> IsCall(const Matcher<CallDescriptor*>& descriptor_matcher,
+                      const Matcher<Node*>& value0_matcher,
+                      const Matcher<Node*>& value1_matcher,
+                      const Matcher<Node*>& value2_matcher,
+                      const Matcher<Node*>& value3_matcher,
+                      const Matcher<Node*>& effect_matcher,
+                      const Matcher<Node*>& control_matcher) {
+  return MakeMatcher(new IsCallMatcher(
+      descriptor_matcher, value0_matcher, value1_matcher, value2_matcher,
+      value3_matcher, effect_matcher, control_matcher));
+}
+
+
 Matcher<Node*> IsLoad(const Matcher<MachineType>& type_matcher,
                       const Matcher<Node*>& base_matcher,
                       const Matcher<Node*>& index_matcher,
                       const Matcher<Node*>& effect_matcher) {
   return MakeMatcher(new IsLoadMatcher(type_matcher, base_matcher,
                                        index_matcher, effect_matcher));
 }
 
 
 Matcher<Node*> IsStore(const Matcher<MachineType>& type_matcher,
@@ skipping 31 matching lines @@
   Matcher<Node*> Is##Name(const Matcher<Node*>& input_matcher) {             \
     return MakeMatcher(new IsUnopMatcher(IrOpcode::k##Name, input_matcher)); \
   }
 IS_UNOP_MATCHER(ConvertInt64ToInt32)
 IS_UNOP_MATCHER(ChangeInt32ToFloat64)
 #undef IS_UNOP_MATCHER
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8