[x64] Use vmovapd and vmovsd when AVX is enabled.

src/x64/codegen-x64.cc

 // 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.
 
 #include "src/x64/codegen-x64.h"
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/codegen.h"
 #include "src/macro-assembler.h"
@@ skipping 33 matching lines @@
   // xmm0: raw double input.
   XMMRegister input = xmm0;
   XMMRegister result = xmm1;
   __ pushq(rax);
   __ pushq(rbx);
 
   MathExpGenerator::EmitMathExp(&masm, input, result, xmm2, rax, rbx);
 
   __ popq(rbx);
   __ popq(rax);
-  __ movsd(xmm0, result);
+  __ Movsd(xmm0, result);
   __ Ret();
 
   CodeDesc desc;
   masm.GetCode(&desc);
   DCHECK(!RelocInfo::RequiresRelocation(desc));
 
   Assembler::FlushICacheWithoutIsolate(buffer, actual_size);
   base::OS::ProtectCode(buffer, actual_size);
   return FUNCTION_CAST<UnaryMathFunction>(buffer);
 }
@@ skipping 23 matching lines @@
 
 
 #ifdef _WIN64
 typedef double (*ModuloFunction)(double, double);
 // Define custom fmod implementation.
 ModuloFunction CreateModuloFunction() {
   size_t actual_size;
   byte* buffer = static_cast<byte*>(
       base::OS::Allocate(Assembler::kMinimalBufferSize, &actual_size, true));
   CHECK(buffer);
-  Assembler masm(NULL, buffer, static_cast<int>(actual_size));
+  MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
   // Generated code is put into a fixed, unmovable, buffer, and not into
   // the V8 heap. We can't, and don't, refer to any relocatable addresses
   // (e.g. the JavaScript nan-object).
 
   // Windows 64 ABI passes double arguments in xmm0, xmm1 and
   // returns result in xmm0.
   // Argument backing space is allocated on the stack above
   // the return address.
 
   // Compute x mod y.
   // Load y and x (use argument backing store as temporary storage).
-  __ movsd(Operand(rsp, kRegisterSize * 2), xmm1);
-  __ movsd(Operand(rsp, kRegisterSize), xmm0);
+  __ Movsd(Operand(rsp, kRegisterSize * 2), xmm1);
+  __ Movsd(Operand(rsp, kRegisterSize), xmm0);
   __ fld_d(Operand(rsp, kRegisterSize * 2));
   __ fld_d(Operand(rsp, kRegisterSize));
 
   // Clear exception flags before operation.
   {
     Label no_exceptions;
     __ fwait();
     __ fnstsw_ax();
     // Clear if Illegal Operand or Zero Division exceptions are set.
     __ testb(rax, Immediate(5));
@@ skipping 18 matching lines @@
   Label valid_result;
   Label return_result;
   // If Invalid Operand or Zero Division exceptions are set,
   // return NaN.
   __ testb(rax, Immediate(5));
   __ j(zero, &valid_result);
   __ fstp(0);  // Drop result in st(0).
   int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000);
   __ movq(rcx, kNaNValue);
   __ movq(Operand(rsp, kRegisterSize), rcx);
-  __ movsd(xmm0, Operand(rsp, kRegisterSize));
+  __ Movsd(xmm0, Operand(rsp, kRegisterSize));
   __ jmp(&return_result);
 
   // If result is valid, return that.
   __ bind(&valid_result);
   __ fstp_d(Operand(rsp, kRegisterSize));
-  __ movsd(xmm0, Operand(rsp, kRegisterSize));
+  __ Movsd(xmm0, Operand(rsp, kRegisterSize));
 
   // Clean up FPU stack and exceptions and return xmm0
   __ bind(&return_result);
   __ fstp(0);  // Unload y.
 
   Label clear_exceptions;
   __ testb(rax, Immediate(0x3f /* Any Exception*/));
   __ j(not_zero, &clear_exceptions);
   __ ret(0);
   __ bind(&clear_exceptions);
@@ skipping 159 matching lines @@
 
   // Conversion loop.
   __ bind(&loop);
   __ movp(rbx,
           FieldOperand(r8, r9, times_pointer_size, FixedArray::kHeaderSize));
   // r9 : current element's index
   // rbx: current element (smi-tagged)
   __ JumpIfNotSmi(rbx, &convert_hole);
   __ SmiToInteger32(rbx, rbx);
   __ Cvtlsi2sd(xmm0, rbx);
-  __ movsd(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize),
-           xmm0);
+  __ Movsd(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize), xmm0);
   __ jmp(&entry);
   __ bind(&convert_hole);
 
   if (FLAG_debug_code) {
     __ CompareRoot(rbx, Heap::kTheHoleValueRootIndex);
     __ Assert(equal, kObjectFoundInSmiOnlyArray);
   }
 
   __ movq(FieldOperand(r14, r9, times_8, FixedDoubleArray::kHeaderSize), r15);
   __ bind(&entry);
@@ skipping 249 matching lines @@
   DCHECK(!input.is(result));
   DCHECK(!input.is(double_scratch));
   DCHECK(!result.is(double_scratch));
   DCHECK(!temp1.is(temp2));
   DCHECK(ExternalReference::math_exp_constants(0).address() != NULL);
   DCHECK(!masm->serializer_enabled());  // External references not serializable.
 
   Label done;
 
   __ Move(kScratchRegister, ExternalReference::math_exp_constants(0));
-  __ movsd(double_scratch, Operand(kScratchRegister, 0 * kDoubleSize));
+  __ Movsd(double_scratch, Operand(kScratchRegister, 0 * kDoubleSize));
   __ xorpd(result, result);
   __ ucomisd(double_scratch, input);
   __ j(above_equal, &done);
   __ ucomisd(input, Operand(kScratchRegister, 1 * kDoubleSize));
-  __ movsd(result, Operand(kScratchRegister, 2 * kDoubleSize));
+  __ Movsd(result, Operand(kScratchRegister, 2 * kDoubleSize));
   __ j(above_equal, &done);
-  __ movsd(double_scratch, Operand(kScratchRegister, 3 * kDoubleSize));
-  __ movsd(result, Operand(kScratchRegister, 4 * kDoubleSize));
+  __ Movsd(double_scratch, Operand(kScratchRegister, 3 * kDoubleSize));
+  __ Movsd(result, Operand(kScratchRegister, 4 * kDoubleSize));
   __ mulsd(double_scratch, input);
   __ addsd(double_scratch, result);
   __ movq(temp2, double_scratch);
   __ subsd(double_scratch, result);
-  __ movsd(result, Operand(kScratchRegister, 6 * kDoubleSize));
+  __ Movsd(result, Operand(kScratchRegister, 6 * kDoubleSize));
   __ leaq(temp1, Operand(temp2, 0x1ff800));
   __ andq(temp2, Immediate(0x7ff));
   __ shrq(temp1, Immediate(11));
   __ mulsd(double_scratch, Operand(kScratchRegister, 5 * kDoubleSize));
   __ Move(kScratchRegister, ExternalReference::math_exp_log_table());
   __ shlq(temp1, Immediate(52));
   __ orq(temp1, Operand(kScratchRegister, temp2, times_8, 0));
   __ Move(kScratchRegister, ExternalReference::math_exp_constants(0));
   __ subsd(double_scratch, input);
-  __ movsd(input, double_scratch);
+  __ Movsd(input, double_scratch);
   __ subsd(result, double_scratch);
   __ mulsd(input, double_scratch);
   __ mulsd(result, input);
   __ movq(input, temp1);
   __ mulsd(result, Operand(kScratchRegister, 7 * kDoubleSize));
   __ subsd(result, double_scratch);
   __ addsd(result, Operand(kScratchRegister, 8 * kDoubleSize));
   __ mulsd(result, input);
 
   __ bind(&done);
@@ skipping 80 matching lines @@
     return Operand(base_reg_, argument_count_reg_, times_pointer_size,
         displacement_to_last_argument + (receiver - 1 - index) * kPointerSize);
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64