s390: exploit new mul in TF

src/compiler/s390/code-generator-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/compiler/code-generator.h"
 
 #include "src/compilation-info.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 293 matching lines @@
       return gt;
     case kOverflow:
       // Overflow checked for AddP/SubP only.
       switch (op) {
         case kS390_Add32:
         case kS390_Add64:
         case kS390_Sub32:
         case kS390_Sub64:
         case kS390_Abs64:
         case kS390_Abs32:
+        case kS390_Mul32:
           return overflow;
         default:
           break;
       }
       break;
     case kNotOverflow:
       switch (op) {
         case kS390_Add32:
         case kS390_Add64:
         case kS390_Sub32:
         case kS390_Sub64:
+        case kS390_Abs64:
+        case kS390_Abs32:
+        case kS390_Mul32:
           return nooverflow;
         default:
           break;
       }
       break;
     default:
       break;
   }
   UNREACHABLE();
   return kNoCondition;
@@ skipping 1282 matching lines @@
       }
       break;
     case kS390_SubFloat:
       ASSEMBLE_BIN_OP(DDInstr(sebr), DMTInstr(SubFloat32), nullInstr);
       break;
     case kS390_SubDouble:
       ASSEMBLE_BIN_OP(DDInstr(sdbr), DMTInstr(SubFloat64), nullInstr);
       break;
     case kS390_Mul32:
       // zero-ext
-      ASSEMBLE_BIN32_OP(RRInstr(Mul32), RM32Instr(Mul32), RIInstr(Mul32));
+      if (CpuFeatures::IsSupported(MISC_INSTR_EXT2)) {
+        ASSEMBLE_BIN32_OP(RRRInstr(msrkc), RM32Instr(msc), RIInstr(Mul32));
+      } else {
+        ASSEMBLE_BIN32_OP(RRInstr(Mul32), RM32Instr(Mul32), RIInstr(Mul32));
+      }
       break;
     case kS390_Mul32WithOverflow:
       // zero-ext
       ASSEMBLE_BIN32_OP(RRRInstr(Mul32WithOverflowIfCCUnequal),
                         RRM32Instr(Mul32WithOverflowIfCCUnequal),
                         RRIInstr(Mul32WithOverflowIfCCUnequal));
       break;
     case kS390_Mul64:
       ASSEMBLE_BIN_OP(RRInstr(Mul64), RM64Instr(Mul64), RIInstr(Mul64));
       break;
@@ skipping 904 matching lines @@
 
 // Assembles boolean materializations after an instruction.
 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
                                         FlagsCondition condition) {
   S390OperandConverter i(this, instr);
   ArchOpcode op = instr->arch_opcode();
   bool check_unordered = (op == kS390_CmpDouble || op == kS390_CmpFloat);
 
   // Overflow checked for add/sub only.
   DCHECK((condition != kOverflow && condition != kNotOverflow) ||
-         (op == kS390_Add32 || kS390_Add64 || op == kS390_Sub32 ||
-          op == kS390_Sub64));
+         (op == kS390_Add32 || op == kS390_Add64 || op == kS390_Sub32 ||
+          op == kS390_Sub64 || op == kS390_Mul32));
 
   // Materialize a full 32-bit 1 or 0 value. The result register is always the
   // last output of the instruction.
   DCHECK_NE(0u, instr->OutputCount());
   Register reg = i.OutputRegister(instr->OutputCount() - 1);
   Condition cond = FlagsConditionToCondition(condition, op);
   Label done;
   if (check_unordered) {
     __ LoadImmP(reg, (cond == eq || cond == le || cond == lt) ? Operand::Zero()
                                                               : Operand(1));
@@ skipping 407 matching lines @@
       padding_size -= 2;
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8