A64: Synchronize with r15922.

src/arm/macro-assembler-arm.cc

 // Copyright 2012 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 774 matching lines @@
   if (value.bits == zero.bits) {
     vmov(dst, kDoubleRegZero);
   } else if (value.bits == minus_zero.bits) {
     vneg(dst, kDoubleRegZero);
   } else {
     vmov(dst, imm, scratch);
   }
 }
 
 
+void MacroAssembler::VmovHigh(Register dst, DwVfpRegister src) {
+  if (src.code() < 16) {
+    const LowDwVfpRegister loc = LowDwVfpRegister::from_code(src.code());
+    vmov(dst, loc.high());
+  } else {
+    vmov(dst, VmovIndexHi, src);
+  }
+}
+
+
+void MacroAssembler::VmovHigh(DwVfpRegister dst, Register src) {
+  if (dst.code() < 16) {
+    const LowDwVfpRegister loc = LowDwVfpRegister::from_code(dst.code());
+    vmov(loc.high(), src);
+  } else {
+    vmov(dst, VmovIndexHi, src);
+  }
+}
+
+
+void MacroAssembler::VmovLow(Register dst, DwVfpRegister src) {
+  if (src.code() < 16) {
+    const LowDwVfpRegister loc = LowDwVfpRegister::from_code(src.code());
+    vmov(dst, loc.low());
+  } else {
+    vmov(dst, VmovIndexLo, src);
+  }
+}
+
+
+void MacroAssembler::VmovLow(DwVfpRegister dst, Register src) {
+  if (dst.code() < 16) {
+    const LowDwVfpRegister loc = LowDwVfpRegister::from_code(dst.code());
+    vmov(loc.low(), src);
+  } else {
+    vmov(dst, VmovIndexLo, src);
+  }
+}
+
+
 void MacroAssembler::ConvertNumberToInt32(Register object,
                                           Register dst,
                                           Register heap_number_map,
                                           Register scratch1,
                                           Register scratch2,
                                           Register scratch3,
                                           DwVfpRegister double_scratch1,
-                                          DwVfpRegister double_scratch2,
+                                          LowDwVfpRegister double_scratch2,
                                           Label* not_number) {
   Label done;
   UntagAndJumpIfSmi(dst, object, &done);
   JumpIfNotHeapNumber(object, heap_number_map, scratch1, not_number);
   vldr(double_scratch1, FieldMemOperand(object, HeapNumber::kValueOffset));
   ECMAToInt32(dst, double_scratch1,
               scratch1, scratch2, scratch3, double_scratch2);
 
   bind(&done);
 }
 
 
 void MacroAssembler::LoadNumber(Register object,
-                                DwVfpRegister dst,
+                                LowDwVfpRegister dst,
                                 Register heap_number_map,
                                 Register scratch,
                                 Label* not_number) {
   Label is_smi, done;
 
   UntagAndJumpIfSmi(scratch, object, &is_smi);
   JumpIfNotHeapNumber(object, heap_number_map, scratch, not_number);
 
   vldr(dst, FieldMemOperand(object, HeapNumber::kValueOffset));
   b(&done);
 
   // Handle loading a double from a smi.
   bind(&is_smi);
   vmov(dst.high(), scratch);
   vcvt_f64_s32(dst, dst.high());
 
   bind(&done);
 }
 
 
 void MacroAssembler::LoadNumberAsInt32Double(Register object,
                                              DwVfpRegister double_dst,
                                              Register heap_number_map,
                                              Register scratch,
-                                             DwVfpRegister double_scratch,
+                                             LowDwVfpRegister double_scratch,
                                              Label* not_int32) {
   ASSERT(!scratch.is(object));
   ASSERT(!heap_number_map.is(object) && !heap_number_map.is(scratch));
 
   Label done, obj_is_not_smi;
 
   UntagAndJumpIfNotSmi(scratch, object, &obj_is_not_smi);
   vmov(double_scratch.low(), scratch);
   vcvt_f64_s32(double_dst, double_scratch.low());
   b(&done);
@@ skipping 11 matching lines @@
 
   bind(&done);
 }
 
 
 void MacroAssembler::LoadNumberAsInt32(Register object,
                                        Register dst,
                                        Register heap_number_map,
                                        Register scratch,
                                        DwVfpRegister double_scratch0,
-                                       DwVfpRegister double_scratch1,
+                                       LowDwVfpRegister double_scratch1,
                                        Label* not_int32) {
   ASSERT(!dst.is(object));
   ASSERT(!scratch.is(object));
 
   Label done, maybe_undefined;
 
   UntagAndJumpIfSmi(dst, object, &done);
 
   JumpIfNotHeapNumber(object, heap_number_map, scratch, &maybe_undefined);
 
@@ skipping 734 matching lines @@
   ldr(result, FieldMemOperand(t2, kValueOffset));
 }
 
 
 void MacroAssembler::Allocate(int object_size,
                               Register result,
                               Register scratch1,
                               Register scratch2,
                               Label* gc_required,
                               AllocationFlags flags) {
+  ASSERT(object_size <= Page::kMaxNonCodeHeapObjectSize);
   if (!FLAG_inline_new) {
     if (emit_debug_code()) {
       // Trash the registers to simulate an allocation failure.
       mov(result, Operand(0x7091));
       mov(scratch1, Operand(0x7191));
       mov(scratch2, Operand(0x7291));
     }
     jmp(gc_required);
     return;
   }
@@ skipping 420 matching lines @@
                                           Register scratch,
                                           Label* fail) {
   STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
   STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
   ldrb(scratch, FieldMemOperand(map, Map::kBitField2Offset));
   cmp(scratch, Operand(Map::kMaximumBitField2FastHoleySmiElementValue));
   b(hi, fail);
 }
 
 
