s390: Remove RSubI on s390 and optimize ConstantI

src/crankshaft/s390/lithium-s390.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 "src/crankshaft/s390/lithium-s390.h"
 
 #include <sstream>
 
 #include "src/crankshaft/hydrogen-osr.h"
 #include "src/crankshaft/lithium-inl.h"
 #include "src/crankshaft/s390/lithium-codegen-s390.h"
 
 namespace v8 {
 namespace internal {
 
 #define DEFINE_COMPILE(type)                           \
   void L##type::CompileToNative(LCodeGen* generator) { \
     generator->Do##type(this);                         \
   }
 LITHIUM_CONCRETE_INSTRUCTION_LIST(DEFINE_COMPILE)
 #undef DEFINE_COMPILE
 
+const char* LInstruction::GetOpcodeName(LInstruction::Opcode op) {
+  switch (op) {

[JoranSiu, 2016/12/07 21:01:42]

What is the purpose of this new function?  I don't see how its related to this
CL.

+#define DECLARE_OPCODE(type) \
+  case Opcode::k##type:      \
+    return #type;
+    LITHIUM_CONCRETE_INSTRUCTION_LIST(DECLARE_OPCODE)
+#undef DECLARE_OPCODE
+    default:
+      return NULL;
+  }
+}
+
 #ifdef DEBUG
 void LInstruction::VerifyCall() {
   // Call instructions can use only fixed registers as temporaries and
   // outputs because all registers are blocked by the calling convention.
   // Inputs operands must use a fixed register or use-at-start policy or
   // a non-register policy.
   DCHECK(Output() == NULL || LUnallocated::cast(Output())->HasFixedPolicy() ||
          !LUnallocated::cast(Output())->HasRegisterPolicy());
   for (UseIterator it(this); !it.Done(); it.Advance()) {
     LUnallocated* operand = LUnallocated::cast(it.Current());
@@ skipping 1313 matching lines @@
   } else {
     return DoArithmeticT(Token::MUL, instr);
   }
 }
 
 LInstruction* LChunkBuilder::DoSub(HSub* instr) {
   if (instr->representation().IsSmiOrInteger32()) {
     DCHECK(instr->left()->representation().Equals(instr->representation()));
     DCHECK(instr->right()->representation().Equals(instr->representation()));
 
-    if (instr->left()->IsConstant() &&
-        !instr->CheckFlag(HValue::kCanOverflow)) {
-      // If lhs is constant, do reverse subtraction instead.
-      return DoRSub(instr);
-    }
-
     LOperand* left = UseRegisterAtStart(instr->left());
     LOperand* right = UseOrConstantAtStart(instr->right());
     LSubI* sub = new (zone()) LSubI(left, right);
     LInstruction* result = DefineAsRegister(sub);
     if (instr->CheckFlag(HValue::kCanOverflow)) {
       result = AssignEnvironment(result);
     }
     return result;
   } else if (instr->representation().IsDouble()) {
     return DoArithmeticD(Token::SUB, instr);
   } else {
     return DoArithmeticT(Token::SUB, instr);
   }
 }
 
-LInstruction* LChunkBuilder::DoRSub(HSub* instr) {
-  DCHECK(instr->representation().IsSmiOrInteger32());
-  DCHECK(instr->left()->representation().Equals(instr->representation()));
-  DCHECK(instr->right()->representation().Equals(instr->representation()));
-  DCHECK(!instr->CheckFlag(HValue::kCanOverflow));
-
-  // Note: The lhs of the subtraction becomes the rhs of the
-  // reverse-subtraction.
-  LOperand* left = UseRegisterAtStart(instr->right());
-  LOperand* right = UseOrConstantAtStart(instr->left());
-  LRSubI* rsb = new (zone()) LRSubI(left, right);
-  LInstruction* result = DefineAsRegister(rsb);
-  return result;
-}
-
 LInstruction* LChunkBuilder::DoMultiplyAdd(HMul* mul, HValue* addend) {
   LOperand* multiplier_op = UseRegister(mul->left());
   LOperand* multiplicand_op = UseRegister(mul->right());
   LOperand* addend_op = UseRegister(addend);
   return DefineAsRegister(
       new (zone()) LMultiplyAddD(addend_op, multiplier_op, multiplicand_op));
 }
 
 LInstruction* LChunkBuilder::DoMultiplySub(HValue* minuend, HMul* mul) {
   LOperand* minuend_op = UseRegister(minuend);
@@ skipping 764 matching lines @@
 LInstruction* LChunkBuilder::DoLoadFieldByIndex(HLoadFieldByIndex* instr) {
   LOperand* object = UseRegister(instr->object());
   LOperand* index = UseTempRegister(instr->index());
   LLoadFieldByIndex* load = new (zone()) LLoadFieldByIndex(object, index);
   LInstruction* result = DefineSameAsFirst(load);
   return AssignPointerMap(result);
 }
 
 }  // namespace internal
 }  // namespace v8