[compiler] Allow matcher to work on arch without scaling capability

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>
 
 // TODO(turbofan): Move ExternalReference out of assembler.h
@@ skipping 376 matching lines @@
 
 typedef AddMatcher<Int32BinopMatcher, IrOpcode::kInt32Add, IrOpcode::kInt32Sub,
                    IrOpcode::kInt32Mul, IrOpcode::kWord32Shl>
     Int32AddMatcher;
 typedef AddMatcher<Int64BinopMatcher, IrOpcode::kInt64Add, IrOpcode::kInt64Sub,
                    IrOpcode::kInt64Mul, IrOpcode::kWord64Shl>
     Int64AddMatcher;
 
 enum DisplacementMode { kPositiveDisplacement, kNegativeDisplacement };
 
 template <class AddMatcher>

[Benedikt Meurer, 2016/08/15 06:29:20]

You need to move this enum out of the template class add add
DEFINE_OPERATORS_FOR_FLAGS for the flags as well, i.e.

enum class DisplacementFlag : uint8_t {
...
};
typedef base::Flags<DisplacementFlag, uint8_t> DisplacementFlags;
DEFINE_OPERATORS_FOR_FLAGS(DisplacementFlags);

 struct BaseWithIndexAndDisplacementMatcher {
-  BaseWithIndexAndDisplacementMatcher(Node* node, bool allow_input_swap)
+  enum Flag {
+    kAllowNone = 0u,
+    kAllowInputSwap = 1u << 0,
+    kAllowScale = 1u << 1,
+    kAllowAll = kAllowInputSwap | kAllowScale
+  };
+
+  typedef base::Flags<Flag, uint8_t> Flags;
+  BaseWithIndexAndDisplacementMatcher(Node* node, Flags flags)
       : matches_(false),
         index_(nullptr),
         scale_(0),
         base_(nullptr),
         displacement_(nullptr),
         displacement_mode_(kPositiveDisplacement) {
-    Initialize(node, allow_input_swap);
+    Initialize(node, flags);
   }
 
   explicit BaseWithIndexAndDisplacementMatcher(Node* node)
       : matches_(false),
         index_(nullptr),
         scale_(0),
         base_(nullptr),
         displacement_(nullptr),
         displacement_mode_(kPositiveDisplacement) {
-    Initialize(node, node->op()->HasProperty(Operator::kCommutative));
+    Initialize(node, Flags(kAllowScale) |
+                         (node->op()->HasProperty(Operator::kCommutative)
+                              ? kAllowInputSwap
+                              : kAllowNone));
   }
 
   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_; }
   DisplacementMode displacement_mode() const { return displacement_mode_; }
 
  private:
   bool matches_;
   Node* index_;
   int scale_;
   Node* base_;
   Node* displacement_;
   DisplacementMode displacement_mode_;
 
-  void Initialize(Node* node, bool allow_input_swap) {
+  void Initialize(Node* node, Flags flags) {
     // 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, allow_input_swap);
+    AddMatcher m(node, flags & kAllowInputSwap);
     Node* left = m.left().node();
     Node* right = m.right().node();
     Node* displacement = nullptr;
     Node* base = nullptr;
     Node* index = nullptr;
     Node* scale_expression = nullptr;
     bool power_of_two_plus_one = false;
     DisplacementMode displacement_mode = kPositiveDisplacement;
     int scale = 0;
     if (m.HasIndexInput() && left->OwnedBy(node)) {
@@ skipping 138 matching lines @@
         // If the scale requires explicitly using the index as the base, but a
         // base is already part of the match, then the (1 << N + 1) scale factor
         // can't be folded into the match and the entire index * scale
         // calculation must be computed separately.
         index = scale_expression;
         scale = 0;
       } else {
         base = index;
       }
     }
+    if (!(flags & kAllowScale) && scale != 0) {
+      index = scale_expression;
+      scale = 0;
+    }
     base_ = base;
     displacement_ = displacement;
     displacement_mode_ = displacement_mode;
     index_ = index;
     scale_ = scale;
     matches_ = true;
   }
 };
 
 typedef BaseWithIndexAndDisplacementMatcher<Int32AddMatcher>
@@ skipping 47 matching lines @@
   Node* branch_;
   Node* if_true_;
   Node* if_false_;
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_NODE_MATCHERS_H_