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

runtime/vm/intermediate_language_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/dart_entry.h"
@@ skipping 3994 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(EAX));
     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(EDX));
     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(EAX));
+    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();
@@ skipping 44 matching lines @@
       __ addl(EDX, right);
     } else {
       // Right is negative.
       __ subl(EDX, right);
     }
     __ Bind(&done);
 
     __ LoadObject(result, Array::ZoneHandle(Array::New(2, Heap::kOld)));
     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(EAX);
     __ SmiTag(EDX);
     __ StoreIntoObjectNoBarrier(result, trunc_div_address, EAX);
     __ StoreIntoObjectNoBarrier(result, mod_address, EDX);
     return;
   }
 
+  if (kind() == MergedMathInstr::kSinCos) {
+    // Do x87 sincos, since the ia32 compilers may not fuse sin/cos into
+    // sincos.
+    __ pushl(EAX);
+    __ pushl(EAX);
+    __ movsd(Address(ESP, 0), locs()->in(0).fpu_reg());
+    __ fldl(Address(ESP, 0));
+    __ fsincos();
+    __ fstpl(Address(ESP, 0));
+    __ movsd(XMM1, Address(ESP, 0));
+    __ fstpl(Address(ESP, 0));
+    __ movsd(XMM0, Address(ESP, 0));
+    __ addl(ESP, Immediate(2 * kWordSize));
+
+    Register result = locs()->out().reg();
+    const TypedData& res_array = TypedData::ZoneHandle(
+      TypedData::New(kTypedDataFloat64ArrayCid, 2, Heap::kOld));
+    __ LoadObject(result, res_array);
+    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 858 matching lines @@
                          PcDescriptors::kOther,
                          locs());
   __ Drop(2);  // Discard type arguments and receiver.
 }
 
 }  // namespace dart
 
 #undef __
 
 #endif  // defined TARGET_ARCH_IA32