-void MacroAssembler::StoreNumberToDoubleElements(Register value_reg,
-                                                 Register key_reg,
-                                                 Register elements_reg,
-                                                 Register scratch1,
-                                                 Label* fail,
-                                                 int elements_offset) {
+void MacroAssembler::StoreNumberToDoubleElements(
+                                      Register value_reg,
+                                      Register key_reg,
+                                      Register elements_reg,
+                                      Register scratch1,
+                                      LowDwVfpRegister double_scratch,
+                                      Label* fail,
+                                      int elements_offset) {
   Label smi_value, store;
 
   // Handle smi values specially.
   JumpIfSmi(value_reg, &smi_value);
 
   // Ensure that the object is a heap number
   CheckMap(value_reg,
            scratch1,
            isolate()->factory()->heap_number_map(),
            fail,
            DONT_DO_SMI_CHECK);
 
-  vldr(d0, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
+  vldr(double_scratch, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
   // Force a canonical NaN.
   if (emit_debug_code()) {
     vmrs(ip);
     tst(ip, Operand(kVFPDefaultNaNModeControlBit));
     Assert(ne, "Default NaN mode not set");
   }
-  VFPCanonicalizeNaN(d0);
+  VFPCanonicalizeNaN(double_scratch);
   b(&store);
 
   bind(&smi_value);
-  SmiToDouble(d0, value_reg);
+  SmiToDouble(double_scratch, value_reg);
 
   bind(&store);
   add(scratch1, elements_reg, Operand::DoubleOffsetFromSmiKey(key_reg));
-  vstr(d0, FieldMemOperand(scratch1,
-                           FixedDoubleArray::kHeaderSize - elements_offset));
+  vstr(double_scratch,
+       FieldMemOperand(scratch1,
+                       FixedDoubleArray::kHeaderSize - elements_offset));
 }
 
 
 void MacroAssembler::CompareMap(Register obj,
                                 Register scratch,
                                 Handle<Map> map,
                                 Label* early_success) {
   ldr(scratch, FieldMemOperand(obj, HeapObject::kMapOffset));
   CompareMap(scratch, map, early_success);
 }
@@ skipping 285 matching lines @@
   // conflict.
   ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) <
          (1 << String::kArrayIndexValueBits));
   // We want the smi-tagged index in key.  kArrayIndexValueMask has zeros in
   // the low kHashShift bits.
   Ubfx(hash, hash, String::kHashShift, String::kArrayIndexValueBits);
   SmiTag(index, hash);
 }
 
 
