[Interpreter] Adds implementation of bytecode graph builder for LoadICSloppy/Strict

test/unittests/compiler/node-test-utils.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/unittests/compiler/node-test-utils.h"
 
 #include <vector>
 
 #include "src/assembler.h"
 #include "src/compiler/common-operator.h"
@@ skipping 1386 matching lines @@
   bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0),
                                  "input", input_matcher_, listener));
   }
 
  private:
   const Matcher<Node*> input_matcher_;
 };
 
+
 class IsParameterMatcher final : public NodeMatcher {
  public:
   explicit IsParameterMatcher(const Matcher<int>& index_matcher)
       : NodeMatcher(IrOpcode::kParameter), index_matcher_(index_matcher) {}
 
   void DescribeTo(std::ostream* os) const override {
     *os << "is a Parameter node with index(";
     index_matcher_.DescribeTo(os);
     *os << ")";
   }
 
   bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
     return (NodeMatcher::MatchAndExplain(node, listener) &&
             PrintMatchAndExplain(ParameterIndexOf(node->op()), "index",
                                  index_matcher_, listener));
   }
 
  private:
   const Matcher<int> index_matcher_;
 };
 
+
+// TODO(mythria): Check if we can use the same matcher for Load and Store
+class IsNamedLoadMatcher final : public NodeMatcher {
+ public:
+  IsNamedLoadMatcher(IrOpcode::Value opcode,

[rmcilroy, 2015/11/09 15:23:01]

don't pass the opcode to this constructor, just use it directly below (if we
want to later merge load and store we can do that but will also need to rename
this class, so just fix it to be a load matcher for now.

[mythria, 2015/11/10 09:55:35]

Done.

+                     const Matcher<NamedAccess>& named_access_matcher,
+                     const Matcher<Node*>& object_value_matcher,
+                     const Matcher<Node*>& feedback_vector_matcher,
+                     const Matcher<Node*>& effect_matcher,
+                     const Matcher<Node*>& control_matcher)
+      : NodeMatcher(opcode),
+        named_access_matcher_(named_access_matcher),
+        object_value_matcher_(object_value_matcher),
+        feedback_vector_matcher_(feedback_vector_matcher),
+        effect_matcher_(effect_matcher),
+        control_matcher_(control_matcher) {}
+
+  void DescribeTo(std::ostream* os) const final {
+    NodeMatcher::DescribeTo(os);
+    *os << " whose object (";
+    object_value_matcher_.DescribeTo(os);
+    *os << ") feedback vector (";

[rmcilroy, 2015/11/09 15:23:01]

/s/)/),/

[mythria, 2015/11/10 09:55:35]

Done.

+    feedback_vector_matcher_.DescribeTo(os);
+    *os << "), effect (";
+    effect_matcher_.DescribeTo(os);
+    *os << ") and control (";
+    control_matcher_.DescribeTo(os);
+    *os << ")";
+  }
+
+  bool MatchAndExplain(Node* node, MatchResultListener* listener) const final {
+    if (!NodeMatcher::MatchAndExplain(node, listener) ||
+        !PrintMatchAndExplain(OpParameter<const NamedAccess>(node),
+                              "descriptor", named_access_matcher_, listener)) {
+      return false;
+    }
+    std::ostringstream ost;
+    ost << "Object ";
+    if (!PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), ost.str(),
+                              object_value_matcher_, listener)) {
+      return false;
+    }
+    ost.clear();
+    ost << "FeedbackVector ";
+    if (!PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), ost.str(),
+                              feedback_vector_matcher_, listener)) {
+      return false;
+    }

[rmcilroy, 2015/11/09 15:23:01]

Please use the same pattern as the other matchers were everthing is in the
return statement and just uses PrintMatchAndExplain(...) &&
PrintMatchAndExplain(...) ... etc.

[mythria, 2015/11/10 09:55:36]

Done.

