Stop creating dummy call frames when calling out to C functions

runtime/vm/intermediate_language_x64.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 3962 matching lines @@
 
 
 LocationSummary* MathUnaryInstr::MakeLocationSummary(bool opt) const {
   if ((kind() == MethodRecognizer::kMathSin) ||
       (kind() == MethodRecognizer::kMathCos)) {
     // Calling convention on x64 uses XMM0 and XMM1 to pass the first two
     // double arguments and XMM0 to return the result. Unfortunately
     // currently we can't specify these registers because ParallelMoveResolver
     // assumes that XMM0 is free at all times.
     // TODO(vegorov): allow XMM0 to be used.
-    const intptr_t kNumTemps = 0;
+    const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(InputCount(), kNumTemps, LocationSummary::kCall);
     summary->set_in(0, Location::FpuRegisterLocation(XMM1));
+    summary->set_temp(0, Location::RegisterLocation(CALLEE_SAVED));

[regis, 2014/02/26 23:53:12]

ditto

[Cutch, 2014/02/27 15:52:37]

Done.

     summary->set_out(Location::FpuRegisterLocation(XMM1));
     return summary;
   }
+  ASSERT(kind() == MethodRecognizer::kMathSqrt);
   const intptr_t kNumInputs = 1;
   const intptr_t kNumTemps = 0;
   LocationSummary* summary =
       new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
   summary->set_in(0, Location::RequiresFpuRegister());
   summary->set_out(Location::RequiresFpuRegister());
   return summary;
 }
 
 
 void MathUnaryInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   if (kind() == MethodRecognizer::kMathSqrt) {
     __ sqrtsd(locs()->out().fpu_reg(), locs()->in(0).fpu_reg());
   } else {
-    __ EnterFrame(0);
+    ASSERT((kind() == MethodRecognizer::kMathSin) ||
+           (kind() == MethodRecognizer::kMathCos));
+    // Save RSP.
+    __ movq(locs()->temp(0).reg(), RSP);
     __ ReserveAlignedFrameSpace(0);
     __ movaps(XMM0, locs()->in(0).fpu_reg());
     __ CallRuntime(TargetFunction(), InputCount());
     __ movaps(locs()->out().fpu_reg(), XMM0);
-    __ leave();
+    // Restore RSP.
+    __ movq(RSP, locs()->temp(0).reg());
   }
 }
 
 
 LocationSummary* UnarySmiOpInstr::MakeLocationSummary(bool opt) const {
   const intptr_t kNumInputs = 1;
   return LocationSummary::Make(kNumInputs,
                                Location::SameAsFirstInput(),
                                LocationSummary::kNoCall);
 }
@@ skipping 295 matching lines @@
 }
 
 
 LocationSummary* InvokeMathCFunctionInstr::MakeLocationSummary(bool opt) const {
   // Calling convention on x64 uses XMM0 and XMM1 to pass the first two
   // double arguments and XMM0 to return the result. Unfortunately
   // currently we can't specify these registers because ParallelMoveResolver
   // assumes that XMM0 is free at all times.
   // TODO(vegorov): allow XMM0 to be used.
   ASSERT((InputCount() == 1) || (InputCount() == 2));
-  const intptr_t kNumTemps = 0;
+  const intptr_t kNumTemps = 1;
   LocationSummary* result =
       new LocationSummary(InputCount(), kNumTemps, LocationSummary::kCall);
+  result->set_temp(0, Location::RegisterLocation(CALLEE_SAVED));
   result->set_in(0, Location::FpuRegisterLocation(XMM2));
   if (InputCount() == 2) {
     result->set_in(1, Location::FpuRegisterLocation(XMM1));
   }
   if (recognized_kind() == MethodRecognizer::kMathDoublePow) {
     result->AddTemp(Location::RegisterLocation(RAX));
     result->AddTemp(Location::FpuRegisterLocation(XMM4));
   }
   result->set_out(Location::FpuRegisterLocation(XMM3));
   return result;
 }
 
 
 void InvokeMathCFunctionInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  __ EnterFrame(0);
+  // Save RSP.
+  __ movq(locs()->temp(0).reg(), RSP);
   __ ReserveAlignedFrameSpace(0);
   __ movaps(XMM0, locs()->in(0).fpu_reg());
   if (InputCount() == 2) {
     ASSERT(locs()->in(1).fpu_reg() == XMM1);
   }
   // For pow-function return NaN if exponent is NaN.
   Label do_call, skip_call;
   if (recognized_kind() == MethodRecognizer::kMathDoublePow) {
     // Pseudo code:
     // if (exponent == 0.0) return 0.0;
     // if (base == 1.0) return 1.0;
     // if (base.isNaN || exponent.isNaN) {
     //    return double.NAN;
     // }
     XmmRegister base = locs()->in(0).fpu_reg();
     XmmRegister exp = locs()->in(1).fpu_reg();
     XmmRegister result = locs()->out().fpu_reg();
     Register temp = locs()->temp(0).reg();

[siva, 2014/02/27 00:00:26]

Ditto comment about the temp index.
I am wondering if it would be more readable to have an enum of these temp slots
so that it is obvious that kSavedSpSlot is not used in any of the code below.

[Cutch, 2014/02/27 15:52:37]

Added index constants to instruction.

     XmmRegister zero_temp = locs()->temp(1).fpu_reg();
 
     // Check if exponent is 0.0 -> return 1.0;
     __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(0)), PP);
     __ movsd(zero_temp, FieldAddress(temp, Double::value_offset()));
     __ LoadObject(temp, Double::ZoneHandle(Double::NewCanonical(1)), PP);
     __ movsd(result, FieldAddress(temp, Double::value_offset()));
     // 'result' contains 1.0.
     Label exp_is_nan;
     __ comisd(exp, zero_temp);
