[turbofan] Optimize add operations to use 'leal' instruction on x64

src/compiler/node-matchers.h

 // 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.
 
 #ifndef V8_COMPILER_NODE_MATCHERS_H_
 #define V8_COMPILER_NODE_MATCHERS_H_
 
+#include "src/compiler/generic-node.h"
+#include "src/compiler/generic-node-inl.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operator.h"
 #include "src/unique.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // A pattern matcher for nodes.
 struct NodeMatcher {
@@ skipping 91 matching lines @@
     : public ValueMatcher<Unique<T>, IrOpcode::kHeapConstant> {
   explicit HeapObjectMatcher(Node* node)
       : ValueMatcher<Unique<T>, IrOpcode::kHeapConstant>(node) {}
 };
 
 
 // For shorter pattern matching code, this struct matches both the left and
 // right hand sides of a binary operation and can put constants on the right
 // if they appear on the left hand side of a commutative operation.
 template <typename Left, typename Right>
-struct BinopMatcher FINAL : public NodeMatcher {
+struct BinopMatcher : public NodeMatcher {
   explicit BinopMatcher(Node* node)
       : NodeMatcher(node), left_(InputAt(0)), right_(InputAt(1)) {
     if (HasProperty(Operator::kCommutative)) PutConstantOnRight();
   }
 
   const Left& left() const { return left_; }
   const Right& right() const { return right_; }
 
   bool IsFoldable() const { return left().HasValue() && right().HasValue(); }
   bool LeftEqualsRight() const { return left().node() == right().node(); }
 
+ protected:
+  void SwapInputs() {
+    std::swap(left_, right_);
+    node()->ReplaceInput(0, left().node());
+    node()->ReplaceInput(1, right().node());
+  }
+
  private:
   void PutConstantOnRight() {
     if (left().HasValue() && !right().HasValue()) {
-      std::swap(left_, right_);
-      node()->ReplaceInput(0, left().node());
-      node()->ReplaceInput(1, right().node());
+      SwapInputs();
     }
   }
 
   Left left_;
   Right right_;
 };
 
 typedef BinopMatcher<Int32Matcher, Int32Matcher> Int32BinopMatcher;
 typedef BinopMatcher<Uint32Matcher, Uint32Matcher> Uint32BinopMatcher;
 typedef BinopMatcher<Int64Matcher, Int64Matcher> Int64BinopMatcher;
 typedef BinopMatcher<Uint64Matcher, Uint64Matcher> Uint64BinopMatcher;
 typedef BinopMatcher<IntPtrMatcher, IntPtrMatcher> IntPtrBinopMatcher;
 typedef BinopMatcher<UintPtrMatcher, UintPtrMatcher> UintPtrBinopMatcher;
 typedef BinopMatcher<Float64Matcher, Float64Matcher> Float64BinopMatcher;
 typedef BinopMatcher<NumberMatcher, NumberMatcher> NumberBinopMatcher;
 
+struct Int32AddMatcher : public Int32BinopMatcher {
+  explicit Int32AddMatcher(Node* node)
+      : Int32BinopMatcher(node), scale_factor_(-1) {
+    PutScaledInputOnLeft();
+  }
+
+  bool HasScaledInput() const { return scale_factor_ != -1; }
+  Node* ScaledInput() const {
+    DCHECK(HasScaledInput());
+    return left().node()->InputAt(0);
+  }
+  int ScaleFactor() const {
+    DCHECK(HasScaledInput());
+    return scale_factor_;
+  }
+
+ private:
+  int GetInputScaleFactor(Node* node) const {
+    if (node->opcode() == IrOpcode::kWord32Shl) {
+      Int32BinopMatcher m(node);
+      if (m.right().HasValue()) {
+        int32_t value = m.right().Value();
+        if (value >= 0 && value <= 3) {
+          return value;
+        }
+      }
+    } else if (node->opcode() == IrOpcode::kInt32Mul) {
+      Int32BinopMatcher m(node);
+      if (m.right().HasValue()) {
+        int32_t value = m.right().Value();
+        if (value == 1) {
+          return 0;
+        } else if (value == 2) {
+          return 1;
+        } else if (value == 4) {
+          return 2;
+        } else if (value == 8) {
+          return 3;
+        }
+      }
+    }
+    return -1;
+  }
+
+  void PutScaledInputOnLeft() {
+    scale_factor_ = GetInputScaleFactor(right().node());
+    if (scale_factor_ >= 0) {
+      int left_scale_factor = GetInputScaleFactor(left().node());
+      if (left_scale_factor == -1) {
+        SwapInputs();
+      } else {
+        scale_factor_ = left_scale_factor;
+      }
+    } else {
+      scale_factor_ = GetInputScaleFactor(left().node());
+      if (scale_factor_ == -1) {
+        if (right().opcode() == IrOpcode::kInt32Add &&
+            left().opcode() != IrOpcode::kInt32Add) {
+          SwapInputs();
+        }
+      }
+    }
+  }
+
+  int scale_factor_;
+};
+
+struct ScaledWithOffsetMatcher {
+  explicit ScaledWithOffsetMatcher(Node* node)
+      : matches_(false),
+        scaled_(NULL),
+        scale_factor_(0),
+        offset_(NULL),
+        constant_(NULL) {
+    if (node->opcode() != IrOpcode::kInt32Add) return;
+
+    // The Int32AddMatcher canonicalizes the order of constants and scale
+    // factors that are used as inputs, so instead of enumerating all possible
+    // patterns by brute force, checking for node clusters using the following
+    // templates in the following order suffices to find all of the interesting
+    // cases (S = scaled input, O = offset input, C = constant input):
+    // (S + (O + C))
+    // (S + (O + O))
+    // (S + C)
+    // (S + O)
+    // ((S + C) + O)
+    // ((S + O) + C)
+    // ((O + C) + O)
+    // ((O + O) + C)
+    // (O + C)
+    // (O + O)
+    Int32AddMatcher base_matcher(node);
+    Node* left = base_matcher.left().node();
+    Node* right = base_matcher.right().node();
+    if (base_matcher.HasScaledInput() && left->OwnedBy(node)) {
+      scaled_ = base_matcher.ScaledInput();
+      scale_factor_ = base_matcher.ScaleFactor();
+      if (right->opcode() == IrOpcode::kInt32Add && right->OwnedBy(node)) {
+        Int32AddMatcher right_matcher(right);
+        if (right_matcher.right().HasValue()) {
+          // (S + (O + C))
+          offset_ = right_matcher.left().node();
+          constant_ = right_matcher.right().node();
+        } else {
+          // (S + (O + O))
+          offset_ = right;
+        }
+      } else if (base_matcher.right().HasValue()) {
+        // (S + C)
+        constant_ = right;
+      } else {
+        // (S + O)
+        offset_ = right;
+      }
+    } else {
+      if (left->opcode() == IrOpcode::kInt32Add && left->OwnedBy(node)) {
+        Int32AddMatcher left_matcher(left);
+        Node* left_left = left_matcher.left().node();
+        Node* left_right = left_matcher.right().node();
+        if (left_matcher.HasScaledInput() && left_left->OwnedBy(left)) {
+          scaled_ = left_matcher.ScaledInput();
+          scale_factor_ = left_matcher.ScaleFactor();
+          if (left_matcher.right().HasValue()) {
+            // ((S + C) + O)
+            constant_ = left_right;
+            offset_ = right;
+          } else if (base_matcher.right().HasValue()) {
+            // ((S + O) + C)
+            offset_ = left_right;
+            constant_ = right;
+          } else {
+            // (O + O)
+            scaled_ = left;
+            offset_ = right;
+          }
+        } else {
+          if (left_matcher.right().HasValue()) {
+            // ((O + C) + O)
+            scaled_ = left_left;
+            constant_ = left_right;
+            offset_ = right;
+          } else if (base_matcher.right().HasValue()) {
+            // ((O + O) + C)
+            scaled_ = left_left;
+            offset_ = left_right;
+            constant_ = right;
+          } else {
+            // (O + O)
+            scaled_ = left;
+            offset_ = right;
+          }
+        }
+      } else {
+        if (base_matcher.right().HasValue()) {
+          // (O + C)
+          offset_ = left;
+          constant_ = right;
+        } else {
+          // (O + O)
+          offset_ = left;
+          scaled_ = right;
+        }
+      }
+    }
+    matches_ = true;
+  }
+
+  bool matches() const { return matches_; }
+  Node* scaled() const { return scaled_; }
+  int scale_factor() const { return scale_factor_; }
+  Node* offset() const { return offset_; }
+  Node* constant() const { return constant_; }
+
+ private:
+  bool matches_;
+
+ protected:
+  Node* scaled_;
+  int scale_factor_;
+  Node* offset_;
+  Node* constant_;
+};
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_MATCHERS_H_