Age the number string cache so it does not keep strings

src/x64/code-stubs-x64.cc

 // Copyright 2011 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 2912 matching lines @@
                                                          Label* not_found) {
   // Use of registers. Register result is used as a temporary.
   Register number_string_cache = result;
   Register mask = scratch1;
   Register scratch = scratch2;
 
   // Load the number string cache.
   __ LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
 
   // Make the hash mask from the length of the number string cache. It
-  // contains two elements (number and string) for each cache entry.
+  // contains three elements (number, string and age) for each cache entry.
   __ SmiToInteger32(
-      mask, FieldOperand(number_string_cache, FixedArray::kLengthOffset));
-  __ shrl(mask, Immediate(1));
-  __ subq(mask, Immediate(1));  // Make mask.
+      scratch, FieldOperand(number_string_cache, FixedArray::kLengthOffset));
+
+  STATIC_ASSERT(Heap::kNSCSlotsPerEntry == 3);
+  // mask = scratch / 3 - 1, making it one less than a power of 2.
+  __ lea(mask, Operand(scratch, -1));
+  __ and_(scratch, mask);
+  __ xor_(mask, scratch);
 
   // Calculate the entry in the number string cache. The hash value in the
   // number string cache for smis is just the smi value, and the hash for
   // doubles is the xor of the upper and lower words. See
   // Heap::GetNumberStringCache.
   Label is_smi;
   Label load_result_from_cache;
   Factory* factory = masm->isolate()->factory();
   if (!object_is_smi) {
     __ JumpIfSmi(object, &is_smi);
     __ CheckMap(object,
                 factory->heap_number_map(),
                 not_found,
                 DONT_DO_SMI_CHECK);
 
     STATIC_ASSERT(8 == kDoubleSize);
     __ movl(scratch, FieldOperand(object, HeapNumber::kValueOffset + 4));
     __ xor_(scratch, FieldOperand(object, HeapNumber::kValueOffset));
     GenerateConvertHashCodeToIndex(masm, scratch, mask);
 
     Register index = scratch;
     Register probe = mask;
-    __ movq(probe,
-            FieldOperand(number_string_cache,
-                         index,
-                         times_1,
-                         FixedArray::kHeaderSize));
+    __ movq(probe, FieldOperand(
+        number_string_cache,
+        index,
+        times_pointer_size,
+        FixedArray::kHeaderSize + kPointerSize * Heap::kNSCNumberOffset));
     __ JumpIfSmi(probe, not_found);
     __ movsd(xmm0, FieldOperand(object, HeapNumber::kValueOffset));
     __ movsd(xmm1, FieldOperand(probe, HeapNumber::kValueOffset));
     __ ucomisd(xmm0, xmm1);
     __ j(parity_even, not_found);  // Bail out if NaN is involved.
     __ j(not_equal, not_found);  // The cache did not contain this value.
     __ jmp(&load_result_from_cache);
   }
 
   __ bind(&is_smi);
   __ SmiToInteger32(scratch, object);
   GenerateConvertHashCodeToIndex(masm, scratch, mask);
 
   Register index = scratch;
   // Check if the entry is the smi we are looking for.
-  __ cmpq(object,
-          FieldOperand(number_string_cache,
-                       index,
-                       times_1,
-                       FixedArray::kHeaderSize));
+  __ cmpq(object, FieldOperand(
+      number_string_cache,
+      index,
+      times_pointer_size,
+      FixedArray::kHeaderSize + kPointerSize * Heap::kNSCNumberOffset));
   __ j(not_equal, not_found);
 
   // Get the result from the cache.
   __ bind(&load_result_from_cache);
-  __ movq(result,
-          FieldOperand(number_string_cache,
+  int kAgeOffset = FixedArray::kHeaderSize + kPointerSize * Heap::kNSCAgeOffset;
+  __ Move(FieldOperand(number_string_cache,
                        index,
-                       times_1,
-                       FixedArray::kHeaderSize + kPointerSize));
+                       times_pointer_size,
+                       kAgeOffset),
+          Smi::FromInt(Heap::kNSCMinAge));  // Reset age field.
+  __ movq(result, FieldOperand(
+      number_string_cache,
+      index,
+      times_pointer_size,
+      FixedArray::kHeaderSize + kPointerSize * Heap::kNSCStringOffset));
   Counters* counters = masm->isolate()->counters();
   __ IncrementCounter(counters->number_to_string_native(), 1);
 }
 
 
 void NumberToStringStub::GenerateConvertHashCodeToIndex(MacroAssembler* masm,
                                                         Register hash,
                                                         Register mask) {
   __ and_(hash, mask);
-  // Each entry in string cache consists of two pointer sized fields,
-  // but times_twice_pointer_size (multiplication by 16) scale factor
-  // is not supported by addrmode on x64 platform.
-  // So we have to premultiply entry index before lookup.
-  __ shl(hash, Immediate(kPointerSizeLog2 + 1));
+  // Each entry in string cache consists of three pointer sized fields,
+  // so we multiply by 3 and we will use times_pointer_size scaling.
+  __ lea(hash, Operand(hash, hash, times_2, 0));
 }
 
 
 void NumberToStringStub::Generate(MacroAssembler* masm) {
   Label runtime;
 
   __ movq(rbx, Operand(rsp, kPointerSize));
 
   // Generate code to lookup number in the number string cache.
   GenerateLookupNumberStringCache(masm, rbx, rax, r8, r9, false, &runtime);
@@ skipping 3074 matching lines @@
                       OMIT_SMI_CHECK);
   __ pop(rax);
   __ movq(rsi, Operand(rbp, StandardFrameConstants::kContextOffset));
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64