X64: Adding macro to load double from memory, and use SSE3 instruction if present.

src/x64/lithium-codegen-x64.cc

 // Copyright 2011 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 2815 matching lines @@
 
     Label non_smi, call;
     __ JumpIfNotSmi(right_reg, &non_smi);
     __ SmiToInteger32(right_reg, right_reg);
     __ cvtlsi2sd(xmm1, right_reg);
     __ jmp(&call);
 
     __ bind(&non_smi);
     __ CmpObjectType(right_reg, HEAP_NUMBER_TYPE , kScratchRegister);
     DeoptimizeIf(not_equal, instr->environment());
-    __ movsd(xmm1, FieldOperand(right_reg, HeapNumber::kValueOffset));
+    __ LoadDbl(xmm1, FieldOperand(right_reg, HeapNumber::kValueOffset));
 
     __ bind(&call);
     __ PrepareCallCFunction(2);
     // Move arguments to correct registers xmm0 and xmm1.
     __ movaps(xmm0, left_reg);
     // Right argument is already in xmm1.
     __ CallCFunction(
         ExternalReference::power_double_double_function(isolate()), 2);
   }
   // Return value is in xmm0.
@@ skipping 582 matching lines @@
   __ CompareRoot(input_reg, Heap::kUndefinedValueRootIndex);
   DeoptimizeIf(not_equal, env);
 
   // Convert undefined to NaN. Compute NaN as 0/0.
   __ xorps(result_reg, result_reg);
   __ divsd(result_reg, result_reg);
   __ jmp(&done);
 
   // Heap number to XMM conversion.
   __ bind(&heap_number);
-  __ movsd(result_reg, FieldOperand(input_reg, HeapNumber::kValueOffset));
+  __ LoadDbl(result_reg, FieldOperand(input_reg, HeapNumber::kValueOffset));
   __ jmp(&done);
 
   // Smi to XMM conversion
   __ bind(&load_smi);
   __ SmiToInteger32(kScratchRegister, input_reg);
   __ cvtlsi2sd(result_reg, kScratchRegister);
   __ bind(&done);
 }
 
 
@@ skipping 19 matching lines @@
     __ j(equal, &heap_number);
     // Check for undefined. Undefined is converted to zero for truncating
     // conversions.
     __ CompareRoot(input_reg, Heap::kUndefinedValueRootIndex);
     DeoptimizeIf(not_equal, instr->environment());
     __ Set(input_reg, 0);
     __ jmp(&done);
 
     __ bind(&heap_number);
 
-    __ movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
+    __ LoadDbl(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
     __ cvttsd2siq(input_reg, xmm0);
     __ Set(kScratchRegister, V8_UINT64_C(0x8000000000000000));
     __ cmpq(input_reg, kScratchRegister);
     DeoptimizeIf(equal, instr->environment());
   } else {
     // Deoptimize if we don't have a heap number.
     DeoptimizeIf(not_equal, instr->environment());
 
     XMMRegister xmm_temp = ToDoubleRegister(instr->TempAt(0));
-    __ movsd(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
+    __ LoadDbl(xmm0, FieldOperand(input_reg, HeapNumber::kValueOffset));
     __ cvttsd2si(input_reg, xmm0);
     __ cvtlsi2sd(xmm_temp, input_reg);
     __ ucomisd(xmm0, xmm_temp);
     DeoptimizeIf(not_equal, instr->environment());
     DeoptimizeIf(parity_even, instr->environment());  // NaN.
     if (instr->hydrogen()->CheckFlag(HValue::kBailoutOnMinusZero)) {
       __ testl(input_reg, input_reg);
       __ j(not_zero, &done);
       __ movmskpd(input_reg, xmm0);
       __ andl(input_reg, Immediate(1));
@@ skipping 524 matching lines @@
   RegisterEnvironmentForDeoptimization(environment);
   ASSERT(osr_pc_offset_ == -1);
   osr_pc_offset_ = masm()->pc_offset();
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64