Age the number string cache so it does not keep strings

src/ia32/code-stubs-ia32.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 3847 matching lines @@
   Register mask = scratch1;
   Register scratch = scratch2;
 
   // Load the number string cache.
   ExternalReference roots_address =
       ExternalReference::roots_address(masm->isolate());
   __ mov(scratch, Immediate(Heap::kNumberStringCacheRootIndex));
   __ mov(number_string_cache,
          Operand::StaticArray(scratch, times_pointer_size, roots_address));
   // 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.
   __ mov(mask, FieldOperand(number_string_cache, FixedArray::kLengthOffset));
-  __ shr(mask, kSmiTagSize + 1);  // Untag length and divide it by two.
-  __ sub(mask, Immediate(1));  // Make mask.
+  __ lea(scratch, Operand(mask, mask, times_1, 0));
+  STATIC_ASSERT(Heap::kNSCSlotsPerEntry == 3);
+  __ and_(mask, scratch);  // Multiply mask by 2/3, making it a power of 2.
+  // Make mask.  It is 4 times the number of entries (2 times for Smi tag,
+  // 2 times for the size of the array * 2/3).
+  STATIC_ASSERT(kSmiTagSize == 1);
+  STATIC_ASSERT(kPointerSize == 4);
+  __ sub(mask, Immediate(kPointerSize - 1));
 
   // 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 smi_hash_calculated;
   Label load_result_from_cache;
   if (object_is_smi) {
-    __ mov(scratch, object);
-    __ SmiUntag(scratch);
+    STATIC_ASSERT(kPointerSizeLog2 - kSmiTagSize == 1);
+    STATIC_ASSERT(kSmiTag == 0);
+    __ lea(scratch, Operand(object, object, times_1, 0));
   } else {
     Label not_smi;
     STATIC_ASSERT(kSmiTag == 0);
     __ JumpIfNotSmi(object, &not_smi, Label::kNear);
-    __ mov(scratch, object);
-    __ SmiUntag(scratch);
+    STATIC_ASSERT(kPointerSizeLog2 - kSmiTagSize == 1);
+    STATIC_ASSERT(kSmiTag == 0);
+    __ lea(scratch, Operand(object, object, times_1, 0));
     __ jmp(&smi_hash_calculated, Label::kNear);
     __ bind(&not_smi);
     __ cmp(FieldOperand(object, HeapObject::kMapOffset),
            masm->isolate()->factory()->heap_number_map());
     __ j(not_equal, not_found);
     STATIC_ASSERT(8 == kDoubleSize);
     __ mov(scratch, FieldOperand(object, HeapNumber::kValueOffset));
     __ xor_(scratch, FieldOperand(object, HeapNumber::kValueOffset + 4));
-    // Object is heap number and hash is now in scratch. Calculate cache index.
+    // Object is heap number and hash is now in scratch. Scale hash to pointer
+    // size and apply the mask.
+    __ shl(scratch, kPointerSizeLog2);
     __ and_(scratch, mask);
+    // Multiply by 3.
+    STATIC_ASSERT(Heap::kNSCSlotsPerEntry == 3);
+    __ lea(scratch, Operand(scratch, scratch, times_2, 0));
     Register index = scratch;
     Register probe = mask;
-    __ mov(probe,
-           FieldOperand(number_string_cache,
-                        index,
-                        times_twice_pointer_size,
-                        FixedArray::kHeaderSize));
+    __ mov(probe, FieldOperand(
+        number_string_cache,
+        index,
+        times_1,
+        FixedArray::kHeaderSize + kPointerSizeLog2 * Heap::kNSCNumberOffset));
     __ JumpIfSmi(probe, not_found);
     if (CpuFeatures::IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ movdbl(xmm0, FieldOperand(object, HeapNumber::kValueOffset));
       __ movdbl(xmm1, FieldOperand(probe, HeapNumber::kValueOffset));
       __ ucomisd(xmm0, xmm1);
     } else {
       __ fld_d(FieldOperand(object, HeapNumber::kValueOffset));
       __ fld_d(FieldOperand(probe, HeapNumber::kValueOffset));
       __ FCmp();
     }
     __ 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, Label::kNear);
   }
 
   __ bind(&smi_hash_calculated);
   // Object is smi and hash is now in scratch. Calculate cache index.
   __ and_(scratch, mask);
+  // Multiply by 3.
   Register index = scratch;
+  __ lea(index, Operand(scratch, scratch, times_2, 0));
   // Check if the entry is the smi we are looking for.
-  __ cmp(object,
-         FieldOperand(number_string_cache,
-                      index,
-                      times_twice_pointer_size,
-                      FixedArray::kHeaderSize));
+  __ cmp(object, FieldOperand(
+      number_string_cache,
+      index,
+      times_1,
+      FixedArray::kHeaderSize + kPointerSizeLog2 * Heap::kNSCNumberOffset));
   __ j(not_equal, not_found);
 
   // Get the result from the cache.
   __ bind(&load_result_from_cache);
+  int kAgeOffset = FixedArray::kHeaderSize + kPointerSize * Heap::kNSCAgeOffset;
+  __ mov(FieldOperand(number_string_cache, index, times_1, kAgeOffset),
+         Immediate(Smi::FromInt(Heap::kNSCMinAge)));  // Reset age field.
   __ mov(result,
-         FieldOperand(number_string_cache,
-                      index,
-                      times_twice_pointer_size,
-                      FixedArray::kHeaderSize + kPointerSize));
+         FieldOperand(
+             number_string_cache,
+             index,
+             times_1,
+             FixedArray::kHeaderSize + kPointerSize * Heap::kNSCStringOffset));
   Counters* counters = masm->isolate()->counters();
   __ IncrementCounter(counters->number_to_string_native(), 1);
 }
 
 
 void NumberToStringStub::Generate(MacroAssembler* masm) {
   Label runtime;
 
   __ mov(ebx, Operand(esp, kPointerSize));
 
@@ skipping 3297 matching lines @@
   // Restore registers.
   __ pop(eax);
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32