[turbofan] x64 lea multiplication matching

src/compiler/x64/instruction-selector-x64.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 "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 36 matching lines @@
         return false;
     }
   }
 
   bool CanBeBetterLeftOperand(Node* node) const {
     return !selector()->IsLive(node);
   }
 };
 
 
+// Get the AddressingMode of scale factor N from the AddressingMode of scale
+// factor 1.
+static AddressingMode AdjustAddressingMode(AddressingMode base_mode,
+                                           int power) {
+  DCHECK(0 <= power && power < 4);
+  return static_cast<AddressingMode>(static_cast<int>(base_mode) + power);
+}
+
+
 class AddressingModeMatcher {
  public:
   AddressingModeMatcher(X64OperandGenerator* g, Node* base, Node* index)
       : base_operand_(NULL),
         index_operand_(NULL),
         displacement_operand_(NULL),
         mode_(kMode_None) {
     Int32Matcher index_imm(index);
     if (index_imm.HasValue()) {
       int32_t value = index_imm.Value();
@@ skipping 24 matching lines @@
           mode_ = kMode_M1I;
         }
       } else {
         if (displacement_operand_ == NULL) {
           mode_ = kMode_MR1;
         } else {
           mode_ = kMode_MR1I;
         }
       }
       // Adjust mode to actual scale factor.
-      mode_ = GetMode(mode_, matcher.power());
+      mode_ = AdjustAddressingMode(mode_, matcher.power());
     }
     DCHECK_NE(kMode_None, mode_);
   }
 
-  AddressingMode GetMode(AddressingMode one, int power) {
-    return static_cast<AddressingMode>(static_cast<int>(one) + power);
-  }
-
   size_t SetInputs(InstructionOperand** inputs) {
     size_t input_count = 0;
     // Compute inputs_ and input_count.
     if (base_operand_ != NULL) {
       inputs[input_count++] = base_operand_;
     }
     if (index_operand_ != NULL) {
       inputs[input_count++] = index_operand_;
     }
     if (displacement_operand_ != NULL) {
@@ skipping 336 matching lines @@
     Emit(kX64Neg, g.DefineSameAsFirst(node), g.Use(m.right().node()));
   } else {
     VisitBinop(this, node, kX64Sub);
   }
 }
 
 
 static void VisitMul(InstructionSelector* selector, Node* node,
                      ArchOpcode opcode) {
   X64OperandGenerator g(selector);
-  Int32BinopMatcher m(node);
-  Node* left = m.left().node();
-  Node* right = m.right().node();
-  if (g.CanBeImmediate(right)) {
-    selector->Emit(opcode, g.DefineAsRegister(node), g.Use(left),
-                   g.UseImmediate(right));
+  LeaMultiplyMatcher lea(node);
+  // Try to match lea.
+  if (lea.Matches()) {
+    switch (opcode) {
+      case kX64Imul32:
+        opcode = kX64Lea32;
+        break;
+      case kX64Imul:
+        opcode = kX64Lea;
+        break;
+      default:
+        UNREACHABLE();
+    }
+    AddressingMode mode;
+    if (lea.Displacement() != 0) {
+      mode = kMode_MX1;
+    } else {
+      mode = kMode_M1;
+    }
+    mode = AdjustAddressingMode(mode, lea.Power());
+    selector->Emit(opcode | AddressingModeField::encode(mode),
+                   g.DefineAsRegister(node), g.UseRegister(lea.Left()));
   } else {
-    if (g.CanBeBetterLeftOperand(right)) {
-      std::swap(left, right);
+    Int32BinopMatcher m(node);
+    Node* left = m.left().node();
+    Node* right = m.right().node();
+    if (g.CanBeImmediate(right)) {
+      selector->Emit(opcode, g.DefineAsRegister(node), g.Use(left),
+                     g.UseImmediate(right));
+    } else {
+      if (g.CanBeBetterLeftOperand(right)) {
+        std::swap(left, right);
+      }
+      selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
+                     g.Use(right));
     }
-    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(left),
-                   g.Use(right));
   }
 }
 
 
 void InstructionSelector::VisitInt32Mul(Node* node) {
   VisitMul(this, node, kX64Imul32);
 }
 
 
 void InstructionSelector::VisitInt64Mul(Node* node) {
@@ skipping 309 matching lines @@
   call_instr->MarkAsCall();
   if (deoptimization != NULL) {
     DCHECK(continuation != NULL);
     call_instr->MarkAsControl();
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8