Version 5.2.361.17 (cherry-pick)

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 <algorithm>
 
 #include "src/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
@@ skipping 19 matching lines @@
       }
       case IrOpcode::kNumberConstant: {
         const double value = OpParameter<double>(node);
         return bit_cast<int64_t>(value) == 0;
       }
       default:
         return false;
     }
   }
 
-  bool CanBeMemoryOperand(InstructionCode opcode, Node* node, Node* input) {
+  bool CanBeMemoryOperand(InstructionCode opcode, Node* node, Node* input,
+                          int effect_level) {
     if (input->opcode() != IrOpcode::kLoad ||
         !selector()->CanCover(node, input)) {
       return false;
     }
+    if (effect_level != selector()->GetEffectLevel(input)) {
+      return false;
+    }
     MachineRepresentation rep =
         LoadRepresentationOf(input->op()).representation();
     switch (opcode) {
       case kX64Cmp:
       case kX64Test:
         return rep == MachineRepresentation::kWord64 ||
                rep == MachineRepresentation::kTagged;
       case kX64Cmp32:
       case kX64Test32:
         return rep == MachineRepresentation::kWord32;
@@ skipping 1444 matching lines @@
 void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
                   Node* left, Node* right, FlagsContinuation* cont,
                   bool commutative) {
   X64OperandGenerator g(selector);
   if (commutative && g.CanBeBetterLeftOperand(right)) {
     std::swap(left, right);
   }
   VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
 }
 
-bool InferMachineRepresentation(Node* node,
-                                MachineRepresentation* representation) {
-  if (node->opcode() == IrOpcode::kLoad) {
-    *representation = LoadRepresentationOf(node->op()).representation();
-    return true;
-  }
-  int64_t value = 0;
-  switch (node->opcode()) {
-    case IrOpcode::kInt32Constant:
-      value = OpParameter<int32_t>(node->op());
-      break;
-    case IrOpcode::kInt64Constant:
-      value = OpParameter<int64_t>(node->op());
-      break;
-    default:
-      return false;
-  }
-  if (is_int8(value)) {
-    *representation = MachineRepresentation::kWord8;
-  } else if (is_int16(value)) {
-    *representation = MachineRepresentation::kWord16;
-  } else if (is_int32(value)) {
-    *representation = MachineRepresentation::kWord32;
-  } else {
-    return false;
-  }
-  return true;
-}
-
 // Tries to match the size of the given opcode to that of the operands, if
 // possible.
 InstructionCode TryNarrowOpcodeSize(InstructionCode opcode, Node* left,
                                     Node* right) {
   if (opcode != kX64Cmp32 && opcode != kX64Test32) {
     return opcode;
   }
-  // We only do this if at least one of the two operands is a load.
-  // TODO(epertoso): we can probably get some size information out of phi nodes.
-  if (left->opcode() != IrOpcode::kLoad && right->opcode() != IrOpcode::kLoad) {
+  // Currently, if one of the two operands is not a Load, we don't know what its
+  // machine representation is, so we bail out.
+  // TODO(epertoso): we can probably get some size information out of immediates
+  // and phi nodes.
+  if (left->opcode() != IrOpcode::kLoad || right->opcode() != IrOpcode::kLoad) {
     return opcode;
   }
-  MachineRepresentation left_representation, right_representation;
-  if (!InferMachineRepresentation(left, &left_representation) ||
-      !InferMachineRepresentation(right, &right_representation)) {
+  // If the load representations don't match, both operands will be
+  // zero/sign-extended to 32bit.
+  LoadRepresentation left_representation = LoadRepresentationOf(left->op());
+  if (left_representation != LoadRepresentationOf(right->op())) {
     return opcode;
   }
-  // If the representations don't match, both operands will be
-  // zero/sign-extended to 32bit.
-  if (left_representation != right_representation) {
-    return opcode;
-  }
-  switch (left_representation) {
+  switch (left_representation.representation()) {
     case MachineRepresentation::kBit:
     case MachineRepresentation::kWord8:
       return opcode == kX64Cmp32 ? kX64Cmp8 : kX64Test8;
     case MachineRepresentation::kWord16:
       return opcode == kX64Cmp32 ? kX64Cmp16 : kX64Test16;
     default:
       return opcode;
   }
 }
 
 // Shared routine for multiple word compare operations.
 void VisitWordCompare(InstructionSelector* selector, Node* node,
                       InstructionCode opcode, FlagsContinuation* cont) {
   X64OperandGenerator g(selector);
   Node* left = node->InputAt(0);
   Node* right = node->InputAt(1);
 
-  InstructionCode narrowed_opcode = TryNarrowOpcodeSize(opcode, left, right);
+  opcode = TryNarrowOpcodeSize(opcode, left, right);
 
   // If one of the two inputs is an immediate, make sure it's on the right, or
   // if one of the two inputs is a memory operand, make sure it's on the left.
+  int effect_level = selector->GetEffectLevel(node);
+  if (cont->IsBranch()) {
+    effect_level = selector->GetEffectLevel(
+        cont->true_block()->PredecessorAt(0)->control_input());
+  }
+
   if ((!g.CanBeImmediate(right) && g.CanBeImmediate(left)) ||
-      (g.CanBeMemoryOperand(narrowed_opcode, node, right) &&
-       !g.CanBeMemoryOperand(narrowed_opcode, node, left))) {
+      (g.CanBeMemoryOperand(opcode, node, right, effect_level) &&
+       !g.CanBeMemoryOperand(opcode, node, left, effect_level))) {
     if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
     std::swap(left, right);
   }
 
   // Match immediates on right side of comparison.
   if (g.CanBeImmediate(right)) {
-    if (g.CanBeMemoryOperand(narrowed_opcode, node, left)) {
-      // If we're truncating the immediate (32 bits to 16 or 8), comparison
-      // semantics should take the signedness/unsignedness of the op into
-      // account.
-      if (narrowed_opcode != opcode &&
-          LoadRepresentationOf(left->op()).IsUnsigned()) {
-        switch (cont->condition()) {
-          case FlagsCondition::kSignedLessThan:
-            cont->OverwriteAndNegateIfEqual(FlagsCondition::kUnsignedLessThan);
-            break;
-          case FlagsCondition::kSignedGreaterThan:
-            cont->OverwriteAndNegateIfEqual(
-                FlagsCondition::kUnsignedGreaterThan);
-            break;
-          case FlagsCondition::kSignedLessThanOrEqual:
-            cont->OverwriteAndNegateIfEqual(
-                FlagsCondition::kUnsignedLessThanOrEqual);
-            break;
-          case FlagsCondition::kSignedGreaterThanOrEqual:
-            cont->OverwriteAndNegateIfEqual(
-                FlagsCondition::kUnsignedGreaterThanOrEqual);
-            break;
-          default:
-            break;
-        }
-      }
-      return VisitCompareWithMemoryOperand(selector, narrowed_opcode, left,
+    if (g.CanBeMemoryOperand(opcode, node, left, effect_level)) {
+      return VisitCompareWithMemoryOperand(selector, opcode, left,
                                            g.UseImmediate(right), cont);
     }
     return VisitCompare(selector, opcode, g.Use(left), g.UseImmediate(right),
                         cont);
   }
 
   // Match memory operands on left side of comparison.
-  if (g.CanBeMemoryOperand(narrowed_opcode, node, left)) {
-    return VisitCompareWithMemoryOperand(selector, narrowed_opcode, left,
+  if (g.CanBeMemoryOperand(opcode, node, left, effect_level)) {
+    return VisitCompareWithMemoryOperand(selector, opcode, left,
                                          g.UseRegister(right), cont);
   }
 
   if (g.CanBeBetterLeftOperand(right)) {
     if (!node->op()->HasProperty(Operator::kCommutative)) cont->Commute();
     std::swap(left, right);
   }
 
   return VisitCompare(selector, opcode, left, right, cont,
                       node->op()->HasProperty(Operator::kCommutative));
@@ skipping 515 matching lines @@
              MachineOperatorBuilder::kFloat64RoundTruncate |
              MachineOperatorBuilder::kFloat32RoundTiesEven |
              MachineOperatorBuilder::kFloat64RoundTiesEven;
   }
   return flags;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8