+    return (PrintMatchAndExplain(NodeProperties::GetEffectInput(node), "effect",
+                                 effect_matcher_, listener) &&
+            PrintMatchAndExplain(NodeProperties::GetControlInput(node),
+                                 "control", control_matcher_, listener));
+  }
+
+ private:
+  const Matcher<NamedAccess> named_access_matcher_;
+  const Matcher<Node*> object_value_matcher_;
+  const Matcher<Node*> feedback_vector_matcher_;
+  const Matcher<Node*> effect_matcher_;
+  const Matcher<Node*> control_matcher_;
+};
+
+
+class IsNamedAccessMatcher final : public MatcherInterface<NamedAccess> {

[rmcilroy, 2015/11/09 15:23:01]

As discussed, remove this.

[mythria, 2015/11/10 09:55:35]

Done.

+ public:
+  IsNamedAccessMatcher(LanguageMode language_mode, const Handle<Name>& name,
+                       const int slot_id)
+      : language_mode_(language_mode), name_(name), slot_id_(slot_id) {}
+
+  void DescribeTo(std::ostream* os) const final {
+    *os << " NamedAccess with language_mode (";
+    *os << language_mode_;
+    *os << ") name (";
+    *os << name_;
+    *os << ") slot (";
+    *os << slot_id_;
+    *os << ")";
+  }
+
+  bool MatchAndExplain(NamedAccess node,
+                       MatchResultListener* listener) const final {
+    if (node.language_mode() != language_mode_) {
+      *listener << "whose languagemode is " << node.language_mode()
+                << " but should have been " << language_mode_;
+      return false;
+    }
+    if (!name_->StrictEquals(*node.name())) {
+      *listener << "whose name is " << node.name() << " but should have been "
+                << name_;
+      return false;
+    }
+    if (node.feedback().slot().ToInt() != slot_id_) {
+      *listener << "whose slot is " << node.feedback().slot().ToInt()
+                << " but should have been " << slot_id_;
+      return false;
+    }
+    // TODO(mythria): Check if Handle<TypeFeedbackVector>
+    // (node.feedback().vector()) is equal to expected value
+    return true;
+  }
+
+ private:
+  const LanguageMode language_mode_;
+  const Handle<Name> name_;
+  const int slot_id_;
+};
+
 }  // namespace
 
 
 Matcher<Node*> IsDead() {
   return MakeMatcher(new NodeMatcher(IrOpcode::kDead));
 }
 
 
 Matcher<Node*> IsEnd(const Matcher<Node*>& control0_matcher) {
   return MakeMatcher(new IsControl1Matcher(IrOpcode::kEnd, control0_matcher));
@@ skipping 553 matching lines @@
 Matcher<Node*> IsParameter(const Matcher<int> index_matcher) {
   return MakeMatcher(new IsParameterMatcher(index_matcher));
 }
 
 
 Matcher<Node*> IsLoadFramePointer() {
   return MakeMatcher(new NodeMatcher(IrOpcode::kLoadFramePointer));
 }
 
 
+Matcher<Node*> IsNamedLoad(const Matcher<NamedAccess>& node_access_matcher,

[rmcilroy, 2015/11/09 15:23:01]

IsJSLoadNamed (Follow the name of the IrOpcode)

[mythria, 2015/11/10 09:55:35]

Done.

+                           const Matcher<Node*>& object_value_matcher,
+                           const Matcher<Node*>& feedback_vector_matcher,
+                           const Matcher<Node*>& effect_matcher,
+                           const Matcher<Node*>& control_matcher) {
+  return MakeMatcher(new IsNamedLoadMatcher(
+      IrOpcode::kJSLoadNamed, node_access_matcher, object_value_matcher,
+      feedback_vector_matcher, effect_matcher, control_matcher));
+}
+
+
+Matcher<NamedAccess> IsNamedAccess(LanguageMode language_mode,

[rmcilroy, 2015/11/09 15:23:00]

As discussed offline, let's not add a new NamedAccess matcher, instead just
match on the "Matcher<Handle<Name>>& name". You can use 
StringTable::LookupString to find the canonical handle for a given string
property name.

[mythria, 2015/11/10 09:55:36]

As discussed, I pass Handle<Name> instead of matcher. If we need a matcher, then
we can change it by implementing a matcher for Handle<Name>.

+                                   const Handle<Name>& name,
+                                   const int slot_id) {
+  return MakeMatcher(new IsNamedAccessMatcher(language_mode, name, slot_id));
+}
+
+
 #define IS_BINOP_MATCHER(Name)                                            \
   Matcher<Node*> Is##Name(const Matcher<Node*>& lhs_matcher,              \
                           const Matcher<Node*>& rhs_matcher) {            \
     return MakeMatcher(                                                   \
         new IsBinopMatcher(IrOpcode::k##Name, lhs_matcher, rhs_matcher)); \
   }
 IS_BINOP_MATCHER(NumberEqual)
 IS_BINOP_MATCHER(NumberLessThan)
 IS_BINOP_MATCHER(NumberSubtract)
 IS_BINOP_MATCHER(NumberMultiply)
@@ skipping 60 matching lines @@
 IS_UNOP_MATCHER(Float64ExtractHighWord32)
 IS_UNOP_MATCHER(NumberToInt32)
 IS_UNOP_MATCHER(NumberToUint32)
 IS_UNOP_MATCHER(ObjectIsSmi)
 IS_UNOP_MATCHER(Word32Clz)
 #undef IS_UNOP_MATCHER
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8