Add an untagged double to transcendental cache elements. They now contain an...

src/x64/code-stubs-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 1051 matching lines @@
   __ j(zero, &runtime_call_clear_stack);
 #ifdef DEBUG
   // Check that the layout of cache elements match expectations.
   {  // NOLINT - doesn't like a single brace on a line.
     TranscendentalCache::Element test_elem[2];
     char* elem_start = reinterpret_cast<char*>(&test_elem[0]);
     char* elem2_start = reinterpret_cast<char*>(&test_elem[1]);
     char* elem_in0  = reinterpret_cast<char*>(&(test_elem[0].in[0]));
     char* elem_in1  = reinterpret_cast<char*>(&(test_elem[0].in[1]));
     char* elem_out = reinterpret_cast<char*>(&(test_elem[0].output));
+    char* elem_uout = reinterpret_cast<char*>(&(test_elem[0].untagged_output));
     // Two uint_32's and a pointer per element.
-    CHECK_EQ(16, static_cast<int>(elem2_start - elem_start));
+    CHECK_EQ(24, static_cast<int>(elem2_start - elem_start));
     CHECK_EQ(0, static_cast<int>(elem_in0 - elem_start));
     CHECK_EQ(kIntSize, static_cast<int>(elem_in1 - elem_start));
     CHECK_EQ(2 * kIntSize, static_cast<int>(elem_out - elem_start));
+    CHECK_EQ(4 * kIntSize, static_cast<int>(elem_uout - elem_start));
   }
 #endif
   // Find the address of the rcx'th entry in the cache, i.e., &rax[rcx*16].
-  __ addl(rcx, rcx);
+  __ lea(rcx, Operand(rcx, rcx, times_2, 0));
   __ lea(rcx, Operand(rax, rcx, times_8, 0));
   // Check if cache matches: Double value is stored in uint32_t[2] array.
-  NearLabel cache_miss;
+  Label cache_miss;
+  NearLabel allocate_cached_answer;
   __ cmpq(rbx, Operand(rcx, 0));
   __ j(not_equal, &cache_miss);
   // Cache hit!
   __ movq(rax, Operand(rcx, 2 * kIntSize));
   __ fstp(0);  // Clear FPU stack.
+  __ testq(rax, rax);
+  __ j(zero, &allocate_cached_answer);  // The answer is cached as untagged.
+  __ ret(kPointerSize);
+
+  __ bind(&allocate_cached_answer);
+  __ AllocateHeapNumber(rax, rdi, &runtime_call_clear_stack);
+  __ movq(rdi, Operand(rcx, 4 * kIntSize));
+  __ movq(FieldOperand(rax, HeapNumber::kValueOffset), rdi);
+  __ movq(Operand(rcx, 2 * kIntSize), rax);
   __ ret(kPointerSize);
 
   __ bind(&cache_miss);
   // Update cache with new value.
   Label nan_result;
   GenerateOperation(masm, &nan_result);
   __ AllocateHeapNumber(rax, rdi, &runtime_call_clear_stack);
   __ movq(Operand(rcx, 0), rbx);
   __ movq(Operand(rcx, 2 * kIntSize), rax);
   __ fstp_d(FieldOperand(rax, HeapNumber::kValueOffset));
@@ skipping 3002 matching lines @@
 
 void ICCompareStub::GenerateMiss(MacroAssembler* masm) {
   UNIMPLEMENTED();
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64