[vm, compiler] Avoid one indirection when loading double constants. TEST=ci Change-Id: I3fc0a506121c660ae6c15a7c5e112fdf93a8ad90 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/224400 Reviewed-by: Alexander Markov <alexmarkov@google.com> Commit-Queue: Ryan Macnak <rmacnak@google.com>

diff --git a/runtime/vm/compiler/assembler/assembler_x64.cc b/runtime/vm/compiler/assembler/assembler_x64.cc
index 0c396e7..12398f9 100644
--- a/runtime/vm/compiler/assembler/assembler_x64.cc
+++ b/runtime/vm/compiler/assembler/assembler_x64.cc

@@ -1379,6 +1379,17 @@
   }
 }
 
+void Assembler::LoadDImmediate(FpuRegister dst, double immediate) {
+  int64_t bits = bit_cast<int64_t>(immediate);
+  if (bits == 0) {
+    xorps(dst, dst);
+  } else {
+    intptr_t index = FindImmediate(bits);
+    LoadUnboxedDouble(
+        dst, PP, target::ObjectPool::element_offset(index) - kHeapObjectTag);
+  }
+}
+
 void Assembler::LoadCompressed(Register dest, const Address& slot) {
 #if !defined(DART_COMPRESSED_POINTERS)
   movq(dest, slot);

diff --git a/runtime/vm/compiler/assembler/assembler_x64.h b/runtime/vm/compiler/assembler/assembler_x64.h
index 5312859..3f4bf92 100644
--- a/runtime/vm/compiler/assembler/assembler_x64.h
+++ b/runtime/vm/compiler/assembler/assembler_x64.h

@@ -747,6 +747,7 @@
   void LoadImmediate(Register reg, int32_t immediate) {
     LoadImmediate(reg, Immediate(immediate));
   }
+  void LoadDImmediate(FpuRegister dst, double immediate);
 
   void LoadIsolate(Register dst);
   void LoadIsolateGroup(Register dst);

diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
index 91cc786..bed125b 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc

@@ -866,14 +866,7 @@
   } else {
     ASSERT(!source.IsInvalid());
     ASSERT(source.IsConstant());
-    if (destination.IsFpuRegister() || destination.IsDoubleStackSlot()) {
-      Register scratch = tmp->AllocateTemporary();
-      source.constant_instruction()->EmitMoveToLocation(this, destination,
-                                                        scratch);
-      tmp->ReleaseTemporary();
-    } else {
-      source.constant_instruction()->EmitMoveToLocation(this, destination);
-    }
+    source.constant_instruction()->EmitMoveToLocation(this, destination);
   }
 }
 

diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 378537a..3066d10 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc

@@ -560,22 +560,9 @@
       __ LoadObject(destination.reg(), value_);
     }
   } else if (destination.IsFpuRegister()) {
-    if (Utils::DoublesBitEqual(Double::Cast(value_).value(), 0.0)) {
-      __ xorps(destination.fpu_reg(), destination.fpu_reg());
-    } else {
-      ASSERT(tmp != kNoRegister);
-      __ LoadObject(tmp, value_);
-      __ movsd(destination.fpu_reg(),
-               compiler::FieldAddress(tmp, Double::value_offset()));
-    }
+    __ LoadDImmediate(destination.fpu_reg(), Double::Cast(value_).value());
   } else if (destination.IsDoubleStackSlot()) {
-    if (Utils::DoublesBitEqual(Double::Cast(value_).value(), 0.0)) {
-      __ xorps(FpuTMP, FpuTMP);
-    } else {
-      ASSERT(tmp != kNoRegister);
-      __ LoadObject(tmp, value_);
-      __ movsd(FpuTMP, compiler::FieldAddress(tmp, Double::value_offset()));
-    }
+    __ LoadDImmediate(FpuTMP, Double::Cast(value_).value());
     __ movsd(LocationToStackSlotAddress(destination), FpuTMP);
   } else {
     ASSERT(destination.IsStackSlot());
@@ -5438,13 +5425,11 @@
   XmmRegister base = locs->in(0).fpu_reg();
   XmmRegister exp = locs->in(1).fpu_reg();
   XmmRegister result = locs->out(0).fpu_reg();
-  Register temp = locs->temp(InvokeMathCFunctionInstr::kObjectTempIndex).reg();
   XmmRegister zero_temp =
       locs->temp(InvokeMathCFunctionInstr::kDoubleTempIndex).fpu_reg();
 
   __ xorps(zero_temp, zero_temp);
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)));
-  __ movsd(result, compiler::FieldAddress(temp, Double::value_offset()));
+  __ LoadDImmediate(result, 1.0);
 
   compiler::Label check_base, skip_call;
   // exponent == 0.0 -> return 1.0;
@@ -5458,15 +5443,13 @@
   __ j(EQUAL, &return_base, compiler::Assembler::kNearJump);
 
   // exponent == 2.0 ?
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(2.0)));
-  __ movsd(XMM0, compiler::FieldAddress(temp, Double::value_offset()));
+  __ LoadDImmediate(XMM0, 2.0);
   __ comisd(exp, XMM0);
   compiler::Label return_base_times_2;
   __ j(EQUAL, &return_base_times_2, compiler::Assembler::kNearJump);
 
   // exponent == 3.0 ?
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(3.0)));
-  __ movsd(XMM0, compiler::FieldAddress(temp, Double::value_offset()));
+  __ LoadDImmediate(XMM0, 3.0);
   __ comisd(exp, XMM0);
   __ j(NOT_EQUAL, &check_base);
 
@@ -5500,22 +5483,19 @@
   __ j(PARITY_ODD, &try_sqrt, compiler::Assembler::kNearJump);
   // Return NaN.
   __ Bind(&return_nan);
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(NAN)));
-  __ movsd(result, compiler::FieldAddress(temp, Double::value_offset()));
+  __ LoadDImmediate(result, NAN);
   __ jmp(&skip_call);
 
   compiler::Label do_pow, return_zero;
   __ Bind(&try_sqrt);
   // Before calling pow, check if we could use sqrt instead of pow.
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(kNegInfinity)));
-  __ movsd(result, compiler::FieldAddress(temp, Double::value_offset()));
+  __ LoadDImmediate(result, kNegInfinity);
   // base == -Infinity -> call pow;
   __ comisd(base, result);
   __ j(EQUAL, &do_pow, compiler::Assembler::kNearJump);
 
   // exponent == 0.5 ?
-  __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0.5)));
-  __ movsd(result, compiler::FieldAddress(temp, Double::value_offset()));
+  __ LoadDImmediate(result, 0.5);
   __ comisd(exp, result);
   __ j(NOT_EQUAL, &do_pow, compiler::Assembler::kNearJump);