[turbofan]: Port lea changes to ia32

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 <cmath>
 
 #include "src/compiler/node.h"
@@ skipping 115 matching lines @@
 
 // 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 : public NodeMatcher {
   explicit BinopMatcher(Node* node)
       : NodeMatcher(node), left_(InputAt(0)), right_(InputAt(1)) {
     if (HasProperty(Operator::kCommutative)) PutConstantOnRight();
   }
+  BinopMatcher(Node* node, bool allow_input_swap)
+      : NodeMatcher(node), left_(InputAt(0)), right_(InputAt(1)) {
+    if (allow_input_swap) PutConstantOnRight();
+  }
 
   typedef Left LeftMatcher;
   typedef Right RightMatcher;
 
   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(); }
 
@@ skipping 82 matching lines @@
 typedef ScaleMatcher<Int64BinopMatcher, IrOpcode::kInt64Mul,
                      IrOpcode::kWord64Shl> Int64ScaleMatcher;
 
 
 template <class BinopMatcher, IrOpcode::Value kAddOpcode,
           IrOpcode::Value kMulOpcode, IrOpcode::Value kShiftOpcode>
 struct AddMatcher : public BinopMatcher {
   static const IrOpcode::Value kOpcode = kAddOpcode;
   typedef ScaleMatcher<BinopMatcher, kMulOpcode, kShiftOpcode> Matcher;
 
+  AddMatcher(Node* node, bool allow_input_swap)
+      : BinopMatcher(node, allow_input_swap),
+        scale_(-1),
+        power_of_two_plus_one_(false) {
+    Initialize(node, allow_input_swap);
+  }
   explicit AddMatcher(Node* node)
-      : BinopMatcher(node), scale_(-1), power_of_two_plus_one_(false) {
+      : BinopMatcher(node, node->op()->HasProperty(Operator::kCommutative)),
+        scale_(-1),
+        power_of_two_plus_one_(false) {
+    Initialize(node, node->op()->HasProperty(Operator::kCommutative));
+  }
+
+  bool HasIndexInput() const { return scale_ != -1; }
+  Node* IndexInput() const {
+    DCHECK(HasIndexInput());
+    return this->left().node()->InputAt(0);
+  }
+  int scale() const {
+    DCHECK(HasIndexInput());
+    return scale_;
+  }
+  bool power_of_two_plus_one() const { return power_of_two_plus_one_; }
+
+ private:
+  void Initialize(Node* node, bool allow_input_swap) {
     Matcher left_matcher(this->left().node(), true);
     if (left_matcher.matches()) {
       scale_ = left_matcher.scale();
       power_of_two_plus_one_ = left_matcher.power_of_two_plus_one();
       return;
     }
 
-    if (!this->HasProperty(Operator::kCommutative)) {
+    if (!allow_input_swap) {
       return;
     }
 
     Matcher right_matcher(this->right().node(), true);
     if (right_matcher.matches()) {
       scale_ = right_matcher.scale();
       power_of_two_plus_one_ = right_matcher.power_of_two_plus_one();
       this->SwapInputs();
       return;
     }
 
     if (this->right().opcode() == kAddOpcode &&
         this->left().opcode() != kAddOpcode) {
       this->SwapInputs();
     }
   }
 
-  bool HasIndexInput() const { return scale_ != -1; }
-  Node* IndexInput() const {
-    DCHECK(HasIndexInput());
-    return this->left().node()->InputAt(0);
-  }
-  int scale() const {
-    DCHECK(HasIndexInput());
-    return scale_;
-  }
-  bool power_of_two_plus_one() const { return power_of_two_plus_one_; }
-
- private:
   int scale_;
   bool power_of_two_plus_one_;
 };
 
 typedef AddMatcher<Int32BinopMatcher, IrOpcode::kInt32Add, IrOpcode::kInt32Mul,
                    IrOpcode::kWord32Shl> Int32AddMatcher;
 typedef AddMatcher<Int64BinopMatcher, IrOpcode::kInt64Add, IrOpcode::kInt64Mul,
                    IrOpcode::kWord64Shl> Int64AddMatcher;
 
 
 template <class AddMatcher>
 struct BaseWithIndexAndDisplacementMatcher {
+  BaseWithIndexAndDisplacementMatcher(Node* node, bool allow_input_swap)
+      : matches_(false),
+        index_(NULL),
+        scale_(0),
+        base_(NULL),
+        displacement_(NULL) {
+    Initialize(node, allow_input_swap);
+  }
+
   explicit BaseWithIndexAndDisplacementMatcher(Node* node)
       : matches_(false),
         index_(NULL),
         scale_(0),
         base_(NULL),
         displacement_(NULL) {
+    Initialize(node, node->op()->HasProperty(Operator::kCommutative));
+  }
+
+  bool matches() const { return matches_; }
+  Node* index() const { return index_; }
+  int scale() const { return scale_; }
+  Node* base() const { return base_; }
+  Node* displacement() const { return displacement_; }
+
+ private:
+  bool matches_;
+  Node* index_;
+  int scale_;
+  Node* base_;
+  Node* displacement_;
+
+  void Initialize(Node* node, bool allow_input_swap) {
     // The BaseWithIndexAndDisplacementMatcher canonicalizes the order of
     // displacements 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 = index * scale, B = base input, D =
     // displacement input):
     // (S + (B + D))
     // (S + (B + B))
     // (S + D)
     // (S + B)
     // ((S + D) + B)
     // ((S + B) + D)
     // ((B + D) + B)
     // ((B + B) + D)
     // (B + D)
     // (B + B)
     if (node->InputCount() < 2) return;
-    AddMatcher m(node);
+    AddMatcher m(node, allow_input_swap);
     Node* left = m.left().node();
     Node* right = m.right().node();
     Node* displacement = NULL;
     Node* base = NULL;
     Node* index = NULL;
     Node* scale_expression = NULL;
     bool power_of_two_plus_one = false;
     int scale = 0;
     if (m.HasIndexInput() && left->OwnedBy(node)) {
       index = m.IndexInput();
@@ skipping 103 matching lines @@
       } else {
         base = index;
       }
     }
     base_ = base;
     displacement_ = displacement;
     index_ = index;
     scale_ = scale;
     matches_ = true;
   }
-
-  bool matches() const { return matches_; }
-  Node* index() const { return index_; }
-  int scale() const { return scale_; }
-  Node* base() const { return base_; }
-  Node* displacement() const { return displacement_; }
-
- private:
-  bool matches_;
-
- protected:
-  Node* index_;
-  int scale_;
-  Node* base_;
-  Node* displacement_;
 };
 
 typedef BaseWithIndexAndDisplacementMatcher<Int32AddMatcher>
     BaseWithIndexAndDisplacement32Matcher;
 typedef BaseWithIndexAndDisplacementMatcher<Int64AddMatcher>
     BaseWithIndexAndDisplacement64Matcher;
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_MATCHERS_H_