Inline NumberToString...

src/ia32/codegen-ia32.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 5609 matching lines @@
   Load(args->at(0));
   Load(args->at(1));
   Load(args->at(2));
   Load(args->at(3));
   RegExpExecStub stub;
   Result result = frame_->CallStub(&stub, 4);
   frame_->Push(&result);
 }
 
 
+void CodeGenerator::GenerateNumberToString(ZoneList<Expression*>* args) {
+  ASSERT_EQ(args->length(), 1);
+
+  // Load the argument on the stack and call the stub.
+  Load(args->at(0));
+  NumberToStringStub stub;
+  Result result = frame_->CallStub(&stub, 1);
+  frame_->Push(&result);
+}
+
+
 void CodeGenerator::VisitCallRuntime(CallRuntime* node) {
   if (CheckForInlineRuntimeCall(node)) {
     return;
   }
 
   ZoneList<Expression*>* args = node->arguments();
   Comment cmnt(masm_, "[ CallRuntime");
   Runtime::Function* function = node->function();
 
   if (function == NULL) {
@@ skipping 2135 matching lines @@
       __ CmpObjectType(eax, FIRST_NONSTRING_TYPE, ecx);
       __ j(above_equal, &string1);
 
       // First and second argument are strings. Jump to the string add stub.
       StringAddStub string_add_stub(NO_STRING_CHECK_IN_STUB);
       __ TailCallStub(&string_add_stub);
 
       __ bind(&string1_smi2);
       // First argument is a string, second is a smi. Try to lookup the number
       // string for the smi in the number string cache.
-      // Load the number string cache.
-      ExternalReference roots_address = ExternalReference::roots_address();
-      __ mov(ecx, Immediate(Heap::kNumberStringCacheRootIndex));
-      __ mov(ebx,
-             Operand::StaticArray(ecx, 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.
-      __ mov(ecx, FieldOperand(ebx, FixedArray::kLengthOffset));
-      __ shr(ecx, 1);  // Divide length by two (length is not a smi).
-      __ sub(Operand(ecx), Immediate(1));  // Make mask.
-      // Calculate the entry in the number string cache. The hash value in the
-      // number string cache for smis is just the smi value.
-      __ mov(edi, eax);
-      __ SmiUntag(edi);
-      __ and_(edi, Operand(ecx));
-      // Check if the entry is the smi we are looking for.
-      __ cmp(eax,
-             FieldOperand(ebx,
-                          edi,
-                          times_twice_pointer_size,
-                          FixedArray::kHeaderSize));
-      __ IncrementCounter(equal, &Counters::string_plus_smi_hit, 1);
-      __ IncrementCounter(not_equal, &Counters::string_plus_smi_miss, 1);
-      __ j(not_equal, &string1);
+      NumberToStringStub::GenerateLookupNumberStringCache(
+          masm, eax, edi, ebx, ecx, true, &string1);
 
-      // Get the string from the cache and call the string add stub to make the
-      // result.
-      __ mov(edi,
-             FieldOperand(ebx,
-                          edi,
-                          times_twice_pointer_size,
-                          FixedArray::kHeaderSize + kPointerSize));
+      // Call the string add stub to make the result.
       __ EnterInternalFrame();
       __ push(edx);  // Original first argument.
       __ push(edi);  // Number to string result for second argument.
       __ CallStub(&string_add_stub);
       __ LeaveInternalFrame();
       __ ret(2 * kPointerSize);
 
       __ bind(&string1);
       __ InvokeBuiltin(
           HasArgsReversed() ?
@@ skipping 1117 matching lines @@
   __ mov(eax, Operand(esp, kLastMatchInfoOffset));
   __ ret(4 * kPointerSize);
 
   // Do the runtime call to execute the regexp.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kRegExpExec), 4, 1);
 #endif  // V8_NATIVE_REGEXP
 }
 
 
+void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
+                                                         Register object,
+                                                         Register result,
+                                                         Register scratch1,
+                                                         Register scratch2,
+                                                         bool object_is_smi,
+                                                         Label* not_found) {
+  // Currently only lookup for smis. Check for smi if object is not known to be
+  // a smi.
+  if (!object_is_smi) {
+    ASSERT(kSmiTag == 0);
+    __ test(object, Immediate(kSmiTagMask));
+    __ j(not_zero, 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.
+  ExternalReference roots_address = ExternalReference::roots_address();
+  __ 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.
+  __ mov(mask, FieldOperand(number_string_cache, FixedArray::kLengthOffset));
+  __ shr(mask, 1);  // Divide length by two (length is not a smi).
+  __ sub(Operand(mask), Immediate(1));  // Make mask.
+  // Calculate the entry in the number string cache. The hash value in the
+  // number string cache for smis is just the smi value.
+  __ mov(scratch, object);
+  __ SmiUntag(scratch);
+  __ and_(scratch, Operand(mask));
+  // Check if the entry is the smi we are looking for.
+  __ cmp(object,
+         FieldOperand(number_string_cache,
+                      scratch,
+                      times_twice_pointer_size,
+                      FixedArray::kHeaderSize));
+  __ j(not_equal, not_found);
+
+  // Get the result from the cache.
+  __ mov(result,
+         FieldOperand(number_string_cache,
+                      scratch,
+                      times_twice_pointer_size,
+                      FixedArray::kHeaderSize + kPointerSize));
+  __ IncrementCounter(&Counters::number_to_string_native, 1);
+}
+
+
+void NumberToStringStub::Generate(MacroAssembler* masm) {
+  Label runtime;
+
+  __ mov(ebx, Operand(esp, kPointerSize));
+
+  // Generate code to lookup number in the number string cache.
+  GenerateLookupNumberStringCache(masm, ebx, eax, ebx, ecx, false, &runtime);
+  __ ret(1 * kPointerSize);
+
+  __ bind(&runtime);
+  // Handle number to string in the runtime system if not found in the cache.
+  __ TailCallRuntime(ExternalReference(Runtime::kNumberToString), 1, 1);
+}
+
+
 void CompareStub::Generate(MacroAssembler* masm) {
   Label call_builtin, done;
 
   // NOTICE! This code is only reached after a smi-fast-case check, so
   // it is certain that at least one operand isn't a smi.
 
   if (cc_ == equal) {  // Both strict and non-strict.
     Label slow;  // Fallthrough label.
     // Equality is almost reflexive (everything but NaN), so start by testing
     // for "identity and not NaN".
@@ skipping 1582 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(ExternalReference(Runtime::kStringCompare), 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal