Age the number string cache so it does not keep strings

src/arm/code-stubs-arm.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 1416 matching lines @@
                                                          bool object_is_smi,
                                                          Label* not_found) {
   // Use of registers. Register result is used as a temporary.
   Register number_string_cache = result;
   Register mask = scratch3;
 
   // 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.
   __ ldr(mask, FieldMemOperand(number_string_cache, FixedArray::kLengthOffset));
-  // Divide length by two (length is a smi).
-  __ mov(mask, Operand(mask, ASR, kSmiTagSize + 1));
-  __ sub(mask, mask, Operand(1));  // Make mask.
+  STATIC_ASSERT(Heap::kNSCSlotsPerEntry == 3);
+  // Multiply mask by 2/3, making it a power of 2.
+  __ and_(mask, mask, Operand(mask, LSL, 1));
+  // 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, mask, Operand(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.
   Isolate* isolate = masm->isolate();
   Label is_smi;
   Label load_result_from_cache;
+  const int kNumberOffset =
+      FixedArray::kHeaderSize + kPointerSize * Heap::kNSCNumberOffset;
+  const int kStringOffset =
+      FixedArray::kHeaderSize + kPointerSize * Heap::kNSCStringOffset;
+  const int kAgeOffset =
+      FixedArray::kHeaderSize + kPointerSize * Heap::kNSCAgeOffset;
   if (!object_is_smi) {
     __ JumpIfSmi(object, &is_smi);
     if (CpuFeatures::IsSupported(VFP3)) {
       CpuFeatures::Scope scope(VFP3);
       __ CheckMap(object,
                   scratch1,
                   Heap::kHeapNumberMapRootIndex,
                   not_found,
                   DONT_DO_SMI_CHECK);
 
       STATIC_ASSERT(8 == kDoubleSize);
       __ add(scratch1,
              object,
              Operand(HeapNumber::kValueOffset - kHeapObjectTag));
       __ ldm(ia, scratch1, scratch1.bit() | scratch2.bit());
       __ eor(scratch1, scratch1, Operand(scratch2));
-      __ and_(scratch1, scratch1, Operand(mask));
+      __ and_(scratch1, mask, Operand(scratch1, LSL, kPointerSizeLog2));
 
       // Calculate address of entry in string cache: each entry consists
-      // of two pointer sized fields.
-      __ add(scratch1,
-             number_string_cache,
-             Operand(scratch1, LSL, kPointerSizeLog2 + 1));
+      // of three pointer sized fields, so we multiply by 3.
+      __ add(scratch1, scratch1, Operand(scratch1, LSL, 1));
+      __ add(scratch1, scratch1, number_string_cache);
 
       Register probe = mask;
-      __ ldr(probe,
-             FieldMemOperand(scratch1, FixedArray::kHeaderSize));
+      __ ldr(probe, FieldMemOperand(scratch1, kNumberOffset));
       __ JumpIfSmi(probe, not_found);
       __ sub(scratch2, object, Operand(kHeapObjectTag));
       __ vldr(d0, scratch2, HeapNumber::kValueOffset);
       __ sub(probe, probe, Operand(kHeapObjectTag));
       __ vldr(d1, probe, HeapNumber::kValueOffset);
       __ VFPCompareAndSetFlags(d0, d1);
       __ b(ne, not_found);  // The cache did not contain this value.
       __ b(&load_result_from_cache);
     } else {
       __ b(not_found);
     }
   }
 
   __ bind(&is_smi);
-  Register scratch = scratch1;
-  __ and_(scratch, mask, Operand(object, ASR, 1));
+  STATIC_ASSERT(kSmiTag == 0);
+  __ and_(scratch1, mask, Operand(object, LSL, kPointerSizeLog2 - kSmiTagSize));
   // Calculate address of entry in string cache: each entry consists
-  // of two pointer sized fields.
-  __ add(scratch,
-         number_string_cache,
-         Operand(scratch, LSL, kPointerSizeLog2 + 1));
+  // of three pointer sized fields, so we multiply by 3.
+  __ add(scratch1, scratch1, Operand(scratch1, LSL, 1));
+  __ add(scratch1, scratch1, number_string_cache);
 
   // Check if the entry is the smi we are looking for.
   Register probe = mask;
-  __ ldr(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
+  __ ldr(probe, FieldMemOperand(scratch1, kNumberOffset));
   __ cmp(object, probe);
   __ b(ne, not_found);
 
   // Get the result from the cache.
   __ bind(&load_result_from_cache);
-  __ ldr(result,
-         FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));
+  __ mov(ip, Operand(Smi::FromInt(Heap::kNSCMinAge)));
+  __ str(ip, FieldMemOperand(scratch1, kAgeOffset));
+  __ ldr(result, FieldMemOperand(scratch1, kStringOffset));
   __ IncrementCounter(isolate->counters()->number_to_string_native(),
                       1,
                       scratch1,
                       scratch2);
 }
 
 
 void NumberToStringStub::Generate(MacroAssembler* masm) {
   Label runtime;
 
@@ skipping 5643 matching lines @@
 
   // Fall through when we need to inform the incremental marker.
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM