s390: optimize for int 64-bit operation and cleanup

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

 // Copyright 2015 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/base/adapters.h"
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/s390/frames-s390.h"
 
@@ skipping 25 matching lines @@
   kArithmeticCommonMode = kAllowRM | kAllowRI
 };
 
 typedef base::Flags<OperandMode, uint32_t> OperandModes;
 DEFINE_OPERATORS_FOR_FLAGS(OperandModes);
 OperandModes immediateModeMask =
     OperandMode::kShift32Imm | OperandMode::kShift64Imm |
     OperandMode::kInt32Imm | OperandMode::kInt32Imm_Negate |
     OperandMode::kUint32Imm | OperandMode::kInt20Imm;
 
-#define AndOperandMode                                              \
-  ((OperandMode::kBitWiseCommonMode | OperandMode::kUint32Imm |     \
-    OperandMode::kAllowRM | (CpuFeatures::IsSupported(DISTINCT_OPS) \
-                                 ? OperandMode::kAllowRRR           \
-                                 : OperandMode::kBitWiseCommonMode)))
+#define AndCommonMode                                                \
+  ((OperandMode::kAllowRM |                                          \
+    (CpuFeatures::IsSupported(DISTINCT_OPS) ? OperandMode::kAllowRRR \
+                                            : OperandMode::kNone)))
+#define And64OperandMode AndCommonMode
+#define Or64OperandMode And64OperandMode
+#define Xor64OperandMode And64OperandMode
 
-#define OrOperandMode AndOperandMode
-#define XorOperandMode AndOperandMode
+#define And32OperandMode \
+  (AndCommonMode | OperandMode::kAllowRI | OperandMode::kUint32Imm)
+#define Or32OperandMode And32OperandMode
+#define Xor32OperandMode And32OperandMode
 
-#define ShiftOperandMode                                         \
-  ((OperandMode::kBitWiseCommonMode | OperandMode::kShift64Imm | \
-    (CpuFeatures::IsSupported(DISTINCT_OPS)                      \
-         ? OperandMode::kAllowRRR                                \
-         : OperandMode::kBitWiseCommonMode)))
+#define Shift32OperandMode                                   \
+  ((OperandMode::kAllowRI | OperandMode::kShift64Imm |       \
+    (CpuFeatures::IsSupported(DISTINCT_OPS)                  \
+         ? (OperandMode::kAllowRRR | OperandMode::kAllowRRI) \
+         : OperandMode::kNone)))
+
+#define Shift64OperandMode                             \
+  ((OperandMode::kAllowRI | OperandMode::kShift64Imm | \
+    OperandMode::kAllowRRR | OperandMode::kAllowRRI))
 
 #define AddOperandMode                                            \
   ((OperandMode::kArithmeticCommonMode | OperandMode::kInt32Imm | \
     (CpuFeatures::IsSupported(DISTINCT_OPS)                       \
          ? (OperandMode::kAllowRRR | OperandMode::kAllowRRI)      \
          : OperandMode::kArithmeticCommonMode)))
 #define SubOperandMode                                                   \
   ((OperandMode::kArithmeticCommonMode | OperandMode::kInt32Imm_Negate | \
     (CpuFeatures::IsSupported(DISTINCT_OPS)                              \
          ? (OperandMode::kAllowRRR | OperandMode::kAllowRRI)             \
@@ skipping 164 matching lines @@
 
   bool Is64BitOperand(Node* node) {
     return MachineRepresentation::kWord64 == GetRepresentation(node);
   }
 };
 
 namespace {
 
 bool S390OpcodeOnlySupport12BitDisp(ArchOpcode opcode) {
   switch (opcode) {
+    case kS390_AddFloat:
+    case kS390_AddDouble:
     case kS390_CmpFloat:
     case kS390_CmpDouble:
+    case kS390_Float32ToDouble:
       return true;
     default:
       return false;
   }
 }
 
 bool S390OpcodeOnlySupport12BitDisp(InstructionCode op) {
   ArchOpcode opcode = ArchOpcodeField::decode(op);
   return S390OpcodeOnlySupport12BitDisp(opcode);
 }
@@ skipping 56 matching lines @@
 #else
   switch (node->opcode()) {
     case IrOpcode::kInt32Div:
     case IrOpcode::kUint32Div:
     case IrOpcode::kInt32MulHigh:
     case IrOpcode::kUint32MulHigh:
     case IrOpcode::kInt32Mod:
     case IrOpcode::kUint32Mod:
     case IrOpcode::kWord32Clz:
     case IrOpcode::kWord32Popcnt:
+    case IrOpcode::kChangeUint32ToUint64:
       return true;
     default:
       return false;
   }
   return false;
 #endif
 }
 
 bool ZeroExtendsWord32ToWord64(Node* node) {
 #if !V8_TARGET_ARCH_S390X
@@ skipping 53 matching lines @@
   }
 #endif
 }
 
 void VisitRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
   S390OperandGenerator g(selector);
   selector->Emit(opcode, g.DefineAsRegister(node),
                  g.UseRegister(node->InputAt(0)));
 }
 
-void VisitRRR(InstructionSelector* selector, ArchOpcode opcode, Node* node) {
-  S390OperandGenerator g(selector);
-  selector->Emit(opcode, g.DefineAsRegister(node),
-                 g.UseRegister(node->InputAt(0)),
-                 g.UseRegister(node->InputAt(1)));
-}
+// TODO(john.yan): Create VisiteShift to match dst = src shift (R+I)
+#if 0
+void VisitShift() { }
+#endif
 
 #if V8_TARGET_ARCH_S390X
-void VisitRRO(InstructionSelector* selector, ArchOpcode opcode, Node* node,
-              OperandModes operand_mode) {
-  S390OperandGenerator g(selector);
-  selector->Emit(opcode, g.DefineAsRegister(node),
-                 g.UseRegister(node->InputAt(0)),
-                 g.UseOperand(node->InputAt(1), operand_mode));
-}
-
 void VisitTryTruncateDouble(InstructionSelector* selector, ArchOpcode opcode,
                             Node* node) {
   S390OperandGenerator g(selector);
   InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))};
   InstructionOperand outputs[2];
   size_t output_count = 0;
   outputs[output_count++] = g.DefineAsRegister(node);
 
   Node* success_output = NodeProperties::FindProjection(node, 1);
   if (success_output) {
     outputs[output_count++] = g.DefineAsRegister(success_output);
   }
 
   selector->Emit(opcode, output_count, outputs, 1, inputs);
 }
 #endif
 
-// Shared routine for multiple binary operations.
-template <typename Matcher>
-void VisitBinop(InstructionSelector* selector, Node* node,
+template <class CanCombineWithLoad>
+void GenerateRightOperands(InstructionSelector* selector, Node* node,
+                           Node* right, InstructionCode& opcode,
+                           OperandModes& operand_mode,
+                           InstructionOperand* inputs, size_t& input_count,
+                           CanCombineWithLoad canCombineWithLoad) {
+  S390OperandGenerator g(selector);
+
+  if ((operand_mode & OperandMode::kAllowImmediate) &&
+      g.CanBeImmediate(right, operand_mode)) {
+    inputs[input_count++] = g.UseImmediate(right);
+    // Can only be RI or RRI
+    operand_mode &= OperandMode::kAllowImmediate;
+  } else if (operand_mode & OperandMode::kAllowMemoryOperand) {
+    NodeMatcher mright(right);
+    if (mright.IsLoad() && selector->CanCover(node, right) &&
+        canCombineWithLoad(SelectLoadOpcode(right))) {
+      AddressingMode mode = g.GetEffectiveAddressMemoryOperand(
+          right, inputs, &input_count, OpcodeImmMode(opcode));
+      opcode |= AddressingModeField::encode(mode);
+      operand_mode &= ~OperandMode::kAllowImmediate;
+      if (operand_mode & OperandMode::kAllowRM)
+        operand_mode &= ~OperandMode::kAllowDistinctOps;
+    } else if (operand_mode & OperandMode::kAllowRM) {
+      DCHECK(!(operand_mode & OperandMode::kAllowRRM));
+      inputs[input_count++] = g.UseAnyExceptImmediate(right);
+      // Can not be Immediate
+      operand_mode &=
+          ~OperandMode::kAllowImmediate & ~OperandMode::kAllowDistinctOps;
+    } else if (operand_mode & OperandMode::kAllowRRM) {
+      DCHECK(!(operand_mode & OperandMode::kAllowRM));
+      inputs[input_count++] = g.UseAnyExceptImmediate(right);
+      // Can not be Immediate
+      operand_mode &= ~OperandMode::kAllowImmediate;
+    } else {
+      UNREACHABLE();
+    }
+  } else {
+    inputs[input_count++] = g.UseRegister(right);
+    // Can only be RR or RRR
+    operand_mode &= OperandMode::kAllowRRR;
+  }
+}
+
+template <class CanCombineWithLoad>
+void GenerateBinOpOperands(InstructionSelector* selector, Node* node,
+                           Node* left, Node* right, InstructionCode& opcode,
+                           OperandModes& operand_mode,
+                           InstructionOperand* inputs, size_t& input_count,
+                           CanCombineWithLoad canCombineWithLoad) {
+  S390OperandGenerator g(selector);
+  // left is always register
+  InstructionOperand const left_input = g.UseRegister(left);
+  inputs[input_count++] = left_input;
+
+  if (left == right) {
+    inputs[input_count++] = left_input;
+    // Can only be RR or RRR
+    operand_mode &= OperandMode::kAllowRRR;
+  } else {
+    GenerateRightOperands(selector, node, right, opcode, operand_mode, inputs,
+                          input_count, canCombineWithLoad);
+  }
+}
+
+template <class CanCombineWithLoad>
+void VisitUnaryOp(InstructionSelector* selector, Node* node,
+                  InstructionCode opcode, OperandModes operand_mode,
+                  FlagsContinuation* cont,
+                  CanCombineWithLoad canCombineWithLoad);
+
+template <class CanCombineWithLoad>
+void VisitBinOp(InstructionSelector* selector, Node* node,
                 InstructionCode opcode, OperandModes operand_mode,
-                FlagsContinuation* cont) {
+                FlagsContinuation* cont, CanCombineWithLoad canCombineWithLoad);
+
+#define VISIT_OP_LIST(V)                                                       \
+  V(Word64, Unary,                                                             \
+    [](ArchOpcode opcode) { return opcode == kS390_LoadWord64; })              \
+  V(Word64, Bin, [](ArchOpcode opcode) { return opcode == kS390_LoadWord64; }) \
+  V(Float32, Unary,                                                            \
+    [](ArchOpcode opcode) { return opcode == kS390_LoadFloat32; })             \
+  V(Float64, Unary,                                                            \
+    [](ArchOpcode opcode) { return opcode == kS390_LoadDouble; })              \
+  V(Float32, Bin,                                                              \
+    [](ArchOpcode opcode) { return opcode == kS390_LoadFloat32; })             \
+  V(Float64, Bin, [](ArchOpcode opcode) { return opcode == kS390_LoadDouble; })
+
+#define DECLARE_VISIT_HELPER_FUNCTIONS(type1, type2, canCombineWithLoad)  \
+  void Visit##type1##type2##Op(                                           \
+      InstructionSelector* selector, Node* node, InstructionCode opcode,  \
+      OperandModes operand_mode, FlagsContinuation* cont) {               \
+    Visit##type2##Op(selector, node, opcode, operand_mode, cont,          \
+                     canCombineWithLoad);                                 \
+  }                                                                       \
+  void Visit##type1##type2##Op(InstructionSelector* selector, Node* node, \
+                               InstructionCode opcode,                    \
+                               OperandModes operand_mode) {               \
+    FlagsContinuation cont;                                               \
+    Visit##type1##type2##Op(selector, node, opcode, operand_mode, &cont); \
+  }
+VISIT_OP_LIST(DECLARE_VISIT_HELPER_FUNCTIONS);
+#undef DECLARE_VISIT_HELPER_FUNCTIONS
+
+template <class CanCombineWithLoad>
+void VisitUnaryOp(InstructionSelector* selector, Node* node,
+                  InstructionCode opcode, OperandModes operand_mode,
+                  FlagsContinuation* cont,
+                  CanCombineWithLoad canCombineWithLoad) {
+// Just to get rid of unused function warning
+#define USE_VISITOR(type1, type2, canCombineWithLoad) \
+  {                                                   \
+    VisiterType dummy = Visit##type1##type2##Op;      \
+    USE(dummy);                                       \
+  }
+  typedef void (*VisiterType)(InstructionSelector * selector, Node * node,
+                              InstructionCode opcode,
+                              OperandModes operand_mode);
+  VISIT_OP_LIST(USE_VISITOR);
+#undef USE_VISITOR
+
   S390OperandGenerator g(selector);
-  Matcher m(node);
-  Node* left = m.left().node();
-  Node* right = m.right().node();
-  InstructionOperand inputs[4];
+  InstructionOperand inputs[8];
   size_t input_count = 0;
   InstructionOperand outputs[2];
   size_t output_count = 0;
+  Node* input = node->InputAt(0);
 
-  // TODO(turbofan): match complex addressing modes.
-  if (left == right) {
-    // If both inputs refer to the same operand, enforce allocating a register
-    // for both of them to ensure that we don't end up generating code like
-    // this:
-    //
-    //   mov rax, [rbp-0x10]
-    //   add rax, [rbp-0x10]
-    //   jo label
-    InstructionOperand const input = g.UseRegister(left);
-    inputs[input_count++] = input;
-    inputs[input_count++] = input;
-  } else if (g.CanBeImmediate(right, operand_mode)) {
-    inputs[input_count++] = g.UseRegister(left);
-    inputs[input_count++] = g.UseImmediate(right);
-  } else {
-    if (node->op()->HasProperty(Operator::kCommutative) &&
-        g.CanBeBetterLeftOperand(right)) {
-      std::swap(left, right);
-    }
-    inputs[input_count++] = g.UseRegister(left);
-    inputs[input_count++] = g.UseRegister(right);
-  }
+  GenerateRightOperands(selector, node, input, opcode, operand_mode, inputs,
+                        input_count, canCombineWithLoad);
 
   if (cont->IsBranch()) {
     inputs[input_count++] = g.Label(cont->true_block());
     inputs[input_count++] = g.Label(cont->false_block());
   }
 
-  if (cont->IsDeoptimize()) {
-    // If we can deoptimize as a result of the binop, we need to make sure that
-    // the deopt inputs are not overwritten by the binop result. One way
+  if (!cont->IsDeoptimize()) {
+    // If we can deoptimize as a result of the binop, we need to make sure
+    // that the deopt inputs are not overwritten by the binop result. One way
     // to achieve that is to declare the output register as same-as-first.
+    outputs[output_count++] = g.DefineAsRegister(node);
+  } else {
     outputs[output_count++] = g.DefineSameAsFirst(node);
-  } else {
-    outputs[output_count++] = g.DefineAsRegister(node);
   }
+
   if (cont->IsSet()) {
     outputs[output_count++] = g.DefineAsRegister(cont->result());
   }
 
   DCHECK_NE(0u, input_count);
   DCHECK_NE(0u, output_count);
   DCHECK_GE(arraysize(inputs), input_count);
   DCHECK_GE(arraysize(outputs), output_count);
 
   opcode = cont->Encode(opcode);
+
   if (cont->IsDeoptimize()) {
     selector->EmitDeoptimize(opcode, output_count, outputs, input_count, inputs,
                              cont->kind(), cont->reason(), cont->frame_state());
   } else if (cont->IsTrap()) {
     inputs[input_count++] = g.UseImmediate(cont->trap_id());
     selector->Emit(opcode, output_count, outputs, input_count, inputs);
   } else {
     selector->Emit(opcode, output_count, outputs, input_count, inputs);
   }
 }
 
-// Shared routine for multiple binary operations.
-template <typename Matcher>
-void VisitBinop(InstructionSelector* selector, Node* node, ArchOpcode opcode,
-                OperandModes operand_mode) {
-  FlagsContinuation cont;
-  VisitBinop<Matcher>(selector, node, opcode, operand_mode, &cont);
+template <class CanCombineWithLoad>
+void VisitBinOp(InstructionSelector* selector, Node* node,
+                InstructionCode opcode, OperandModes operand_mode,
+                FlagsContinuation* cont,
+                CanCombineWithLoad canCombineWithLoad) {
+  S390OperandGenerator g(selector);
+  Int32BinopMatcher m(node);
+  Node* left = m.left().node();
+  Node* right = m.right().node();
+  InstructionOperand inputs[8];
+  size_t input_count = 0;
+  InstructionOperand outputs[2];
+  size_t output_count = 0;
+
+  if (node->op()->HasProperty(Operator::kCommutative) &&
+      !g.CanBeImmediate(right, operand_mode) &&
+      (g.CanBeBetterLeftOperand(right))) {
+    std::swap(left, right);
+  }
+
+  GenerateBinOpOperands(selector, node, left, right, opcode, operand_mode,
+                        inputs, input_count, canCombineWithLoad);
+
+  if (cont->IsBranch()) {
+    inputs[input_count++] = g.Label(cont->true_block());
+    inputs[input_count++] = g.Label(cont->false_block());
+  }
+
+  if ((operand_mode & OperandMode::kAllowDistinctOps) &&
+      // If we can deoptimize as a result of the binop, we need to make sure
+      // that the deopt inputs are not overwritten by the binop result. One way
+      // to achieve that is to declare the output register as same-as-first.
+      !cont->IsDeoptimize()) {
+    outputs[output_count++] = g.DefineAsRegister(node);
+  } else {
+    outputs[output_count++] = g.DefineSameAsFirst(node);
+  }
+
+  if (cont->IsSet()) {
+    outputs[output_count++] = g.DefineAsRegister(cont->result());
+  }
+
+  DCHECK_NE(0u, input_count);
+  DCHECK_NE(0u, output_count);
+  DCHECK_GE(arraysize(inputs), input_count);
+  DCHECK_GE(arraysize(outputs), output_count);
+
+  opcode = cont->Encode(opcode);
+
+  if (cont->IsDeoptimize()) {
+    selector->EmitDeoptimize(opcode, output_count, outputs, input_count, inputs,
+                             cont->kind(), cont->reason(), cont->frame_state());
+  } else if (cont->IsTrap()) {
+    inputs[input_count++] = g.UseImmediate(cont->trap_id());
+    selector->Emit(opcode, output_count, outputs, input_count, inputs);
+  } else {
+    selector->Emit(opcode, output_count, outputs, input_count, inputs);
+  }
 }
 
 void VisitBin32op(InstructionSelector* selector, Node* node,
                   InstructionCode opcode, OperandModes operand_mode,
                   FlagsContinuation* cont) {
   S390OperandGenerator g(selector);
   Int32BinopMatcher m(node);
   Node* left = m.left().node();
   Node* right = m.right().node();
   InstructionOperand inputs[8];
@@ skipping 17 matching lines @@
     std::swap(left, right);
   }
 #else
   if (node->op()->HasProperty(Operator::kCommutative) &&
       !g.CanBeImmediate(right, operand_mode) &&
       (g.CanBeBetterLeftOperand(right))) {
     std::swap(left, right);
   }
 #endif
 
-  // left is always register
-  InstructionOperand const left_input = g.UseRegister(left);
-  inputs[input_count++] = left_input;
-
-  // TODO(turbofan): match complex addressing modes.
-  if (left == right) {
-    // If both inputs refer to the same operand, enforce allocating a register
-    // for both of them to ensure that we don't end up generating code like
-    // this:
-    //
-    //   mov rax, [rbp-0x10]
-    //   add rax, [rbp-0x10]
-    //   jo label
-    inputs[input_count++] = left_input;
-    // Can only be RR or RRR
-    operand_mode &= OperandMode::kAllowRRR;
-  } else if ((operand_mode & OperandMode::kAllowImmediate) &&
-             g.CanBeImmediate(right, operand_mode)) {
-    inputs[input_count++] = g.UseImmediate(right);
-    // Can only be RI or RRI
-    operand_mode &= OperandMode::kAllowImmediate;
-  } else if (operand_mode & OperandMode::kAllowMemoryOperand) {
-    NodeMatcher mright(right);
-    if (mright.IsLoad() && selector->CanCover(node, right) &&
-        SelectLoadOpcode(right) == kS390_LoadWordU32) {
-      AddressingMode mode =
-          g.GetEffectiveAddressMemoryOperand(right, inputs, &input_count);
-      opcode |= AddressingModeField::encode(mode);
-      operand_mode &= ~OperandMode::kAllowImmediate;
-      if (operand_mode & OperandMode::kAllowRM)
-        operand_mode &= ~OperandMode::kAllowDistinctOps;
-    } else if (operand_mode & OperandMode::kAllowRM) {
-      DCHECK(!(operand_mode & OperandMode::kAllowRRM));
-      inputs[input_count++] = g.Use(right);
-      // Can not be Immediate
-      operand_mode &=
-          ~OperandMode::kAllowImmediate & ~OperandMode::kAllowDistinctOps;
-    } else if (operand_mode & OperandMode::kAllowRRM) {
-      DCHECK(!(operand_mode & OperandMode::kAllowRM));
-      inputs[input_count++] = g.Use(right);
-      // Can not be Immediate
-      operand_mode &= ~OperandMode::kAllowImmediate;
-    } else {
-      UNREACHABLE();
-    }
-  } else {
-    inputs[input_count++] = g.UseRegister(right);
-    // Can only be RR or RRR
-    operand_mode &= OperandMode::kAllowRRR;
-  }
+  GenerateBinOpOperands(selector, node, left, right, opcode, operand_mode,
+                        inputs, input_count, [](ArchOpcode opcode) {
+                          return opcode == kS390_LoadWordU32 ||
+                                 opcode == kS390_LoadWordS32;
+                        });
 
   bool doZeroExt =
       AutoZeroExtendsWord32ToWord64(node) || !ZeroExtendsWord32ToWord64(left);
 
   inputs[input_count++] =
       g.TempImmediate(doZeroExt && (!AutoZeroExtendsWord32ToWord64(node)));
 
   if (cont->IsBranch()) {
     inputs[input_count++] = g.Label(cont->true_block());
     inputs[input_count++] = g.Label(cont->false_block());
@@ skipping 30 matching lines @@
   } else {
     selector->Emit(opcode, output_count, outputs, input_count, inputs);
   }
 }
 
 void VisitBin32op(InstructionSelector* selector, Node* node, ArchOpcode opcode,
                   OperandModes operand_mode) {
   FlagsContinuation cont;
   VisitBin32op(selector, node, opcode, operand_mode, &cont);
 }
+#undef VISIT_OP_LIST
 
 }  // namespace
 
 void InstructionSelector::VisitLoad(Node* node) {
   S390OperandGenerator g(this);
   ArchOpcode opcode = SelectLoadOpcode(node);
   InstructionOperand outputs[1];
   outputs[0] = g.DefineAsRegister(node);
   InstructionOperand inputs[3];
   size_t input_count = 0;
@@ skipping 248 matching lines @@
   int mask_msb = base::bits::CountLeadingZeros64(value);
   int mask_lsb = base::bits::CountTrailingZeros64(value);
   if ((mask_width == 0) || (mask_msb + mask_width + mask_lsb != 64))
     return false;
   *mb = mask_lsb + mask_width - 1;
   *me = mask_lsb;
   return true;
 }
 #endif
 
-void InstructionSelector::VisitWord32And(Node* node) {
-  VisitBin32op(this, node, kS390_And32, AndOperandMode);
-}
+// TODO(john.yan): use list to simplify general instructions
+#define WORD32_BIN_OP_LIST(V)                         \
+  /* V(name, ArchOpcode, OperandModes) */             \
+  V(Word32And, kS390_And32, And32OperandMode)         \
+  V(Word32Or, kS390_Or32, Or32OperandMode)            \
+  V(Word32Xor, kS390_Xor32, Xor32OperandMode)         \
+  V(Word32Shl, kS390_ShiftLeft32, Shift32OperandMode) \
+  V(Word32Shr, kS390_ShiftRight32, Shift32OperandMode)
+
+#define VISITOR(name, op, mode)                       \
+  void InstructionSelector::Visit##name(Node* node) { \
+    VisitBin32op(this, node, op, mode);               \
+  }
+WORD32_BIN_OP_LIST(VISITOR);
+#undef VISITOR
+#undef WORD32_BIN_OP_LIST
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64And(Node* node) {
   S390OperandGenerator g(this);
   Int64BinopMatcher m(node);
   int mb = 0;
   int me = 0;
   if (m.right().HasValue() && IsContiguousMask64(m.right().Value(), &mb, &me)) {
     int sh = 0;
     Node* left = m.left().node();
@@ skipping 23 matching lines @@
         mask = mb;
       } else if (mb == 63) {
         match = true;
         opcode = kS390_RotLeftAndClearRight64;
         mask = me;
       } else if (sh && me <= sh && m.left().IsWord64Shl()) {
         match = true;
         opcode = kS390_RotLeftAndClear64;
         mask = mb;
       }
-      if (match) {
+      if (match && CpuFeatures::IsSupported(GENERAL_INSTR_EXT)) {
         Emit(opcode, g.DefineAsRegister(node), g.UseRegister(left),
              g.TempImmediate(sh), g.TempImmediate(mask));
         return;
       }
     }
   }
