s390: TF Optimize 32-bit Mul/Div/Mod/Popcnt

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 228 matching lines @@
 }
 
 bool AutoZeroExtendsWord32ToWord64(Node* node) {
 #if !V8_TARGET_ARCH_S390X
   return true;
 #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:
       return true;
     default:
       return false;
   }
   return false;
 #endif
 }
 
 bool ZeroExtendsWord32ToWord64(Node* node) {
 #if !V8_TARGET_ARCH_S390X
   return true;
 #else
   switch (node->opcode()) {
     case IrOpcode::kInt32Add:
     case IrOpcode::kInt32Sub:
     case IrOpcode::kWord32And:
     case IrOpcode::kWord32Or:
     case IrOpcode::kWord32Xor:
     case IrOpcode::kWord32Shl:
     case IrOpcode::kWord32Shr:
     case IrOpcode::kWord32Sar:
     case IrOpcode::kInt32Mul:
     case IrOpcode::kWord32Ror:
     case IrOpcode::kInt32Div:
     case IrOpcode::kUint32Div:
     case IrOpcode::kInt32MulHigh:
     case IrOpcode::kInt32Mod:
     case IrOpcode::kUint32Mod:
+    case IrOpcode::kWord32Popcnt:
       return true;
     // TODO(john.yan): consider the following case to be valid
     // case IrOpcode::kWord32Equal:
     // case IrOpcode::kInt32LessThan:
     // case IrOpcode::kInt32LessThanOrEqual:
     // case IrOpcode::kUint32LessThan:
     // case IrOpcode::kUint32LessThanOrEqual:
     // case IrOpcode::kUint32MulHigh:
     //   // These 32-bit operations implicitly zero-extend to 64-bit on x64, so
     //   the
@@ skipping 852 matching lines @@
                    OperandMode::kAllowRRI | OperandMode::kShift32Imm);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Ror(Node* node) {
   VisitRRO(this, kS390_RotRight64, node, OperandMode::kShift64Imm);
 }
 #endif
 
 void InstructionSelector::VisitWord32Clz(Node* node) {
-  S390OperandGenerator g(this);
-  Emit(kS390_Cntlz32, g.DefineAsRegister(node),
-       g.UseRegister(node->InputAt(0)));
+  VisitRR(this, kS390_Cntlz32, node);
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Clz(Node* node) {
   S390OperandGenerator g(this);
   Emit(kS390_Cntlz64, g.DefineAsRegister(node),
        g.UseRegister(node->InputAt(0)));
 }
 #endif
 
 void InstructionSelector::VisitWord32Popcnt(Node* node) {
   S390OperandGenerator g(this);
-  Emit(kS390_Popcnt32, g.DefineAsRegister(node),
-       g.UseRegister(node->InputAt(0)));
+  Node* value = node->InputAt(0);
+  Emit(kS390_Popcnt32, g.DefineAsRegister(node), g.UseRegister(value));
 }
 
 #if V8_TARGET_ARCH_S390X
 void InstructionSelector::VisitWord64Popcnt(Node* node) {
   S390OperandGenerator g(this);
   Emit(kS390_Popcnt64, g.DefineAsRegister(node),
        g.UseRegister(node->InputAt(0)));
 }
 #endif
 
@@ skipping 146 matching lines @@
   VisitMul(this, node, kS390_Mul64);
 }
 #endif
 
 void InstructionSelector::VisitInt32MulHigh(Node* node) {
   VisitBin32op(this, node, kS390_MulHigh32,
                OperandMode::kInt32Imm | OperandMode::kAllowDistinctOps);
 }
 
 void InstructionSelector::VisitUint32MulHigh(Node* node) {
-  S390OperandGenerator g(this);
-  Int32BinopMatcher m(node);
-  Node* left = m.left().node();
-  Node* right = m.right().node();
-  if (g.CanBeBetterLeftOperand(right)) {
-    std::swap(left, right);
-  }
-  Emit(kS390_MulHighU32, g.DefineAsRegister(node), g.UseRegister(left),
-       g.Use(right));
+  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);
 }
 #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);
 }
 #endif
 
 void InstructionSelector::VisitInt32Mod(Node* node) {
-  VisitRRR(this, kS390_Mod32, 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);
 }
 #endif
 
 void InstructionSelector::VisitUint32Mod(Node* node) {
-  VisitRRR(this, kS390_ModU32, 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);
 }
 #endif
 
 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) {
   VisitRR(this, kS390_Float32ToDouble, node);
@@ skipping 911 matching lines @@
 // static
 MachineOperatorBuilder::AlignmentRequirements
 InstructionSelector::AlignmentRequirements() {
   return MachineOperatorBuilder::AlignmentRequirements::
       FullUnalignedAccessSupport();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8