A64: Do not sign-extend constant operand of bitwise operation.

src/a64/lithium-codegen-a64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1069 matching lines @@
   } else if (op->IsDoubleRegister()) {
     Abort("ToOperand IsDoubleRegister unimplemented");
     return Operand(0);
   }
   // Stack slots not implemented, use ToMemOperand instead.
   UNREACHABLE();
   return Operand(0);
 }
 
 
-Operand LCodeGen::ToOperand32(LOperand* op) {
+Operand LCodeGen::ToOperand32I(LOperand* op) {
+  return ToOperand32(op, SIGNED_INT32);
+}
+
+
+Operand LCodeGen::ToOperand32U(LOperand* op) {
+  return ToOperand32(op, UNSIGNED_INT32);
+}
+
+
+Operand LCodeGen::ToOperand32(LOperand* op, IntegerSignedness signedness) {
   ASSERT(op != NULL);
   if (op->IsRegister()) {
     return Operand(ToRegister32(op));
   } else if (op->IsConstantOperand()) {
     LConstantOperand* const_op = LConstantOperand::cast(op);
     HConstant* constant = chunk()->LookupConstant(const_op);
     Representation r = chunk_->LookupLiteralRepresentation(const_op);
     if (r.IsInteger32()) {
       ASSERT(constant->HasInteger32Value());
-      return Operand(constant->Integer32Value());
+      return Operand(signedness == SIGNED_INT32
+                     ? constant->Integer32Value()
+                     : static_cast<uint32_t>(constant->Integer32Value()));
     } else {
       // Other constants not implemented.
       Abort("ToOperand32 unsupported immediate.");
     }
   }
   // Other cases are not implemented.
   UNREACHABLE();
   return Operand(0);
 }
 
@@ skipping 155 matching lines @@
       instr->index()->IsConstantOperand()) {
     ASSERT(instr->temp() == NULL);
     int index = ToInteger32(LConstantOperand::cast(instr->index()));
     int length = ToInteger32(LConstantOperand::cast(instr->length()));
     int offset = ((length - index) + 1) * kPointerSize;
     __ Ldr(result, MemOperand(arguments, offset));
   } else {
     ASSERT(instr->temp() != NULL);
     Register temp = ToRegister32(instr->temp());
     Register length = ToRegister32(instr->length());
-    Operand index = ToOperand32(instr->index());
+    Operand index = ToOperand32I(instr->index());
     // There are two words between the frame pointer and the last arguments.
     // Subtracting from length accounts for only one, so we add one more.
     __ Sub(temp, length, index);
     __ Add(temp, temp, 1);
     __ Ldr(result, MemOperand(arguments, temp, UXTW, kPointerSizeLog2));
   }
 }
 
 
 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 = ToOperand32(instr->right());
+  Operand right = ToOperand32I(instr->right());
   if (can_overflow) {
     __ Adds(result, left, right);
     DeoptimizeIf(vs, instr->environment());
   } else {
     __ Add(result, left, right);
   }
 }
 
 
 void LCodeGen::DoAddS(LAddS* instr) {
@@ skipping 244 matching lines @@
   ASSERT(ToRegister(instr->result()).is(x0));
 
   BinaryOpStub stub(instr->op(), NO_OVERWRITE);
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
 }
 
 
 void LCodeGen::DoBitI(LBitI* instr) {
   Register result = ToRegister32(instr->result());
   Register left = ToRegister32(instr->left());
-  Operand right = ToOperand32(instr->right());
+  Operand right = ToOperand32U(instr->right());
 
   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 634 matching lines @@
       // If a NaN is involved, i.e. the result is unordered (V set),
       // jump to false block label.
       __ B(vs, instr->FalseLabel(chunk_));
       EmitBranch(instr, cond);
     } else {
       if (instr->hydrogen_value()->representation().IsInteger32()) {
         if (right->IsConstantOperand()) {
           EmitCompareAndBranch(instr,
                                cond,
                                ToRegister32(left),
-                               ToOperand32(right));
+                               ToOperand32I(right));
         } else {
           // Transpose the operands and reverse the condition.
           EmitCompareAndBranch(instr,
                                ReverseConditionForCmp(cond),
                                ToRegister32(right),
-                               ToOperand32(left));
+                               ToOperand32I(left));
         }
       } else {
         ASSERT(instr->hydrogen_value()->representation().IsSmi());
         if (right->IsConstantOperand()) {
           int32_t value = ToInteger32(LConstantOperand::cast(right));
           EmitCompareAndBranch(instr,
                                cond,
                                ToRegister(left),
                                Operand(Smi::FromInt(value)));
         } else if (left->IsConstantOperand()) {
@@ skipping 1774 matching lines @@
   CallCode(stub.GetCode(isolate()), RelocInfo::CODE_TARGET, instr);
   ASSERT(ToDoubleRegister(instr->result()).Is(d0));
 }
 
 
 void LCodeGen::DoMathMinMax(LMathMinMax* instr) {
   HMathMinMax::Operation op = instr->hydrogen()->operation();
   if (instr->hydrogen()->representation().IsInteger32()) {
     Register result = ToRegister32(instr->result());
     Register left = ToRegister32(instr->left());
-    Operand right = ToOperand32(instr->right());
+    Operand right = ToOperand32I(instr->right());
 
     __ Cmp(left, right);
     __ Csel(result, left, right, (op == HMathMinMax::kMathMax) ? ge : le);
   } else if (instr->hydrogen()->representation().IsSmi()) {
     Register result = ToRegister(instr->result());
     Register left = ToRegister(instr->left());
     Operand right = ToOperand(instr->right());
 
     __ Cmp(left, right);
     __ Csel(result, left, right, (op == HMathMinMax::kMathMax) ? ge : le);
@@ skipping 1152 matching lines @@
   Register string = ToRegister(instr->string());
   Register result = ToRegister(instr->result());
   __ Ldr(result, FieldMemOperand(string, String::kLengthOffset));
 }
 
 
 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 = ToOperand32(instr->right());
+  Operand right = ToOperand32I(instr->right());
   if (can_overflow) {
     __ Subs(result, left, right);
     DeoptimizeIf(vs, instr->environment());
   } else {
     __ Sub(result, left, right);
   }
 }
 
 
 void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr,
@@ skipping 411 matching lines @@
   __ Bind(&out_of_object);
   __ 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(&done);
 }
 
 } }  // namespace v8::internal