-  VisitBinop<Int64BinopMatcher>(this, node, kS390_And64,
-                                OperandMode::kUint32Imm);
-}
-#endif
-
-void InstructionSelector::VisitWord32Or(Node* node) {
-  VisitBin32op(this, node, kS390_Or32, OrOperandMode);
+  VisitWord64BinOp(this, node, kS390_And64, And64OperandMode);
 }
 
-#if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Or(Node* node) {
-  Int64BinopMatcher m(node);
-  VisitBinop<Int64BinopMatcher>(this, node, kS390_Or64,
-                                OperandMode::kUint32Imm);
-}
-#endif
-
-void InstructionSelector::VisitWord32Xor(Node* node) {
-  VisitBin32op(this, node, kS390_Xor32, XorOperandMode);
+  VisitWord64BinOp(this, node, kS390_Or64, Or64OperandMode);
 }
 
-#if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Xor(Node* node) {
-  VisitBinop<Int64BinopMatcher>(this, node, kS390_Xor64,
-                                OperandMode::kUint32Imm);
-}
-#endif
-
-void InstructionSelector::VisitWord32Shl(Node* node) {
-  VisitBin32op(this, node, kS390_ShiftLeft32, ShiftOperandMode);
+  VisitWord64BinOp(this, node, kS390_Xor64, Xor64OperandMode);
 }
 
-#if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Shl(Node* node) {
   S390OperandGenerator g(this);
   Int64BinopMatcher m(node);
   // TODO(mbrandy): eliminate left sign extension if right >= 32
   if (m.left().IsWord64And() && m.right().IsInRange(0, 63)) {
     Int64BinopMatcher mleft(m.left().node());
     int sh = m.right().Value();
     int mb;
     int me;
     if (mleft.right().HasValue() &&
@@ skipping 10 matching lines @@
           mask = mb;
         } else if (mb == 63) {
           match = true;
           opcode = kS390_RotLeftAndClearRight64;
           mask = me;
         } else if (sh && me <= sh) {
           match = true;
           opcode = kS390_RotLeftAndClear64;
           mask = mb;
         }
-        if (match) {
+        if (match && CpuFeatures::IsSupported(GENERAL_INSTR_EXT)) {
           Emit(opcode, g.DefineAsRegister(node),
                g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
                g.TempImmediate(mask));
           return;
         }
       }
     }
   }
-  VisitRRO(this, kS390_ShiftLeft64, node, OperandMode::kShift64Imm);
-}
-#endif
-
-void InstructionSelector::VisitWord32Shr(Node* node) {
-  VisitBin32op(this, node, kS390_ShiftRight32, ShiftOperandMode);
+  VisitWord64BinOp(this, node, kS390_ShiftLeft64, Shift64OperandMode);
 }
 
-#if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Shr(Node* node) {
   S390OperandGenerator g(this);
   Int64BinopMatcher m(node);
   if (m.left().IsWord64And() && m.right().IsInRange(0, 63)) {
     Int64BinopMatcher mleft(m.left().node());
     int sh = m.right().Value();
     int mb;
     int me;
     if (mleft.right().HasValue() &&
         IsContiguousMask64((uint64_t)(mleft.right().Value()) >> sh, &mb, &me)) {
@@ skipping 15 matching lines @@
         }
         if (match) {
           Emit(opcode, g.DefineAsRegister(node),
                g.UseRegister(mleft.left().node()), g.TempImmediate(sh),
                g.TempImmediate(mask));
           return;
         }
       }
     }
   }
-  VisitRRO(this, kS390_ShiftRight64, node, OperandMode::kShift64Imm);
+  VisitWord64BinOp(this, node, kS390_ShiftRight64, Shift64OperandMode);
 }
 #endif
 
 void InstructionSelector::VisitWord32Sar(Node* node) {
   S390OperandGenerator g(this);
   Int32BinopMatcher m(node);
   // Replace with sign extension for (x << K) >> K where K is 16 or 24.
   if (CanCover(node, m.left().node()) && m.left().IsWord32Shl()) {
     Int32BinopMatcher mleft(m.left().node());
     if (mleft.right().Is(16) && m.right().Is(16)) {
       bool doZeroExt = !ZeroExtendsWord32ToWord64(mleft.left().node());
       Emit(kS390_ExtendSignWord16,
            doZeroExt ? g.DefineAsRegister(node) : g.DefineSameAsFirst(node),
            g.UseRegister(mleft.left().node()), g.TempImmediate(doZeroExt));
       return;
     } else if (mleft.right().Is(24) && m.right().Is(24)) {
       bool doZeroExt = !ZeroExtendsWord32ToWord64(mleft.left().node());
       Emit(kS390_ExtendSignWord8,
            doZeroExt ? g.DefineAsRegister(node) : g.DefineSameAsFirst(node),
            g.UseRegister(mleft.left().node()), g.TempImmediate(doZeroExt));
       return;
     }
   }
-  VisitBin32op(this, node, kS390_ShiftRightArith32, ShiftOperandMode);
+  VisitBin32op(this, node, kS390_ShiftRightArith32, Shift32OperandMode);
 }
 
 #if !V8_TARGET_ARCH_S390X
 void VisitPairBinop(InstructionSelector* selector, InstructionCode opcode,
                     InstructionCode opcode2, Node* node) {
   S390OperandGenerator g(selector);
 
   Node* projection1 = NodeProperties::FindProjection(node, 1);
   if (projection1) {
     // We use UseUniqueRegister here to avoid register sharing with the output
@@ skipping 92 matching lines @@
   VisitPairShift(this, kS390_ShiftRightPair, node);
 }
 
 void InstructionSelector::VisitWord32PairSar(Node* node) {
   VisitPairShift(this, kS390_ShiftRightArithPair, node);
 }
 #endif
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Sar(Node* node) {
-  VisitRRO(this, kS390_ShiftRightArith64, node, OperandMode::kShift64Imm);
+  VisitWord64BinOp(this, node, kS390_ShiftRightArith64, Shift64OperandMode);
 }
 #endif
 
 void InstructionSelector::VisitWord32Ror(Node* node) {
   // TODO(john): match dst = ror(src1, src2 + imm)
   VisitBin32op(this, node, kS390_RotRight32,
                OperandMode::kAllowRI | OperandMode::kAllowRRR |
                    OperandMode::kAllowRRI | OperandMode::kShift32Imm);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Ror(Node* node) {
-  VisitRRO(this, kS390_RotRight64, node, OperandMode::kShift64Imm);
+  VisitWord64BinOp(this, node, kS390_RotRight64, Shift64OperandMode);
 }
 #endif
 
 void InstructionSelector::VisitWord32Clz(Node* node) {
   VisitRR(this, kS390_Cntlz32, node);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Clz(Node* node) {
   S390OperandGenerator g(this);
@@ skipping 52 matching lines @@
   Emit(kS390_LoadReverse32RR, g.DefineAsRegister(node),
        g.UseRegister(node->InputAt(0)));
 }
 
 void InstructionSelector::VisitInt32Add(Node* node) {
   VisitBin32op(this, node, kS390_Add32, AddOperandMode);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitInt64Add(Node* node) {
-  VisitBinop<Int64BinopMatcher>(this, node, kS390_Add64,
-                                OperandMode::kInt32Imm);
+  VisitWord64BinOp(this, node, kS390_Add64, AddOperandMode);
 }
 #endif
 
 void InstructionSelector::VisitInt32Sub(Node* node) {
   S390OperandGenerator g(this);
   Int32BinopMatcher m(node);
   if (m.left().Is(0)) {
     Node* right = m.right().node();
     bool doZeroExt = ZeroExtendsWord32ToWord64(right);
     Emit(kS390_Neg32, g.DefineAsRegister(node), g.UseRegister(right),
          g.TempImmediate(doZeroExt));
   } else {
     VisitBin32op(this, node, kS390_Sub32, SubOperandMode);
   }
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitInt64Sub(Node* node) {
   S390OperandGenerator g(this);
   Int64BinopMatcher m(node);
   if (m.left().Is(0)) {
     Emit(kS390_Neg64, g.DefineAsRegister(node),
          g.UseRegister(m.right().node()));
   } else {
-    VisitBinop<Int64BinopMatcher>(this, node, kS390_Sub64,
-                                  OperandMode::kInt32Imm_Negate);
+    VisitWord64BinOp(this, node, kS390_Sub64, SubOperandMode);
   }
 }
 #endif
 
-namespace {
-
-void VisitCompare(InstructionSelector* selector, InstructionCode opcode,
-                  InstructionOperand left, InstructionOperand right,
-                  FlagsContinuation* cont);
-
-#if V8_TARGET_ARCH_S390X
-void VisitMul(InstructionSelector* selector, Node* node, ArchOpcode opcode) {
-  S390OperandGenerator g(selector);
-  Int32BinopMatcher m(node);
-  Node* left = m.left().node();
-  Node* right = m.right().node();
-  if (g.CanBeImmediate(right, OperandMode::kInt32Imm)) {
-    selector->Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(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));
-  }
-}
-#endif
-
-}  // namespace
-
 void InstructionSelector::VisitInt32MulWithOverflow(Node* node) {
   if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
     FlagsContinuation cont = FlagsContinuation::ForSet(kNotEqual, ovf);
     return VisitBin32op(this, node, kS390_Mul32WithOverflow,
                         OperandMode::kInt32Imm | OperandMode::kAllowDistinctOps,
                         &cont);
   }
   VisitBin32op(this, node, kS390_Mul32, MulOperandMode);
 }
 
@@ skipping 24 matching lines @@
   Int64BinopMatcher m(node);
   Node* left = m.left().node();
   Node* right = m.right().node();
   if (g.CanBeImmediate(right, OperandMode::kInt32Imm) &&
       base::bits::IsPowerOfTwo64(g.GetImmediate(right))) {
     int power = 63 - base::bits::CountLeadingZeros64(g.GetImmediate(right));
     Emit(kS390_ShiftLeft64, g.DefineSameAsFirst(node), g.UseRegister(left),
          g.UseImmediate(power));
     return;
   }
-  VisitMul(this, node, kS390_Mul64);
+  VisitWord64BinOp(this, node, kS390_Mul64, MulOperandMode);
 }
 #endif
 
 void InstructionSelector::VisitInt32MulHigh(Node* node) {
   VisitBin32op(this, node, kS390_MulHigh32,
                OperandMode::kInt32Imm | OperandMode::kAllowDistinctOps);
 }
 
 void InstructionSelector::VisitUint32MulHigh(Node* node) {
   VisitBin32op(this, node, kS390_MulHighU32,
                OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 
 void InstructionSelector::VisitInt32Div(Node* node) {
   VisitBin32op(this, node, kS390_Div32,
                OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitInt64Div(Node* node) {
-  VisitRRR(this, kS390_Div64, node);
+  VisitWord64BinOp(this, node, kS390_Div64,
+                   OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 #endif
 
 void InstructionSelector::VisitUint32Div(Node* node) {
   VisitBin32op(this, node, kS390_DivU32,
                OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitUint64Div(Node* node) {
-  VisitRRR(this, kS390_DivU64, node);
+  VisitWord64BinOp(this, node, kS390_DivU64,
+                   OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 #endif
 
 void InstructionSelector::VisitInt32Mod(Node* node) {
   VisitBin32op(this, node, kS390_Mod32,
                OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitInt64Mod(Node* node) {
-  VisitRRR(this, kS390_Mod64, node);
+  VisitWord64BinOp(this, node, kS390_Mod64,
+                   OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 #endif
 
 void InstructionSelector::VisitUint32Mod(Node* node) {
   VisitBin32op(this, node, kS390_ModU32,
                OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitUint64Mod(Node* node) {
-  VisitRRR(this, kS390_ModU64, node);
+  VisitWord64BinOp(this, node, kS390_ModU64,
+                   OperandMode::kAllowRRM | OperandMode::kAllowRRR);
 }
 #endif
 
-void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
-  VisitRR(this, kS390_Float32ToDouble, node);
-}
+// TODO(john.yan): place kAllowRM where available
+#define VISIT_FLOAT_UNARY_OP_LIST(V)                                           \
+  V(Float32, ChangeFloat32ToFloat64, kS390_Float32ToDouble,                    \
+    OperandMode::kAllowRM)                                                     \
+  V(Float32, BitcastFloat32ToInt32, kS390_BitcastFloat32ToInt32,               \
+    OperandMode::kNone)                                                        \
+  V(Float64, TruncateFloat64ToFloat32, kS390_DoubleToFloat32,                  \
+    OperandMode::kNone)                                                        \
+  V(Float64, TruncateFloat64ToWord32, kArchTruncateDoubleToI,                  \
+    OperandMode::kNone)                                                        \
+  V(Float64, RoundFloat64ToInt32, kS390_DoubleToInt32, OperandMode::kNone)     \
+  V(Float32, TruncateFloat32ToInt32, kS390_Float32ToInt32, OperandMode::kNone) \
+  V(Float32, TruncateFloat32ToUint32, kS390_Float32ToUint32,                   \
+    OperandMode::kNone)                                                        \
+  V(Float64, ChangeFloat64ToInt32, kS390_DoubleToInt32, OperandMode::kNone)    \
+  V(Float64, ChangeFloat64ToUint32, kS390_DoubleToUint32, OperandMode::kNone)  \
+  V(Float64, TruncateFloat64ToUint32, kS390_DoubleToUint32,                    \
+    OperandMode::kNone)                                                        \
+  V(Float64, Float64SilenceNaN, kS390_Float64SilenceNaN, OperandMode::kNone)   \
+  V(Float32, Float32Abs, kS390_AbsFloat, OperandMode::kNone)                   \
+  V(Float64, Float64Abs, kS390_AbsDouble, OperandMode::kNone)                  \
+  V(Float32, Float32Sqrt, kS390_SqrtFloat, OperandMode::kNone)                 \
+  V(Float64, Float64Sqrt, kS390_SqrtDouble, OperandMode::kNone)                \
+  V(Float32, Float32RoundDown, kS390_FloorFloat, OperandMode::kNone)           \
+  V(Float64, Float64RoundDown, kS390_FloorDouble, OperandMode::kNone)          \
+  V(Float32, Float32RoundUp, kS390_CeilFloat, OperandMode::kNone)              \
+  V(Float64, Float64RoundUp, kS390_CeilDouble, OperandMode::kNone)             \
+  V(Float32, Float32RoundTruncate, kS390_TruncateFloat, OperandMode::kNone)    \
+  V(Float64, Float64RoundTruncate, kS390_TruncateDouble, OperandMode::kNone)   \
+  V(Float64, Float64RoundTiesAway, kS390_RoundDouble, OperandMode::kNone)      \
+  V(Float32, Float32Neg, kS390_NegFloat, OperandMode::kNone)                   \
+  V(Float64, Float64Neg, kS390_NegDouble, OperandMode::kNone)
+
+#define VISIT_WORD64_UNARY_OP_LIST(V)                                        \
+  V(Word64, TruncateInt64ToInt32, kS390_Int64ToInt32, OperandMode::kNone)    \
+  V(Word64, RoundInt64ToFloat32, kS390_Int64ToFloat32, OperandMode::kNone)   \
+  V(Word64, RoundInt64ToFloat64, kS390_Int64ToDouble, OperandMode::kNone)    \
+  V(Word64, RoundUint64ToFloat32, kS390_Uint64ToFloat32, OperandMode::kNone) \
+  V(Word64, RoundUint64ToFloat64, kS390_Uint64ToDouble, OperandMode::kNone)  \
+  V(Word64, BitcastInt64ToFloat64, kS390_BitcastInt64ToDouble,               \
+    OperandMode::kNone)                                                      \
+  V(Float64, BitcastFloat64ToInt64, kS390_BitcastDoubleToInt64,              \
+    OperandMode::kNone)
+
+#define DECLARE_UNARY_OP(type, name, op, mode)        \
+  void InstructionSelector::Visit##name(Node* node) { \
+    Visit##type##UnaryOp(this, node, op, mode);       \
+  }
+
+VISIT_FLOAT_UNARY_OP_LIST(DECLARE_UNARY_OP);
+
+#if V8_TARGET_ARCH_S390X
+VISIT_WORD64_UNARY_OP_LIST(DECLARE_UNARY_OP)
+#endif
+
+#undef DECLARE_UNARY_OP
+#undef VISIT_WORD64_UNARY_OP_LIST
+#undef VISIT_FLOAT_UNARY_OP_LIST
 
 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) {
   VisitRR(this, kS390_Int32ToFloat32, node);
 }
 
 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) {
   VisitRR(this, kS390_Uint32ToFloat32, node);
 }
 
 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) {
   VisitRR(this, kS390_Int32ToDouble, node);
 }
 
 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) {
   VisitRR(this, kS390_Uint32ToDouble, node);
 }
 
-void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) {
-  VisitRR(this, kS390_DoubleToInt32, node);
-}
-
-void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) {
-  VisitRR(this, kS390_DoubleToUint32, node);
-}
-
-void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) {
-  VisitRR(this, kS390_DoubleToUint32, node);
-}
-
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) {
   VisitTryTruncateDouble(this, kS390_Float32ToInt64, node);
 }
 
 void InstructionSelector::VisitTryTruncateFloat64ToInt64(Node* node) {
   VisitTryTruncateDouble(this, kS390_DoubleToInt64, node);
 }
 
 void InstructionSelector::VisitTryTruncateFloat32ToUint64(Node* node) {
@@ skipping 14 matching lines @@
   Node* value = node->InputAt(0);
   if (ZeroExtendsWord32ToWord64(value)) {
     // These 32-bit operations implicitly zero-extend to 64-bit on x64, so the
     // zero-extension is a no-op.
     return EmitIdentity(node);
   }
   VisitRR(this, kS390_Uint32ToUint64, node);
 }
 #endif
 
-void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) {
-  VisitRR(this, kS390_DoubleToFloat32, node);
-}
-
-void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) {
-  VisitRR(this, kArchTruncateDoubleToI, node);
-}
-
-void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) {
-  VisitRR(this, kS390_DoubleToInt32, node);
-}
-
-void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) {
-  VisitRR(this, kS390_Float32ToInt32, node);
-}
-
-void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) {
-  VisitRR(this, kS390_Float32ToUint32, node);
-}
-
-#if V8_TARGET_ARCH_S390X
-void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) {
-  // TODO(mbrandy): inspect input to see if nop is appropriate.
-  VisitRR(this, kS390_Int64ToInt32, node);
-}
-
-void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) {
-  VisitRR(this, kS390_Int64ToFloat32, node);
-}
-
-void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) {
-  VisitRR(this, kS390_Int64ToDouble, node);
-}
-
-void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) {
-  VisitRR(this, kS390_Uint64ToFloat32, node);
-}
-
-void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) {
-  VisitRR(this, kS390_Uint64ToDouble, node);
-}
-#endif
-
-void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) {
-  VisitRR(this, kS390_BitcastFloat32ToInt32, node);
-}
-
-#if V8_TARGET_ARCH_S390X
-void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) {
-  VisitRR(this, kS390_BitcastDoubleToInt64, node);
-}
-#endif
-
 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) {
   VisitRR(this, kS390_BitcastInt32ToFloat32, node);
 }
 
