[arm] Unify instruction selector for Word32Neg.

src/compiler/arm/instruction-selector-arm.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"
 #include "src/compiler-intrinsics.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 199 matching lines @@
     *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_LSR_I);
     *shift_return = g.UseImmediate(m.right().node());
   } else {
     *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_LSR_R);
     *shift_return = g.UseRegister(m.right().node());
   }
   return true;
 }
 
 
+static inline bool TryMatchShift(InstructionSelector* selector,

[titzer, 2014/08/01 11:12:33]

s/inline//

+                                 InstructionCode* opcode_return, Node* node,
+                                 InstructionOperand** value_return,
+                                 InstructionOperand** shift_return) {
+  return (
+      TryMatchASR(selector, opcode_return, node, value_return, shift_return) ||
+      TryMatchLSL(selector, opcode_return, node, value_return, shift_return) ||
+      TryMatchLSR(selector, opcode_return, node, value_return, shift_return) ||
+      TryMatchROR(selector, opcode_return, node, value_return, shift_return));
+}
+
+
 static inline bool TryMatchImmediateOrShift(InstructionSelector* selector,
                                             InstructionCode* opcode_return,
                                             Node* node,
                                             size_t* input_count_return,
                                             InstructionOperand** inputs) {
   ArmOperandGenerator g(selector);
   if (g.CanBeImmediate(node, *opcode_return)) {
     *opcode_return |= AddressingModeField::encode(kMode_Operand2_I);
     inputs[0] = g.UseImmediate(node);
     *input_count_return = 1;
     return true;
   }
-  if (TryMatchASR(selector, opcode_return, node, &inputs[0], &inputs[1]) ||
-      TryMatchLSL(selector, opcode_return, node, &inputs[0], &inputs[1]) ||
-      TryMatchLSR(selector, opcode_return, node, &inputs[0], &inputs[1]) ||
-      TryMatchROR(selector, opcode_return, node, &inputs[0], &inputs[1])) {
+  if (TryMatchShift(selector, opcode_return, node, &inputs[0], &inputs[1])) {
     *input_count_return = 2;
     return true;
   }
   return false;
 }
 
 
 // Shared routine for multiple binary operations.
 static void VisitBinop(InstructionSelector* selector, Node* node,
                        InstructionCode opcode, InstructionCode reverse_opcode) {
@@ skipping 172 matching lines @@
     Emit(opcode | AddressingModeField::encode(kMode_Offset_RR), NULL,
          g.UseRegister(base), g.UseRegister(index), val);
   }
 }
 
 
 static inline void EmitBic(InstructionSelector* selector, Node* node,
                            Node* left, Node* right) {
   ArmOperandGenerator g(selector);
   InstructionCode opcode = kArmBic;
-  InstructionOperand* inputs[3];
-  size_t input_count = 0;
-  InstructionOperand* outputs[1] = {g.DefineAsRegister(node)};
-  const size_t output_count = ARRAY_SIZE(outputs);
-
-  inputs[input_count++] = g.UseRegister(left);
-  if (!TryMatchImmediateOrShift(selector, &opcode, right, &input_count,
-                                &inputs[input_count])) {
-    opcode |= AddressingModeField::encode(kMode_Operand2_R);
-    inputs[input_count++] = g.UseRegister(right);
+  InstructionOperand* value_operand;
+  InstructionOperand* shift_operand;
+  if (TryMatchShift(selector, &opcode, right, &value_operand, &shift_operand)) {
+    selector->Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
+                   value_operand, shift_operand);
+    return;
   }
-
-  ASSERT_NE(0, input_count);
-  ASSERT_GE(ARRAY_SIZE(inputs), input_count);
-  ASSERT_NE(kMode_None, AddressingModeField::decode(opcode));
-
-  selector->Emit(opcode, output_count, outputs, input_count, inputs);
+  selector->Emit(opcode | AddressingModeField::encode(kMode_Operand2_R),
+                 g.DefineAsRegister(node), g.UseRegister(left),
+                 g.UseRegister(right));
 }
 
 
 void InstructionSelector::VisitWord32And(Node* node) {
   ArmOperandGenerator g(this);
   Int32BinopMatcher m(node);
   if (m.left().IsWord32Xor() && CanCover(node, m.left().node())) {
     Int32BinopMatcher mleft(m.left().node());
     if (mleft.right().Is(-1)) {
       EmitBic(this, node, m.right().node(), mleft.left().node());
@@ skipping 50 matching lines @@
     return;
   }
   VisitBinop(this, node, kArmOrr, kArmOrr);
 }
 
 
 void InstructionSelector::VisitWord32Xor(Node* node) {
   ArmOperandGenerator g(this);
   Int32BinopMatcher m(node);
   if (m.right().Is(-1)) {
-    Emit(kArmMvn | AddressingModeField::encode(kMode_Operand2_R),
-         g.DefineSameAsFirst(node), g.UseRegister(m.left().node()));
-  } else {
-    VisitBinop(this, node, kArmEor, kArmEor);
+    InstructionCode opcode = kArmMvn;
+    InstructionOperand* value_operand;
+    InstructionOperand* shift_operand;
+    if (TryMatchShift(this, &opcode, m.left().node(), &value_operand,
+                      &shift_operand)) {
+      Emit(opcode, g.DefineAsRegister(node), value_operand, shift_operand);
+      return;
+    }
+    Emit(opcode | AddressingModeField::encode(kMode_Operand2_R),
+         g.DefineAsRegister(node), g.UseRegister(m.left().node()));
+    return;
   }
+  VisitBinop(this, node, kArmEor, kArmEor);
 }
 
 
 template <typename TryMatchShift>
 static inline void VisitShift(InstructionSelector* selector, Node* node,
                               TryMatchShift try_match_shift) {
   ArmOperandGenerator g(selector);
   InstructionCode opcode = kArmMov;
   InstructionOperand* value_operand = NULL;
   InstructionOperand* shift_operand = NULL;
@@ skipping 417 matching lines @@
     ASSERT(cont->IsSet());
     Emit(cont->Encode(kArmVcmpF64), g.DefineAsRegister(cont->result()),
          g.UseDoubleRegister(m.left().node()),
          g.UseDoubleRegister(m.right().node()));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8