X87: Revert of [turbofan] Improve codegen for 8- and 16-bit memory comparisons...

X87: Revert of [turbofan] Improve codegen for 8- and 16-bit memory comparisons on Intel platforms (patchset #3 id:40001 of https://codereview.chromium.org/2605863002/ ).

  port c16ca32e (r42092)

  original commit message:
  Reason for revert:
  Breaks wasm benchmark (http://crbug.com/v8/5798).

  Original issue's description:
  > [turbofan] Improve codegen for 8- and 16-bit memory comparisons on Intel platforms
  >
  > Recognize and emit in-memory comparisons of 8-bit and 16-bit values with
  > immediate values that fit.
  >
  > LOG=N
  > R=epertoso@chromium.org
  >
  > Review-Url: https://codereview.chromium.org/2605863002
  > Cr-Commit-Position: refs/heads/master@{#41971}
  > Committed: https://chromium.googlesource.com/v8/v8/+/be11812c53ff6c8ce320887bc76a3b60d8103695

BUG=

Review-Url: https://codereview.chromium.org/2622463002
Cr-Commit-Position: refs/heads/master@{#42126}

src/compiler/x87/instruction-selector-x87.cc

@@ -1261,54 +1261,21 @@ void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
   VisitCompare(selector, opcode, g.UseRegister(left), g.Use(right), cont);
 }
 
-MachineType MachineTypeForNarrow(Node* node, Node* hint_node) {
-  if (hint_node->opcode() == IrOpcode::kLoad) {
-    MachineType hint = LoadRepresentationOf(hint_node->op());
-    if (node->opcode() == IrOpcode::kInt32Constant ||
-        node->opcode() == IrOpcode::kInt64Constant) {
-      int64_t constant = node->opcode() == IrOpcode::kInt32Constant
-                             ? OpParameter<int32_t>(node)
-                             : OpParameter<int64_t>(node);
-      if (hint == MachineType::Int8()) {
-        if (constant >= std::numeric_limits<int8_t>::min() &&
-            constant <= std::numeric_limits<int8_t>::max()) {
-          return hint;
-        }
-      } else if (hint == MachineType::Uint8()) {
-        if (constant >= std::numeric_limits<uint8_t>::min() &&
-            constant <= std::numeric_limits<uint8_t>::max()) {
-          return hint;
-        }
-      } else if (hint == MachineType::Int16()) {
-        if (constant >= std::numeric_limits<int16_t>::min() &&
-            constant <= std::numeric_limits<int16_t>::max()) {
-          return hint;
-        }
-      } else if (hint == MachineType::Uint16()) {
-        if (constant >= std::numeric_limits<uint16_t>::min() &&
-            constant <= std::numeric_limits<uint16_t>::max()) {
-          return hint;
-        }
-      } else if (hint == MachineType::Int32()) {
-        return hint;
-      } else if (hint == MachineType::Uint32()) {
-        if (constant >= 0) return hint;
-      }
-    }
-  }
-  return node->opcode() == IrOpcode::kLoad ? LoadRepresentationOf(node->op())
-                                           : MachineType::None();
-}
-
 // Tries to match the size of the given opcode to that of the operands, if
 // possible.
 InstructionCode TryNarrowOpcodeSize(InstructionCode opcode, Node* left,
                                     Node* right, FlagsContinuation* cont) {
-  // TODO(epertoso): we can probably get some size information out of phi nodes.
+  // 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;
+  }
   // If the load representations don't match, both operands will be
   // zero/sign-extended to 32bit.
-  MachineType left_type = MachineTypeForNarrow(left, right);
-  MachineType right_type = MachineTypeForNarrow(right, left);
+  MachineType left_type = LoadRepresentationOf(left->op());
+  MachineType right_type = LoadRepresentationOf(right->op());
   if (left_type == right_type) {
     switch (left_type.representation()) {
       case MachineRepresentation::kBit:
@@ -1410,8 +1377,10 @@ void VisitWordCompare(InstructionSelector* selector, Node* node,
 
   // Match immediates on right side of comparison.
   if (g.CanBeImmediate(right)) {
-    if (g.CanBeMemoryOperand(narrowed_opcode, node, left, effect_level)) {
-      return VisitCompareWithMemoryOperand(selector, narrowed_opcode, left,
+    if (g.CanBeMemoryOperand(opcode, node, left, effect_level)) {
+      // TODO(epertoso): we should use `narrowed_opcode' here once we match
+      // immediates too.
+      return VisitCompareWithMemoryOperand(selector, opcode, left,
                                            g.UseImmediate(right), cont);
     }
     return VisitCompare(selector, opcode, g.Use(left), g.UseImmediate(right),