@@ skipping 17 matching lines @@
     __ comisd(base, result);
     __ j(PARITY_EVEN, &base_is_nan, Assembler::kNearJump);
     __ j(EQUAL, &skip_call, Assembler::kNearJump);  // base and result are 1.0
     __ movsd(result, exp);  // result is NaN
     __ jmp(&skip_call, Assembler::kNearJump);
   }
   __ Bind(&do_call);
   __ CallRuntime(TargetFunction(), InputCount());
   __ movaps(locs()->out().fpu_reg(), XMM0);
   __ Bind(&skip_call);
-  __ leave();
+  // Restore RSP.
+  __ movq(RSP, locs()->temp(0).reg());
 }
 
 
 LocationSummary* MergedMathInstr::MakeLocationSummary(bool opt) const {
   if (kind() == MergedMathInstr::kTruncDivMod) {
     const intptr_t kNumInputs = 2;
     const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kNoCall);
     // Both inputs must be writable because they will be untagged.
     summary->set_in(0, Location::RegisterLocation(RAX));
     summary->set_in(1, Location::WritableRegister());
     summary->set_out(Location::RequiresRegister());
     // Will be used for sign extension and division.
     summary->set_temp(0, Location::RegisterLocation(RDX));
     return summary;
   }
   if (kind() == MergedMathInstr::kSinCos) {
     const intptr_t kNumInputs = 1;
-    const intptr_t kNumTemps = 0;
+    const intptr_t kNumTemps = 1;
     LocationSummary* summary =
         new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
     summary->set_in(0, Location::FpuRegisterLocation(XMM1));
+    summary->set_temp(0, Location::RegisterLocation(CALLEE_SAVED));
     summary->set_out(Location::RegisterLocation(RAX));
     return summary;
   }
   UNIMPLEMENTED();
   return NULL;
 }
 
 
 
 typedef void (*SinCosCFunction) (double x, double* res_sin, double* res_cos);
@@ skipping 102 matching lines @@
     __ SmiTag(RAX);
     __ SmiTag(RDX);
     __ StoreIntoObjectNoBarrier(result, trunc_div_address, RAX);
     __ StoreIntoObjectNoBarrier(result, mod_address, RDX);
     // FLAG_throw_on_javascript_int_overflow: not needed.
     // Note that the result of an integer division/modulo of two
     // in-range arguments, cannot create out-of-range result.
     return;
   }
   if (kind() == MergedMathInstr::kSinCos) {
-    __ EnterFrame(0);
+    // Save RSP.
+    __ movq(locs()->temp(0).reg(), RSP);
     // +-------------------------------+
     // | double-argument               |  <- TOS
     // +-------------------------------+
     // | address-cos-result            |  +8
     // +-------------------------------+
     // | address-sin-result            |  +16
     // +-------------------------------+
     // | double-storage-for-cos-result |  +24
     // +-------------------------------+
     // | double-storage-for-sin-result |  +32
     // +-------------------------------+
     // ....
     __ ReserveAlignedFrameSpace(kDoubleSize * 3 + kWordSize * 2);
     __ movsd(Address(RSP, 0), locs()->in(0).fpu_reg());
 
     __ leaq(RDI, Address(RSP, 2 * kWordSize + kDoubleSize));
     __ leaq(RSI, Address(RSP, 2 * kWordSize + 2 * kDoubleSize));
     __ movaps(XMM0, locs()->in(0).fpu_reg());
 
     __ CallRuntime(kSinCosRuntimeEntry, InputCount());
     __ movsd(XMM0, Address(RSP, 2 * kWordSize + kDoubleSize * 2));  // sin.
     __ movsd(XMM1, Address(RSP, 2 * kWordSize + kDoubleSize));  // cos.
-    __ leave();
+    // Restore RSP.
+    __ movq(RSP, locs()->temp(0).reg());
 
     Register result = locs()->out().reg();
     const TypedData& res_array = TypedData::ZoneHandle(
       TypedData::New(kTypedDataFloat64ArrayCid, 2, Heap::kOld));
     __ LoadObject(result, res_array, PP);
     const intptr_t index_scale =
         FlowGraphCompiler::ElementSizeFor(kTypedDataFloat64ArrayCid);
     Address sin_address(
         FlowGraphCompiler::ElementAddressForIntIndex(
             kTypedDataFloat64ArrayCid, index_scale, result,
@@ skipping 512 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64