-#if V8_TARGET_ARCH_S390X
-void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) {
-  VisitRR(this, kS390_BitcastInt64ToDouble, node);
-}
-#endif
-
 void InstructionSelector::VisitFloat32Add(Node* node) {
-  VisitRRR(this, kS390_AddFloat, node);
+  return VisitFloat32BinOp(this, node, kS390_AddFloat, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat64Add(Node* node) {
   // TODO(mbrandy): detect multiply-add
-  VisitRRR(this, kS390_AddDouble, node);
+  return VisitFloat64BinOp(this, node, kS390_AddDouble, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat32Sub(Node* node) {
-  VisitRRR(this, kS390_SubFloat, node);
+  return VisitFloat32BinOp(this, node, kS390_SubFloat, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat64Sub(Node* node) {
   // TODO(mbrandy): detect multiply-subtract
-  VisitRRR(this, kS390_SubDouble, node);
+  return VisitFloat64BinOp(this, node, kS390_SubDouble, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat32Mul(Node* node) {
-  VisitRRR(this, kS390_MulFloat, node);
+  return VisitFloat32BinOp(this, node, kS390_MulFloat, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat64Mul(Node* node) {
   // TODO(mbrandy): detect negate
-  VisitRRR(this, kS390_MulDouble, node);
+  return VisitFloat64BinOp(this, node, kS390_MulDouble, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat32Div(Node* node) {
-  VisitRRR(this, kS390_DivFloat, node);
+  return VisitFloat32BinOp(this, node, kS390_DivFloat, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat64Div(Node* node) {
-  VisitRRR(this, kS390_DivDouble, node);
+  return VisitFloat64BinOp(this, node, kS390_DivDouble, OperandMode::kAllowRM);
 }
 
 void InstructionSelector::VisitFloat64Mod(Node* node) {
   S390OperandGenerator g(this);
   Emit(kS390_ModDouble, g.DefineAsFixed(node, d1),
        g.UseFixed(node->InputAt(0), d1), g.UseFixed(node->InputAt(1), d2))
       ->MarkAsCall();
 }
 
 void InstructionSelector::VisitFloat32Max(Node* node) {
-  VisitRRR(this, kS390_MaxFloat, node);
+  return VisitFloat32BinOp(this, node, kS390_MaxFloat, OperandMode::kNone);
 }
 
 void InstructionSelector::VisitFloat64Max(Node* node) {
-  VisitRRR(this, kS390_MaxDouble, node);
-}
-
-void InstructionSelector::VisitFloat64SilenceNaN(Node* node) {
-  VisitRR(this, kS390_Float64SilenceNaN, node);
+  return VisitFloat64BinOp(this, node, kS390_MaxDouble, OperandMode::kNone);
 }
 
 void InstructionSelector::VisitFloat32Min(Node* node) {
-  VisitRRR(this, kS390_MinFloat, node);
+  return VisitFloat32BinOp(this, node, kS390_MinFloat, OperandMode::kNone);
 }
 
 void InstructionSelector::VisitFloat64Min(Node* node) {
-  VisitRRR(this, kS390_MinDouble, node);
-}
-
-void InstructionSelector::VisitFloat32Abs(Node* node) {
-  VisitRR(this, kS390_AbsFloat, node);
-}
-
-void InstructionSelector::VisitFloat64Abs(Node* node) {
-  VisitRR(this, kS390_AbsDouble, node);
-}
-
-void InstructionSelector::VisitFloat32Sqrt(Node* node) {
-  VisitRR(this, kS390_SqrtFloat, node);
+  return VisitFloat64BinOp(this, node, kS390_MinDouble, OperandMode::kNone);
 }
 
 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node,
                                                   InstructionCode opcode) {
   S390OperandGenerator g(this);
   Emit(opcode, g.DefineAsFixed(node, d1), g.UseFixed(node->InputAt(0), d1))
       ->MarkAsCall();
 }
 
 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node,
                                                    InstructionCode opcode) {
   S390OperandGenerator g(this);
   Emit(opcode, g.DefineAsFixed(node, d1), g.UseFixed(node->InputAt(0), d1),
        g.UseFixed(node->InputAt(1), d2))
       ->MarkAsCall();
 }
 
-void InstructionSelector::VisitFloat64Sqrt(Node* node) {
-  VisitRR(this, kS390_SqrtDouble, node);
-}
-
-void InstructionSelector::VisitFloat32RoundDown(Node* node) {
-  VisitRR(this, kS390_FloorFloat, node);
-}
-
-void InstructionSelector::VisitFloat64RoundDown(Node* node) {
-  VisitRR(this, kS390_FloorDouble, node);
-}
-
-void InstructionSelector::VisitFloat32RoundUp(Node* node) {
-  VisitRR(this, kS390_CeilFloat, node);
-}
-
-void InstructionSelector::VisitFloat64RoundUp(Node* node) {
-  VisitRR(this, kS390_CeilDouble, node);
-}
-
-void InstructionSelector::VisitFloat32RoundTruncate(Node* node) {
-  VisitRR(this, kS390_TruncateFloat, node);
-}
-
-void InstructionSelector::VisitFloat64RoundTruncate(Node* node) {
-  VisitRR(this, kS390_TruncateDouble, node);
-}
-
-void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) {
-  VisitRR(this, kS390_RoundDouble, node);
-}
-
 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) {
   UNREACHABLE();
 }
 
 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) {
   UNREACHABLE();
 }
 
-void InstructionSelector::VisitFloat32Neg(Node* node) {
-  VisitRR(this, kS390_NegFloat, node);
-}
-
-void InstructionSelector::VisitFloat64Neg(Node* node) {
-  VisitRR(this, kS390_NegDouble, node);
-}
-
 void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
   OperandModes mode = AddOperandMode;
   if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
     FlagsContinuation cont = FlagsContinuation::ForSet(kOverflow, ovf);
     return VisitBin32op(this, node, kS390_Add32, mode, &cont);
   }
   FlagsContinuation cont;
   VisitBin32op(this, node, kS390_Add32, mode, &cont);
 }
 
 void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
   OperandModes mode = SubOperandMode;
   if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
     FlagsContinuation cont = FlagsContinuation::ForSet(kOverflow, ovf);
     return VisitBin32op(this, node, kS390_Sub32, mode, &cont);
   }
   FlagsContinuation cont;
   VisitBin32op(this, node, kS390_Sub32, mode, &cont);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitInt64AddWithOverflow(Node* node) {
   if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
     FlagsContinuation cont = FlagsContinuation::ForSet(kOverflow, ovf);
-    return VisitBinop<Int64BinopMatcher>(this, node, kS390_Add64,
-                                         OperandMode::kInt32Imm, &cont);
+    return VisitWord64BinOp(this, node, kS390_Add64, AddOperandMode, &cont);
   }
-  FlagsContinuation cont;
-  VisitBinop<Int64BinopMatcher>(this, node, kS390_Add64, OperandMode::kInt32Imm,
-                                &cont);
+  VisitWord64BinOp(this, node, kS390_Add64, AddOperandMode);
 }
 
 void InstructionSelector::VisitInt64SubWithOverflow(Node* node) {
   if (Node* ovf = NodeProperties::FindProjection(node, 1)) {
     FlagsContinuation cont = FlagsContinuation::ForSet(kOverflow, ovf);
-    return VisitBinop<Int64BinopMatcher>(this, node, kS390_Sub64,
-                                         OperandMode::kInt32Imm_Negate, &cont);
+    return VisitWord64BinOp(this, node, kS390_Sub64, SubOperandMode, &cont);
   }
-  FlagsContinuation cont;
-  VisitBinop<Int64BinopMatcher>(this, node, kS390_Sub64,
-                                OperandMode::kInt32Imm_Negate, &cont);
+  VisitWord64BinOp(this, node, kS390_Sub64, SubOperandMode);
 }
 #endif
 
 static bool CompareLogical(FlagsContinuation* cont) {
   switch (cont->condition()) {
     case kUnsignedLessThan:
     case kUnsignedGreaterThanOrEqual:
     case kUnsignedLessThanOrEqual:
     case kUnsignedGreaterThan:
       return true;
@@ skipping 341 matching lines @@
                                     cont);
               case IrOpcode::kInt32MulWithOverflow:
                 cont->OverwriteAndNegateIfEqual(kNotEqual);
                 return VisitBin32op(
                     selector, node, kS390_Mul32WithOverflow,
                     OperandMode::kInt32Imm | OperandMode::kAllowDistinctOps,
                     cont);
 #if V8_TARGET_ARCH_S390X
               case IrOpcode::kInt64AddWithOverflow:
                 cont->OverwriteAndNegateIfEqual(kOverflow);
-                return VisitBinop<Int64BinopMatcher>(
-                    selector, node, kS390_Add64, OperandMode::kInt32Imm, cont);
+                return VisitWord64BinOp(selector, node, kS390_Add64,
+                                        AddOperandMode, cont);
               case IrOpcode::kInt64SubWithOverflow:
                 cont->OverwriteAndNegateIfEqual(kOverflow);
-                return VisitBinop<Int64BinopMatcher>(
-                    selector, node, kS390_Sub64, OperandMode::kInt32Imm_Negate,
-                    cont);
+                return VisitWord64BinOp(selector, node, kS390_Sub64,
+                                        SubOperandMode, cont);
 #endif
               default:
                 break;
             }
           }
         }
         break;
       case IrOpcode::kInt32Sub:
         if (fc == kNotEqual || fc == kEqual)
           return VisitWord32Compare(selector, value, cont);
         break;
       case IrOpcode::kWord32And:
         return VisitTestUnderMask(selector, value, cont);
       case IrOpcode::kLoad: {
         LoadRepresentation load_rep = LoadRepresentationOf(value->op());
         switch (load_rep.representation()) {
           case MachineRepresentation::kWord32:
             if (opcode == kS390_LoadAndTestWord32) {
               return VisitLoadAndTest(selector, opcode, user, value, cont);
             }
           default:
             break;
         }
         break;
       }
       case IrOpcode::kInt32Add:
         // can't handle overflow case.
         break;
       case IrOpcode::kWord32Or:
-        return VisitBin32op(selector, value, kS390_Or32, OrOperandMode, cont);
+        if (fc == kNotEqual || fc == kEqual)
+          return VisitBin32op(selector, value, kS390_Or32, Or32OperandMode,
+                              cont);
+        break;
       case IrOpcode::kWord32Xor:
-        return VisitBin32op(selector, value, kS390_Xor32, XorOperandMode, cont);
+        if (fc == kNotEqual || fc == kEqual)
+          return VisitBin32op(selector, value, kS390_Xor32, Xor32OperandMode,
+                              cont);
+        break;
       case IrOpcode::kWord32Sar:
       case IrOpcode::kWord32Shl:
       case IrOpcode::kWord32Shr:
       case IrOpcode::kWord32Ror:
         // doesn't generate cc, so ignore.
         break;
 #if V8_TARGET_ARCH_S390X
       case IrOpcode::kInt64Sub:
         if (fc == kNotEqual || fc == kEqual)
           return VisitWord64Compare(selector, value, cont);
         break;
       case IrOpcode::kWord64And:
         return VisitTestUnderMask(selector, value, cont);
       case IrOpcode::kInt64Add:
         // can't handle overflow case.
         break;
       case IrOpcode::kWord64Or:
-        // TODO(john.yan): need to handle
+        if (fc == kNotEqual || fc == kEqual)
+          return VisitWord64BinOp(selector, value, kS390_Or64, Or64OperandMode,
+                                  cont);
         break;
       case IrOpcode::kWord64Xor:
-        // TODO(john.yan): need to handle
+        if (fc == kNotEqual || fc == kEqual)
+          return VisitWord64BinOp(selector, value, kS390_Xor64,
+                                  Xor64OperandMode, cont);
         break;
       case IrOpcode::kWord64Sar:
       case IrOpcode::kWord64Shl:
       case IrOpcode::kWord64Shr:
       case IrOpcode::kWord64Ror:
         // doesn't generate cc, so ignore
         break;
 #endif
       default:
         break;
@@ skipping 338 matching lines @@
 // static
 MachineOperatorBuilder::AlignmentRequirements
 InstructionSelector::AlignmentRequirements() {
   return MachineOperatorBuilder::AlignmentRequirements::
       FullUnalignedAccessSupport();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8