ARM64: Use the shifter operand to merge in previous shift instructions.

src/arm64/lithium-codegen-arm64.cc

 // Copyright 2013 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 "v8.h"
 
 #include "arm64/lithium-codegen-arm64.h"
 #include "arm64/lithium-gap-resolver-arm64.h"
 #include "code-stubs.h"
 #include "stub-cache.h"
@@ skipping 1237 matching lines @@
 }
 
 
 Handle<Object> LCodeGen::ToHandle(LConstantOperand* op) const {
   HConstant* constant = chunk_->LookupConstant(op);
   ASSERT(chunk_->LookupLiteralRepresentation(op).IsSmiOrTagged());
   return constant->handle(isolate());
 }
 
 
+Operand LCodeGen::ToShiftedRightOperand32(
+    LOperand* right, LShiftedRightOpInterface* shift_info,
+    IntegerSignedness signedness) {
+  if (shift_info->shift() == NO_SHIFT) {
+    return (signedness == SIGNED_INT32) ? ToOperand32I(right)
+                                        : ToOperand32U(right);
+  } else {
+    return Operand(
+        ToRegister32(right),
+        shift_info->shift(),
+        ToInteger32(LConstantOperand::cast(shift_info->shift_amount())) & 0x1f);

[ulan, 2014/05/02 10:01:18]

Could you name the 0x1f constant since it is used in other places too?

[Alexandre Rames, 2014/05/02 13:51:44]

Abstracted the constant and used a helper.

+  }
+}

[ulan, 2014/05/02 10:01:18]

Two empty lines after function.

[Alexandre Rames, 2014/05/02 13:51:44]

Done.

 bool LCodeGen::IsSmi(LConstantOperand* op) const {
   return chunk_->LookupLiteralRepresentation(op).IsSmi();
 }
 
 
 bool LCodeGen::IsInteger32Constant(LConstantOperand* op) const {
   return chunk_->LookupLiteralRepresentation(op).IsSmiOrInteger32();
 }
 
 
@@ skipping 176 matching lines @@
 
   ASSERT(!instr->hydrogen()->CheckFlag(HValue::kCanOverflow));
   __ Add(result, left, right);
 }
 
 
 void LCodeGen::DoAddI(LAddI* instr) {
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
-  Operand right = ToOperand32I(instr->right());
+  Operand right = ToShiftedRightOperand32I(instr->right(), instr);
+
   if (can_overflow) {
     __ Adds(result, left, right);
     DeoptimizeIf(vs, instr->environment());
   } else {
     __ Add(result, left, right);
   }
 }
 
 
 void LCodeGen::DoAddS(LAddS* instr) {
@@ skipping 253 matching lines @@
   ASSERT(ToRegister(instr->result()).is(x0));
 
   BinaryOpICStub stub(isolate(), instr->op(), NO_OVERWRITE);
   CallCode(stub.GetCode(), RelocInfo::CODE_TARGET, instr);
 }
 
 
 void LCodeGen::DoBitI(LBitI* instr) {
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
-  Operand right = ToOperand32U(instr->right());
+  Operand right = ToShiftedRightOperand32U(instr->right(), instr);
 
   switch (instr->op()) {
     case Token::BIT_AND: __ And(result, left, right); break;
     case Token::BIT_OR:  __ Orr(result, left, right); break;
     case Token::BIT_XOR: __ Eor(result, left, right); break;
     default:
       UNREACHABLE();
       break;
   }
 }
@@ skipping 3665 matching lines @@
   Condition condition = TokenToCondition(op, false);
 
   EmitCompareAndBranch(instr, condition, x0, 0);
 }
 
 
 void LCodeGen::DoSubI(LSubI* instr) {
   bool can_overflow = instr->hydrogen()->CheckFlag(HValue::kCanOverflow);
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
-  Operand right = ToOperand32I(instr->right());
+  Operand right = ToShiftedRightOperand32I(instr->right(), instr);
+
   if (can_overflow) {
     __ Subs(result, left, right);
     DeoptimizeIf(vs, instr->environment());
   } else {
     __ Sub(result, left, right);
   }
 }
 
 
 void LCodeGen::DoSubS(LSubS* instr) {
@@ skipping 451 matching lines @@
   __ Ldr(result, FieldMemOperand(object, JSObject::kPropertiesOffset));
   // Index is equal to negated out of object property index plus 1.
   __ Sub(result, result, Operand::UntagSmiAndScale(index, kPointerSizeLog2));
   __ Ldr(result, FieldMemOperand(result,
                                  FixedArray::kHeaderSize - kPointerSize));
   __ Bind(deferred->exit());
   __ Bind(&done);
 }
 
 } }  // namespace v8::internal