-void MacroAssembler::SmiToDouble(DwVfpRegister value, Register smi) {
-  ASSERT(value.code() < 16);
+void MacroAssembler::SmiToDouble(LowDwVfpRegister value, Register smi) {
   if (CpuFeatures::IsSupported(VFP3)) {
     vmov(value.low(), smi);
     vcvt_f64_s32(value, 1);
   } else {
     SmiUntag(ip, smi);
     vmov(value.low(), ip);
     vcvt_f64_s32(value, value.low());
   }
 }
 
 
 void MacroAssembler::TestDoubleIsInt32(DwVfpRegister double_input,
-                                       DwVfpRegister double_scratch) {
+                                       LowDwVfpRegister double_scratch) {
   ASSERT(!double_input.is(double_scratch));
   vcvt_s32_f64(double_scratch.low(), double_input);
   vcvt_f64_s32(double_scratch, double_scratch.low());
   VFPCompareAndSetFlags(double_input, double_scratch);
 }
 
 
 void MacroAssembler::TryDoubleToInt32Exact(Register result,
                                            DwVfpRegister double_input,
-                                           DwVfpRegister double_scratch) {
+                                           LowDwVfpRegister double_scratch) {
   ASSERT(!double_input.is(double_scratch));
   vcvt_s32_f64(double_scratch.low(), double_input);
   vmov(result, double_scratch.low());
   vcvt_f64_s32(double_scratch, double_scratch.low());
   VFPCompareAndSetFlags(double_input, double_scratch);
 }
 
 
 void MacroAssembler::TryInt32Floor(Register result,
                                    DwVfpRegister double_input,
                                    Register input_high,
-                                   DwVfpRegister double_scratch,
+                                   LowDwVfpRegister double_scratch,
                                    Label* done,
                                    Label* exact) {
   ASSERT(!result.is(input_high));
   ASSERT(!double_input.is(double_scratch));
   Label negative, exception;
 
+  VmovHigh(input_high, double_input);
+
   // Test for NaN and infinities.
   Sbfx(result, input_high,
        HeapNumber::kExponentShift, HeapNumber::kExponentBits);
   cmp(result, Operand(-1));
   b(eq, &exception);
   // Test for values that can be exactly represented as a
   // signed 32-bit integer.
   TryDoubleToInt32Exact(result, double_input, double_scratch);
   // If exact, return (result already fetched).
   b(eq, exact);
@@ skipping 20 matching lines @@
   b(mi, done);
   bind(&exception);
 }
 
 
 void MacroAssembler::ECMAToInt32(Register result,
                                  DwVfpRegister double_input,
                                  Register scratch,
                                  Register scratch_high,
                                  Register scratch_low,
-                                 DwVfpRegister double_scratch) {
+                                 LowDwVfpRegister double_scratch) {
   ASSERT(!scratch_high.is(result));
   ASSERT(!scratch_low.is(result));
   ASSERT(!scratch_low.is(scratch_high));
   ASSERT(!scratch.is(result) &&
          !scratch.is(scratch_high) &&
          !scratch.is(scratch_low));
   ASSERT(!double_input.is(double_scratch));
 
   Label out_of_range, only_low, negate, done;
 
@@ skipping 633 matching lines @@
                                                  Label* gc_required) {
   AllocateHeapNumber(result, scratch1, scratch2, heap_number_map, gc_required);
   sub(scratch1, result, Operand(kHeapObjectTag));
   vstr(value, scratch1, HeapNumber::kValueOffset);
 }
 
 
 // Copies a fixed number of fields of heap objects from src to dst.
 void MacroAssembler::CopyFields(Register dst,
                                 Register src,
-                                DwVfpRegister double_scratch,
-                                SwVfpRegister single_scratch,
+                                LowDwVfpRegister double_scratch,
                                 int field_count) {
   int double_count = field_count / (DwVfpRegister::kSizeInBytes / kPointerSize);
   for (int i = 0; i < double_count; i++) {
     vldr(double_scratch, FieldMemOperand(src, i * DwVfpRegister::kSizeInBytes));
     vstr(double_scratch, FieldMemOperand(dst, i * DwVfpRegister::kSizeInBytes));
   }
 
   STATIC_ASSERT(SwVfpRegister::kSizeInBytes == kPointerSize);
   STATIC_ASSERT(2 * SwVfpRegister::kSizeInBytes == DwVfpRegister::kSizeInBytes);
 
   int remain = field_count % (DwVfpRegister::kSizeInBytes / kPointerSize);
   if (remain != 0) {
-    vldr(single_scratch,
+    vldr(double_scratch.low(),
          FieldMemOperand(src, (field_count - 1) * kPointerSize));
-    vstr(single_scratch,
+    vstr(double_scratch.low(),
          FieldMemOperand(dst, (field_count - 1) * kPointerSize));
   }
 }
 
 
 void MacroAssembler::CopyBytes(Register src,
                                Register dst,
                                Register length,
                                Register scratch) {
   Label align_loop, align_loop_1, word_loop, byte_loop, byte_loop_1, done;
@@ skipping 480 matching lines @@
 }
 
 
 void MacroAssembler::ClampUint8(Register output_reg, Register input_reg) {
   Usat(output_reg, 8, Operand(input_reg));
 }
 
 
 void MacroAssembler::ClampDoubleToUint8(Register result_reg,
                                         DwVfpRegister input_reg,
-                                        DwVfpRegister temp_double_reg) {
+                                        LowDwVfpRegister double_scratch) {
   Label above_zero;
   Label done;
   Label in_bounds;
 
-  Vmov(temp_double_reg, 0.0);
-  VFPCompareAndSetFlags(input_reg, temp_double_reg);
+  VFPCompareAndSetFlags(input_reg, 0.0);
   b(gt, &above_zero);
 
   // Double value is less than zero, NaN or Inf, return 0.
   mov(result_reg, Operand::Zero());
   b(al, &done);
 
   // Double value is >= 255, return 255.
   bind(&above_zero);
-  Vmov(temp_double_reg, 255.0, result_reg);
-  VFPCompareAndSetFlags(input_reg, temp_double_reg);
+  Vmov(double_scratch, 255.0, result_reg);
+  VFPCompareAndSetFlags(input_reg, double_scratch);
   b(le, &in_bounds);
   mov(result_reg, Operand(255));
   b(al, &done);
 
   // In 0-255 range, round and truncate.
   bind(&in_bounds);
   // Save FPSCR.
   vmrs(ip);
   // Set rounding mode to round to the nearest integer by clearing bits[23:22].
   bic(result_reg, ip, Operand(kVFPRoundingModeMask));
   vmsr(result_reg);
-  vcvt_s32_f64(input_reg.low(), input_reg, kFPSCRRounding);
-  vmov(result_reg, input_reg.low());
+  vcvt_s32_f64(double_scratch.low(), input_reg, kFPSCRRounding);
+  vmov(result_reg, double_scratch.low());
   // Restore FPSCR.
   vmsr(ip);
   bind(&done);
 }
 
 
 void MacroAssembler::LoadInstanceDescriptors(Register map,
                                              Register descriptors) {
   ldr(descriptors, FieldMemOperand(map, Map::kDescriptorsOffset));
 }
@@ skipping 131 matching lines @@
 void CodePatcher::EmitCondition(Condition cond) {
   Instr instr = Assembler::instr_at(masm_.pc_);
   instr = (instr & ~kCondMask) | cond;
   masm_.emit(instr);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM