A64: Fix some int32 accesses in lithium

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 1551 matching lines @@
 
   CallRuntimeFromDeferred(
       Runtime::kAllocateInTargetSpace, 2, instr, instr->context());
   __ StoreToSafepointRegisterSlot(x0, ToRegister(instr->result()));
 }
 
 
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   Register receiver = ToRegister(instr->receiver());
   Register function = ToRegister(instr->function());
-  Register length = ToRegister(instr->length());
+  Register length = ToRegister32(instr->length());
+
   Register elements = ToRegister(instr->elements());
   Register scratch = x5;
   ASSERT(receiver.Is(x0));  // Used for parameter count.
   ASSERT(function.Is(x1));  // Required by InvokeFunction.
   ASSERT(ToRegister(instr->result()).Is(x0));
   ASSERT(instr->IsMarkedAsCall());
 
   // Copy the arguments to this function possibly from the
   // adaptor frame below it.
   const uint32_t kArgumentsLimit = 1 * KB;
   __ Cmp(length, kArgumentsLimit);
   DeoptimizeIf(hi, instr->environment());
 
   // Push the receiver and use the register to keep the original
   // number of arguments.
   __ Push(receiver);
   Register argc = receiver;
   receiver = NoReg;
-  __ Mov(argc, length);
+  __ Sxtw(argc, length);
   // The arguments are at a one pointer size offset from elements.
   __ Add(elements, elements, 1 * kPointerSize);
 
   // Loop through the arguments pushing them onto the execution
   // stack.
   Label invoke, loop;
   // length is a small non-negative integer, due to the test above.
   __ Cbz(length, &invoke);
   __ Bind(&loop);
-  __ Ldr(scratch, MemOperand(elements, length, LSL, kPointerSizeLog2));
+  __ Ldr(scratch, MemOperand(elements, length, SXTW, kPointerSizeLog2));
   __ Push(scratch);
   __ Subs(length, length, 1);
   __ B(ne, &loop);
 
   __ Bind(&invoke);
   ASSERT(instr->HasPointerMap());
   LPointerMap* pointers = instr->pointer_map();
   SafepointGenerator safepoint_generator(this, pointers, Safepoint::kLazyDeopt);
   // The number of arguments is stored in argc (receiver) which is x0, as
   // expected by InvokeFunction.
@@ skipping 134 matching lines @@
     __ Assert(InvertCondition(cc), kEliminatedBoundsCheckFailed);
   } else {
     DeoptimizeIf(cc, check->environment());
   }
 }
 
 
 void LCodeGen::DoBoundsCheck(LBoundsCheck *instr) {
   if (instr->hydrogen()->skip_check()) return;
 
-  Register length = ToRegister(instr->length());
+  ASSERT(instr->hydrogen()->length()->representation().IsInteger32());
+  Register length = ToRegister32(instr->length());
 
   if (instr->index()->IsConstantOperand()) {
     int constant_index =
         ToInteger32(LConstantOperand::cast(instr->index()));
 
     if (instr->hydrogen()->length()->representation().IsSmi()) {
       __ Cmp(length, Operand(Smi::FromInt(constant_index)));
     } else {
       __ Cmp(length, Operand(constant_index));
     }
   } else {
-    __ Cmp(length, ToRegister(instr->index()));
+  ASSERT(instr->hydrogen()->index()->representation().IsInteger32());
+    __ Cmp(length, ToRegister32(instr->index()));
   }
   Condition condition = instr->hydrogen()->allow_equality() ? lo : ls;
   ApplyCheckIf(condition, instr);
 }
 
 
 void LCodeGen::DoBranch(LBranch* instr) {
   Representation r = instr->hydrogen()->value()->representation();
   Label* true_label = instr->TrueLabel(chunk_);
   Label* false_label = instr->FalseLabel(chunk_);
@@ skipping 400 matching lines @@
         __ Cmp(scratch, tag);
       }
       DeoptimizeIf(ne, instr->environment());
     }
   }
 }
 
 
 void LCodeGen::DoClampDToUint8(LClampDToUint8* instr) {
   DoubleRegister input = ToDoubleRegister(instr->unclamped());
-  Register result = ToRegister(instr->result());
+  Register result = ToRegister32(instr->result());
   __ ClampDoubleToUint8(result, input, double_scratch());
 }
 
 
 void LCodeGen::DoClampIToUint8(LClampIToUint8* instr) {
   Register input = ToRegister32(instr->unclamped());
   Register result = ToRegister32(instr->result());
   __ ClampInt32ToUint8(result, input);
 }
 
 
 void LCodeGen::DoClampTToUint8(LClampTToUint8* instr) {
   Register input = ToRegister(instr->unclamped());
-  Register result = ToRegister(instr->result());
+  Register result = ToRegister32(instr->result());
   Register scratch = ToRegister(instr->temp1());
   Label done;
 
   // Both smi and heap number cases are handled.
   Label is_not_smi;
   __ JumpIfNotSmi(input, &is_not_smi);
-  __ SmiUntag(result, input);
+  __ SmiUntag(result.X(), input);
   __ ClampInt32ToUint8(result);
   __ B(&done);
 
   __ Bind(&is_not_smi);
 
   // Check for heap number.
   Label is_heap_number;
   __ Ldr(scratch, FieldMemOperand(input, HeapObject::kMapOffset));
   __ JumpIfRoot(scratch, Heap::kHeapNumberMapRootIndex, &is_heap_number);
 
@@ skipping 232 matching lines @@
   __ Fmov(result, instr->value());
 }
 
 
 void LCodeGen::DoConstantE(LConstantE* instr) {
   __ Mov(ToRegister(instr->result()), Operand(instr->value()));
 }
 
 
 void LCodeGen::DoConstantI(LConstantI* instr) {
-  __ Mov(ToRegister(instr->result()), instr->value());
+  ASSERT(is_int32(instr->value()));
+  // Cast the value here to ensure that the value isn't sign extended by the
+  // implicit Operand constructor.
+  __ Mov(ToRegister32(instr->result()), static_cast<uint32_t>(instr->value()));
 }
 
 
 void LCodeGen::DoConstantS(LConstantS* instr) {
   __ Mov(ToRegister(instr->result()), Operand(instr->value()));
 }
 
 
 void LCodeGen::DoConstantT(LConstantT* instr) {
   Handle<Object> value = instr->value(isolate());
@@ skipping 430 matching lines @@
     __ JumpIfSmi(input, instr->FalseLabel(chunk_));
   }
   __ CompareObjectType(input, scratch, scratch, TestType(instr->hydrogen()));
   EmitBranch(instr, BranchCondition(instr->hydrogen()));
 }
 
 
 void LCodeGen::DoInnerAllocatedObject(LInnerAllocatedObject* instr) {
   Register result = ToRegister(instr->result());
   Register base = ToRegister(instr->base_object());
-  __ Add(result, base, ToOperand(instr->offset()));
+  if (instr->offset()->IsConstantOperand()) {
+    __ Add(result, base, ToOperand32I(instr->offset()));
+  } else {
+    __ Add(result, base, Operand(ToRegister32(instr->offset()), SXTW));
+  }
 }
 
 
 void LCodeGen::DoInstanceOf(LInstanceOf* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
   // Assert that the arguments are in the registers expected by InstanceofStub.
   ASSERT(ToRegister(instr->left()).Is(InstanceofStub::left()));
   ASSERT(ToRegister(instr->right()).Is(InstanceofStub::right()));
 
   InstanceofStub stub(InstanceofStub::kArgsInRegisters);
@@ skipping 134 matching lines @@
   DoubleRegister result = ToDoubleRegister(instr->result());
   __ Scvtf(result, value);
 }
 
 
 void LCodeGen::DoInteger32ToSmi(LInteger32ToSmi* instr) {
   // A64 smis can represent all Integer32 values, so this cannot deoptimize.
   ASSERT(!instr->hydrogen()->value()->HasRange() ||
          instr->hydrogen()->value()->range()->IsInSmiRange());
 
-  Register value = ToRegister(instr->value());
+  Register value = ToRegister32(instr->value());
   Register result = ToRegister(instr->result());
-  __ SmiTag(result, value);
+  __ SmiTag(result, value.X());
 }
 
 
 void LCodeGen::DoInvokeFunction(LInvokeFunction* instr) {
   ASSERT(ToRegister(instr->context()).is(cp));
   // The function is required to be in x1.
   ASSERT(ToRegister(instr->function()).is(x1));
   ASSERT(instr->HasPointerMap());
 
   Handle<JSFunction> known_function = instr->hydrogen()->known_function();
@@ skipping 234 matching lines @@
   }
 
   if (additional_index == 0) {
     if (key_is_smi) {
       // Key is smi: untag, and scale by element size.
       __ Add(scratch, base, Operand::UntagSmiAndScale(key, element_size_shift));
       return MemOperand(scratch, additional_offset);
     } else {
       // Key is not smi, and element size is not byte: scale by element size.
       if (additional_offset == 0) {
-        return MemOperand(base, key, LSL, element_size_shift);
+        return MemOperand(base, key, SXTW, element_size_shift);
       } else {
-        __ Add(scratch, base, Operand(key, LSL, element_size_shift));
+        __ Add(scratch, base, Operand(key, SXTW, element_size_shift));
         return MemOperand(scratch, additional_offset);
       }
     }
   } else {
     // TODO(all): Try to combine these cases a bit more intelligently.
     if (additional_offset == 0) {
       if (key_is_smi) {
         __ SmiUntag(scratch, key);
-        __ Add(scratch, scratch, additional_index);
+        __ Add(scratch.W(), scratch.W(), additional_index);
       } else {
-        __ Add(scratch, key, additional_index);
+        __ Add(scratch.W(), key.W(), additional_index);
       }
       return MemOperand(base, scratch, LSL, element_size_shift);
     } else {
       if (key_is_smi) {
         __ Add(scratch, base,
                Operand::UntagSmiAndScale(key, element_size_shift));
       } else {
-        __ Add(scratch, base, Operand(key, LSL, element_size_shift));
+        __ Add(scratch, base, Operand(key, SXTW, element_size_shift));
       }
       return MemOperand(
           scratch,
           (additional_index << element_size_shift) + additional_offset);
     }
   }
 }
 
 
 void LCodeGen::DoLoadKeyedExternal(LLoadKeyedExternal* instr) {
@@ skipping 92 matching lines @@
                                           ElementsKind elements_kind) {
   int element_size_shift = ElementsKindToShiftSize(elements_kind);
 
   // Even though the HLoad/StoreKeyed instructions force the input
   // representation for the key to be an integer, the input gets replaced during
   // bounds check elimination with the index argument to the bounds check, which
   // can be tagged, so that case must be handled here, too.
   if (key_is_tagged) {
     __ Add(base, elements, Operand::UntagSmiAndScale(key, element_size_shift));
   } else {
-    // Sign extend key because it could be a 32-bit negative value and the
-    // address computation happens in 64-bit.
+    // Sign extend key because it could be a 32-bit negative value or contain
+    // garbage in the top 32-bits. The address computation happens in 64-bit.
     ASSERT((element_size_shift >= 0) && (element_size_shift <= 4));
     __ Add(base, elements, Operand(key, SXTW, element_size_shift));
   }
 }
 
 
 void LCodeGen::DoLoadKeyedFixedDouble(LLoadKeyedFixedDouble* instr) {
   Register elements = ToRegister(instr->elements());
   DoubleRegister result = ToDoubleRegister(instr->result());
   Register load_base;
@@ skipping 439 matching lines @@
   } else if (exponent_type.IsTagged()) {
     Label no_deopt;
     __ JumpIfSmi(x11, &no_deopt);
     __ Ldr(x0, FieldMemOperand(x11, HeapObject::kMapOffset));
     DeoptimizeIfNotRoot(x0, Heap::kHeapNumberMapRootIndex,
                         instr->environment());
     __ Bind(&no_deopt);
     MathPowStub stub(MathPowStub::TAGGED);
     __ CallStub(&stub);
   } else if (exponent_type.IsInteger32()) {
+    // Ensure integer exponent has no garbage in top 32-bits, as MathPowStub
+    // supports large integer exponents.
+    Register exponent = ToRegister(instr->right());
+    __ Sxtw(exponent, exponent);
     MathPowStub stub(MathPowStub::INTEGER);
     __ CallStub(&stub);
   } else {
     ASSERT(exponent_type.IsDouble());
     MathPowStub stub(MathPowStub::DOUBLE);
     __ CallStub(&stub);
   }
 }
 
 
@@ skipping 418 matching lines @@
       codegen()->DoDeferredNumberTagU(instr_,
                                       instr_->value(),
                                       instr_->temp1(),
                                       instr_->temp2());
     }
     virtual LInstruction* instr() { return instr_; }
    private:
     LNumberTagU* instr_;
   };
 
-  Register value = ToRegister(instr->value());
+  Register value = ToRegister32(instr->value());
   Register result = ToRegister(instr->result());
 
   DeferredNumberTagU* deferred = new(zone()) DeferredNumberTagU(this, instr);
   __ Cmp(value, Smi::kMaxValue);
   __ B(hi, deferred->entry());
-  __ SmiTag(result, value);
+  __ SmiTag(result, value.X());
   __ Bind(deferred->exit());
 }
 
 
 void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) {
   Register input = ToRegister(instr->value());
   Register scratch = ToRegister(instr->temp());
   DoubleRegister result = ToDoubleRegister(instr->result());
   bool can_convert_undefined_to_nan =
       instr->hydrogen()->can_convert_undefined_to_nan();
@@ skipping 123 matching lines @@
     int offset = ToInteger32(LConstantOperand::cast(index));
     if (encoding == String::TWO_BYTE_ENCODING) {
       offset *= kUC16Size;
     }
     STATIC_ASSERT(kCharSize == 1);
     return FieldMemOperand(string, SeqString::kHeaderSize + offset);
   }
   ASSERT(!temp.is(string));
   ASSERT(!temp.is(ToRegister(index)));
   if (encoding == String::ONE_BYTE_ENCODING) {
-    __ Add(temp, string, Operand(ToRegister(index)));
+    __ Add(temp, string, Operand(ToRegister32(index), SXTW));
   } else {
     STATIC_ASSERT(kUC16Size == 2);
-    __ Add(temp, string, Operand(ToRegister(index), LSL, 1));
+    __ Add(temp, string, Operand(ToRegister32(index), SXTW, 1));
   }
   return FieldMemOperand(temp, SeqString::kHeaderSize);
 }
 
 
 void LCodeGen::DoSeqStringGetChar(LSeqStringGetChar* instr) {
   String::Encoding encoding = instr->hydrogen()->encoding();
   Register string = ToRegister(instr->string());
   Register result = ToRegister(instr->result());
   Register temp = ToRegister(instr->temp());
@@ skipping 1178 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