Revert "ARM: Use the shifter operand to merge in previous shift instructions."

src/arm/lithium-arm.h

 // Copyright 2012 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.
 
 #ifndef V8_ARM_LITHIUM_ARM_H_
 #define V8_ARM_LITHIUM_ARM_H_
 
 #include "src/hydrogen.h"
 #include "src/lithium.h"
 #include "src/lithium-allocator.h"
@@ skipping 1221 matching lines @@
   LOperand* index() { return inputs_[0]; }
   LOperand* length() { return inputs_[1]; }
 
   DECLARE_CONCRETE_INSTRUCTION(BoundsCheck, "bounds-check")
   DECLARE_HYDROGEN_ACCESSOR(BoundsCheck)
 };
 
 
 class LBitI V8_FINAL : public LTemplateInstruction<1, 2, 0> {
  public:
-  LBitI(LOperand* left, LOperand* right)
-      : shift_(NO_SHIFT), shift_amount_(0)  {
+  LBitI(LOperand* left, LOperand* right) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
-
-  LBitI(LOperand* left, LOperand* right, ShiftOp shift, LOperand* shift_amount)
-      : shift_(shift), shift_amount_(shift_amount)  {
-    inputs_[0] = left;
-    inputs_[1] = right;
-  }
 
   LOperand* left() { return inputs_[0]; }
   LOperand* right() { return inputs_[1]; }
 
-  ShiftOp shift() const { return shift_; }
-  LOperand* shift_amount() const { return shift_amount_; }
-
   Token::Value op() const { return hydrogen()->op(); }
 
   DECLARE_CONCRETE_INSTRUCTION(BitI, "bit-i")
   DECLARE_HYDROGEN_ACCESSOR(Bitwise)
-
- protected:
-  ShiftOp shift_;
-  LOperand* shift_amount_;
 };
 
 
 class LShiftI V8_FINAL : public LTemplateInstruction<1, 2, 0> {
  public:
   LShiftI(Token::Value op, LOperand* left, LOperand* right, bool can_deopt)
       : op_(op), can_deopt_(can_deopt) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
   Token::Value op() const { return op_; }
   LOperand* left() { return inputs_[0]; }
   LOperand* right() { return inputs_[1]; }
   bool can_deopt() const { return can_deopt_; }
 
   DECLARE_CONCRETE_INSTRUCTION(ShiftI, "shift-i")
 
  private:
   Token::Value op_;
   bool can_deopt_;
 };
 
 
 class LSubI V8_FINAL : public LTemplateInstruction<1, 2, 0> {
  public:
-  LSubI(LOperand* left, LOperand* right)
-      : shift_(NO_SHIFT), shift_amount_(0)  {
+  LSubI(LOperand* left, LOperand* right) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
-  LSubI(LOperand* left, LOperand* right, ShiftOp shift, LOperand* shift_amount)
-      : shift_(shift), shift_amount_(shift_amount)  {
-    inputs_[0] = left;
-    inputs_[1] = right;
-  }
-
-  ShiftOp shift() const { return shift_; }
-  LOperand* shift_amount() const { return shift_amount_; }
-
   LOperand* left() { return inputs_[0]; }
   LOperand* right() { return inputs_[1]; }
 
   DECLARE_CONCRETE_INSTRUCTION(SubI, "sub-i")
   DECLARE_HYDROGEN_ACCESSOR(Sub)
-
- protected:
-  ShiftOp shift_;
-  LOperand* shift_amount_;
 };
 
 
 class LRSubI V8_FINAL : public LTemplateInstruction<1, 2, 0> {
  public:
   LRSubI(LOperand* left, LOperand* right) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
@@ skipping 148 matching lines @@
   LOperand* index() { return inputs_[2]; }
   LOperand* value() { return inputs_[3]; }
 
   DECLARE_CONCRETE_INSTRUCTION(SeqStringSetChar, "seq-string-set-char")
   DECLARE_HYDROGEN_ACCESSOR(SeqStringSetChar)
 };
 
 
 class LAddI V8_FINAL : public LTemplateInstruction<1, 2, 0> {
  public:
-  LAddI(LOperand* left, LOperand* right)
-      : shift_(NO_SHIFT), shift_amount_(0)  {
+  LAddI(LOperand* left, LOperand* right) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
-
-  LAddI(LOperand* left, LOperand* right, ShiftOp shift, LOperand* shift_amount)
-      : shift_(shift), shift_amount_(shift_amount)  {
-    inputs_[0] = left;
-    inputs_[1] = right;
-  }
 
   LOperand* left() { return inputs_[0]; }
   LOperand* right() { return inputs_[1]; }
 
-  ShiftOp shift() const { return shift_; }
-  LOperand* shift_amount() const { return shift_amount_; }
-
   DECLARE_CONCRETE_INSTRUCTION(AddI, "add-i")
   DECLARE_HYDROGEN_ACCESSOR(Add)
-
- protected:
-  ShiftOp shift_;
-  LOperand* shift_amount_;
 };
 
 
 class LMathMinMax V8_FINAL : public LTemplateInstruction<1, 2, 0> {
  public:
   LMathMinMax(LOperand* left, LOperand* right) {
     inputs_[0] = left;
     inputs_[1] = right;
   }
 
@@ skipping 1370 matching lines @@
   // instruction.
   LInstruction* MarkAsCall(
       LInstruction* instr,
       HInstruction* hinstr,
       CanDeoptimize can_deoptimize = CANNOT_DEOPTIMIZE_EAGERLY);
 
   void VisitInstruction(HInstruction* current);
   void AddInstruction(LInstruction* instr, HInstruction* current);
 
   void DoBasicBlock(HBasicBlock* block, HBasicBlock* next_block);
-
-  int JSShiftAmountFromHConstant(HValue* constant) {
-    return HConstant::cast(constant)->Integer32Value() & 0x1f;
-  }
-  bool LikelyFitsImmField(HInstruction* instr, int imm) {
-    Instr instr_bits;
-    // All arithmetic and logical operations accept the same range of
-    // immediates. In some cases though, the operation itself can be changed to
-    // get a wider effective range of immediates.
-    if (instr->IsAdd() || instr->IsSub()) {
-      // ADD and SUB can be exchanged with a negate immediate.
-      instr_bits = ADD;
-    } else if (HBitwise::cast(instr)->op() == Token::BIT_AND) {
-      ASSERT(instr->IsBitwise());
-      // AND and BIC can be exchanged with an inverted immediate.
-      instr_bits = AND;
-    } else {
-      ASSERT(instr->IsBitwise());
-      // Use ORR for all other operations, since fits_shifter() can't adapt ORR.
-      instr_bits = ORR;
-    }
-    return fits_shifter(imm, NULL, NULL, &instr_bits);
-  }
-
-  // Indicates if a sequence of the form
-  //   mov r1, r2 LSL #imm
-  //   add r0, r5, r1
-  // can be replaced with:
-  //   add r0, r5, r2 LSL #imm
-  // If this is not possible, the function returns NULL. Otherwise it returns a
-  // pointer to the shift instruction that would be optimized away.
-  HBitwiseBinaryOperation* CanTransformToShiftedOp(HValue* val,
-                                                   HValue** left = NULL);
-  // Checks if all uses of the shift operation can optimize it away.
-  bool ShiftCanBeOptimizedAway(HBitwiseBinaryOperation* shift);
-  // Attempts to merge the binary operation and a previous shift operation into
-  // a single operation. Returns the merged instruction on success, and NULL
-  // otherwise.
-  LInstruction* TryDoOpWithShiftedRightOperand(HBinaryOperation* op);
-  LInstruction* DoShiftedBinaryOp(HBinaryOperation* instr,
-                                  HValue* left,
-                                  HBitwiseBinaryOperation* shift);
-
   LInstruction* DoShift(Token::Value op, HBitwiseBinaryOperation* instr);
   LInstruction* DoArithmeticD(Token::Value op,
                               HArithmeticBinaryOperation* instr);
   LInstruction* DoArithmeticT(Token::Value op,
                               HBinaryOperation* instr);
 
   LPlatformChunk* chunk_;
   CompilationInfo* info_;
   HGraph* const graph_;
   Status status_;
   HInstruction* current_instruction_;
   HBasicBlock* current_block_;
   HBasicBlock* next_block_;
   LAllocator* allocator_;
 
   DISALLOW_COPY_AND_ASSIGN(LChunkBuilder);
 };
 
 #undef DECLARE_HYDROGEN_ACCESSOR
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_ARM_LITHIUM_ARM_H_