X64: Minor change of control flow in inline transcendental cache.

src/x64/codegen-x64.cc

 // Copyright 2010 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 25 matching lines @@
 #include "regexp-macro-assembler.h"
 #include "register-allocator-inl.h"
 #include "scopes.h"
 #include "virtual-frame-inl.h"
 
 namespace v8 {
 namespace internal {
 
 #define __ ACCESS_MASM(masm_)
 
-static int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000);
-
 // -------------------------------------------------------------------------
 // Platform-specific DeferredCode functions.
 
 void DeferredCode::SaveRegisters() {
   for (int i = 0; i < RegisterAllocator::kNumRegisters; i++) {
     int action = registers_[i];
     if (action == kPush) {
       __ push(RegisterAllocator::ToRegister(i));
     } else if (action != kIgnore && (action & kSyncedFlag) == 0) {
       __ movq(Operand(rbp, action), RegisterAllocator::ToRegister(i));
@@ skipping 7492 matching lines @@
   Label cache_miss;
   __ cmpq(rbx, Operand(rcx, 0));
   __ j(not_equal, &cache_miss);
   // Cache hit!
   __ movq(rax, Operand(rcx, 2 * kIntSize));
   __ fstp(0);  // Clear FPU stack.
   __ ret(kPointerSize);
 
   __ bind(&cache_miss);
   // Update cache with new value.
+  Label nan_result;
+  GenerateOperation(masm, &nan_result);
   __ AllocateHeapNumber(rax, rdi, &runtime_call_clear_stack);
-  GenerateOperation(masm);
   __ movq(Operand(rcx, 0), rbx);
   __ movq(Operand(rcx, 2 * kIntSize), rax);
   __ fstp_d(FieldOperand(rax, HeapNumber::kValueOffset));
   __ ret(kPointerSize);
 
   __ bind(&runtime_call_clear_stack);
   __ fstp(0);
   __ bind(&runtime_call);
   __ TailCallExternalReference(ExternalReference(RuntimeFunction()), 1, 1);
+
+  __ bind(&nan_result);
+  __ fstp(0);  // Remove argument from FPU stack.
+  __ LoadRoot(rax, Heap::kNanValueRootIndex);
+  __ movq(Operand(rcx, 0), rbx);
+  __ movq(Operand(rcx, 2 * kIntSize), rax);
+  __ ret(kPointerSize);
 }
 
 
 Runtime::FunctionId TranscendentalCacheStub::RuntimeFunction() {
   switch (type_) {
     // Add more cases when necessary.
     case TranscendentalCache::SIN: return Runtime::kMath_sin;
     case TranscendentalCache::COS: return Runtime::kMath_cos;
     default:
       UNIMPLEMENTED();
       return Runtime::kAbort;
   }
 }
 
 
-void TranscendentalCacheStub::GenerateOperation(MacroAssembler* masm) {
-  // Only free register is rdi.
+void TranscendentalCacheStub::GenerateOperation(MacroAssembler* masm,
+                                                Label* on_nan_result) {
+  // Registers:
+  // rbx: Bits of input double. Must be preserved.
+  // rcx: Pointer to cache entry. Must be preserved.
+  // st(0): Input double
   Label done;
   ASSERT(type_ == TranscendentalCache::SIN ||
          type_ == TranscendentalCache::COS);
   // More transcendental types can be added later.
 
   // Both fsin and fcos require arguments in the range +/-2^63 and
   // return NaN for infinities and NaN. They can share all code except
   // the actual fsin/fcos operation.
   Label in_range;
   // If argument is outside the range -2^63..2^63, fsin/cos doesn't
   // work. We must reduce it to the appropriate range.
   __ movq(rdi, rbx);
   // Move exponent and sign bits to low bits.
   __ shr(rdi, Immediate(HeapNumber::kMantissaBits));
   // Remove sign bit.
   __ andl(rdi, Immediate((1 << HeapNumber::KExponentBits) - 1));
   int supported_exponent_limit = (63 + HeapNumber::kExponentBias);
   __ cmpl(rdi, Immediate(supported_exponent_limit));
   __ j(below, &in_range);
   // Check for infinity and NaN. Both return NaN for sin.
   __ cmpl(rdi, Immediate(0x7ff));
-  Label non_nan_result;
-  __ j(not_equal, &non_nan_result);
-  // Input is +/-Infinity or NaN. Result is NaN.
-  __ fstp(0);  // Clear fpu stack.
-  // NaN is represented by 0x7ff8000000000000.
-  __ movq(rdi, kNaNValue, RelocInfo::NONE);
-  __ push(rdi);
-  __ fld_d(Operand(rsp, 0));
-  __ addq(rsp, Immediate(kPointerSize));
-  __ jmp(&done);
-
-  __ bind(&non_nan_result);
+  __ j(equal, on_nan_result);
 
   // Use fpmod to restrict argument to the range +/-2*PI.
-  __ movq(rdi, rax);  // Save rax before using fnstsw_ax.
   __ fldpi();
   __ fadd(0);
   __ fld(1);
   // FPU Stack: input, 2*pi, input.
   {
     Label no_exceptions;
     __ fwait();
     __ fnstsw_ax();
     // Clear if Illegal Operand or Zero Division exceptions are set.
-    __ testl(rax, Immediate(5));
+    __ testl(rax, Immediate(5));  // #IO and #ZD flags of FPU status word.
     __ j(zero, &no_exceptions);
     __ fnclex();
     __ bind(&no_exceptions);
   }
 
   // Compute st(0) % st(1)
   {
     Label partial_remainder_loop;
     __ bind(&partial_remainder_loop);
     __ fprem1();
     __ fwait();
     __ fnstsw_ax();
     __ testl(rax, Immediate(0x400));  // Check C2 bit of FPU status word.
     // If C2 is set, computation only has partial result. Loop to
     // continue computation.
     __ j(not_zero, &partial_remainder_loop);
   }
   // FPU Stack: input, 2*pi, input % 2*pi
   __ fstp(2);
   // FPU Stack: input % 2*pi, 2*pi,
   __ fstp(0);
   // FPU Stack: input % 2*pi
-  __ movq(rax, rdi);  // Restore rax (allocated HeapNumber pointer).
-
-  // FPU Stack: input % 2*pi
   __ bind(&in_range);
   switch (type_) {
     case TranscendentalCache::SIN:
       __ fsin();
       break;
     case TranscendentalCache::COS:
       __ fcos();
       break;
     default:
       UNREACHABLE();
@@ skipping 3531 matching lines @@
     __ j(not_zero, &partial_remainder_loop);
   }
 
   Label valid_result;
   Label return_result;
   // If Invalid Operand or Zero Division exceptions are set,
   // return NaN.
   __ testb(rax, Immediate(5));
   __ j(zero, &valid_result);
   __ fstp(0);  // Drop result in st(0).
+  int64_t kNaNValue = V8_INT64_C(0x7ff8000000000000);
   __ movq(rcx, kNaNValue, RelocInfo::NONE);
   __ movq(Operand(rsp, kPointerSize), rcx);
   __ movsd(xmm0, Operand(rsp, kPointerSize));
   __ jmp(&return_result);
 
   // If result is valid, return that.
   __ bind(&valid_result);
   __ fstp_d(Operand(rsp, kPointerSize));
   __ movsd(xmm0, Operand(rsp, kPointerSize));
 
@@ skipping 14 matching lines @@
   // Call the function from C++.
   return FUNCTION_CAST<ModuloFunction>(buffer);
 }
 
 #endif
 
 
 #undef __
 
 } }  // namespace v8::internal