Merge sin(a), cos(a) into one instruction. TODO: Implement for ARM and MIPS.

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 4034 matching lines @@
     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;
+    LocationSummary* summary =
+        new LocationSummary(kNumInputs, kNumTemps, LocationSummary::kCall);
+    summary->set_in(0, Location::FpuRegisterLocation(XMM1));
+    summary->set_out(Location::RegisterLocation(RAX));
+    return summary;
+  }
   UNIMPLEMENTED();
   return NULL;
 }
 
 
+
+typedef void (*SinCosCFunction) (double x, double* res_sin, double* res_cos);
+
+extern const RuntimeEntry kSinCosRuntimeEntry(
+    "libc_sincos", reinterpret_cast<RuntimeFunction>(
+        static_cast<SinCosCFunction>(&SinCos)), 1, true, true);
+
+
 void MergedMathInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
   Label* deopt = NULL;
   if (CanDeoptimize()) {
     deopt  = compiler->AddDeoptStub(deopt_id(), kDeoptBinarySmiOp);
   }
   if (kind() == MergedMathInstr::kTruncDivMod) {
     Register left = locs()->in(0).reg();
     Register right = locs()->in(1).reg();
     Register result = locs()->out().reg();
     Label not_32bit, done;
@@ skipping 69 matching lines @@
     } else {
       // Right is negative.
       __ subq(RDX, right);
     }
     __ Bind(&all_done);
     __ SmiTag(result);
 
     __ LoadObject(result, Array::ZoneHandle(Array::New(2, Heap::kOld)), PP);
     const intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(kArrayCid);
     Address trunc_div_address(
-        FlowGraphCompiler::ElementAddressForIntIndex(kArrayCid,
-                                                     index_scale,
-                                                     result,
-                                                     0));
+        FlowGraphCompiler::ElementAddressForIntIndex(
+            kArrayCid, index_scale, result,
+            MergedMathInstr::ResultIndexOf(Token::kTRUNCDIV)));
     Address mod_address(
-        FlowGraphCompiler::ElementAddressForIntIndex(kArrayCid,
-                                                     index_scale,
-                                                     result,
-                                                     1));
+        FlowGraphCompiler::ElementAddressForIntIndex(
+            kArrayCid, index_scale, result,
+            MergedMathInstr::ResultIndexOf(Token::kMOD)));
     __ 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);
+    // +-------------------------------+
+    // | 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();
+
+    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,
+            MergedMathInstr::ResultIndexOf(MethodRecognizer::kMathSin)));
+    Address cos_address(
+        FlowGraphCompiler::ElementAddressForIntIndex(
+            kTypedDataFloat64ArrayCid, index_scale, result,
+            MergedMathInstr::ResultIndexOf(MethodRecognizer::kMathCos)));
+    __ movsd(sin_address, XMM0);
+    __ movsd(cos_address, XMM1);
+    return;
+  }
   UNIMPLEMENTED();
 }
 
 
 LocationSummary* PolymorphicInstanceCallInstr::MakeLocationSummary() const {
   return MakeCallSummary();
 }
 
 
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
@@ skipping 516 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_X64