Optimize sine and cosine by checking up front if the fsin or fcos...

src/ia32/codegen-ia32.cc

 // Copyright 2006-2009 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 5372 matching lines @@
   // Load number and duplicate it.
   Load(args->at(0));
   frame_->Dup();
 
   // Get the number into an unaliased register and load it onto the
   // floating point stack still leaving one copy on the frame.
   Result number = frame_->Pop();
   number.ToRegister();
   frame_->Spill(number.reg());
   FloatingPointHelper::LoadFloatOperand(masm_, number.reg());
+
+  // Check whether the exponent is so big that performing a sine or
+  // cosine operation could result in inaccurate results or an
+  // exception.  In that case call the runtime routine.
+  __ and_(number.reg(), HeapNumber::kExponentMask);
+  __ cmp(Operand(number.reg()), Immediate(kTwoToThePowerOf63Exponent));
+  call_runtime.Branch(greater_equal, not_taken);
   number.Unuse();
 
-  // Perform the operation on the number.
+  // Perform the operation on the number.  This will succeed since we
+  // already checked that it is in range.
   switch (op) {
     case SIN:
       __ fsin();
       break;
     case COS:
       __ fcos();
       break;
   }
 
-  // Go slow case if argument to operation is out of range.
-  Result eax_reg = allocator_->Allocate(eax);
-  ASSERT(eax_reg.is_valid());
-  __ fnstsw_ax();
-  __ sahf();
-  eax_reg.Unuse();
-  call_runtime.Branch(parity_even, not_taken);
-
   // Allocate heap number for result if possible.
   Result scratch1 = allocator()->Allocate();
   Result scratch2 = allocator()->Allocate();
   Result heap_number = allocator()->Allocate();
   __ AllocateHeapNumber(heap_number.reg(),
                         scratch1.reg(),
                         scratch2.reg(),
                         call_runtime.entry_label());
   scratch1.Unuse();
   scratch2.Unuse();
@@ skipping 2035 matching lines @@
   Register scratch = ebx;
   Register scratch2 = edi;
   // Get exponent word.
   __ mov(scratch, FieldOperand(source, HeapNumber::kExponentOffset));
   // Get exponent alone in scratch2.
   __ mov(scratch2, scratch);
   __ and_(scratch2, HeapNumber::kExponentMask);
   if (use_sse3) {
     CpuFeatures::Scope scope(SSE3);
     // Check whether the exponent is too big for a 64 bit signed integer.
-    const uint32_t too_big_exponent =
-        (HeapNumber::kExponentBias + 63) << HeapNumber::kExponentShift;
-    __ cmp(Operand(scratch2), Immediate(too_big_exponent));
+    __ cmp(Operand(scratch2),
+           Immediate(CodeGenerator::kTwoToThePowerOf63Exponent));
     __ j(greater_equal, conversion_failure);
     // Load x87 register with heap number.
     __ fld_d(FieldOperand(source, HeapNumber::kValueOffset));
     // Reserve space for 64 bit answer.
     __ sub(Operand(esp), Immediate(sizeof(uint64_t)));  // Nolint.
     // Do conversion, which cannot fail because we checked the exponent.
     __ fisttp_d(Operand(esp, 0));
     __ mov(ecx, Operand(esp, 0));  // Load low word of answer into ecx.
     __ add(Operand(esp), Immediate(sizeof(uint64_t)));  // Nolint.
   } else {
@@ skipping 1478 matching lines @@
     __ add(Operand(dest), Immediate(2));
   }
   __ sub(Operand(count), Immediate(1));
   __ j(not_zero, &loop);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal