A64: Synchronize with r16918.

src/a64/code-stubs-a64.cc

 // Copyright 2013 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 43 matching lines @@
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x0: value
   static Register registers[] = { x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ = NULL;
 }
 
 
+void NumberToStringStub::InitializeInterfaceDescriptor(
+    Isolate* isolate,
+    CodeStubInterfaceDescriptor* descriptor) {
+  // x0: value
+  static Register registers[] = { x0 };
+  descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
+  descriptor->register_params_ = registers;
+  descriptor->deoptimization_handler_ = NULL;
+}
+
+
 void FastCloneShallowArrayStub::InitializeInterfaceDescriptor(
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x3: array literals array
   // x2: array literal index
   // x1: constant elements
   static Register registers[] = { x3, x2, x1 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
@@ skipping 4031 matching lines @@
   __ Bind(&slow);
   __ Push(length_smi, index_smi, input);
   __ TailCallRuntime(Runtime::kRegExpConstructResult, 3, 1);
 }
 
 
 // TODO(jbramley): Don't use static registers here, but take them as arguments.
 static void GenerateRecordCallTarget(MacroAssembler* masm) {
   // Cache the called function in a global property cell. Cache states are
   // uninitialized, monomorphic (indicated by a JSFunction), and megamorphic.
+  //  x0 : number of arguments to the construct function
   //  x1 : the function to call
   //  x2 : cache cell for the call target
   Label initialize, done, miss, megamorphic, not_array_function;
 
   ASSERT_EQ(*TypeFeedbackCells::MegamorphicSentinel(masm->isolate()),
             masm->isolate()->heap()->undefined_value());
   ASSERT_EQ(*TypeFeedbackCells::UninitializedSentinel(masm->isolate()),
             masm->isolate()->heap()->the_hole_value());
 
   // Load the cache state.
@@ skipping 36 matching lines @@
   __ LoadArrayFunction(x3);
   __ Cmp(x1, x3);
   __ B(ne, &not_array_function);
 
   // The target function is the Array constructor,
   // Create an AllocationSite if we don't already have it, store it in the cell
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateAllocationSiteStub create_stub;
 
+    // Arguments register must be smi-tagged to call out.
     __ SmiTag(x0);
     __ Push(x0, x1, x2);
 
     __ CallStub(&create_stub);
 
     __ Pop(x2, x1, x0);
     __ SmiUntag(x0);
   }
   __ B(&done);
 
@@ skipping 601 matching lines @@
     __ Add(stub_entry, x0, Code::kHeaderSize - kHeapObjectTag);
     // Restore caller-saved registers.
     __ Pop(lr, x0, x1);
   }
 
   // Tail-call to the new stub.
   __ Jump(stub_entry);
 }
 
 
-void NumberToStringStub::Generate(MacroAssembler* masm) {
-  Register result = x0;
-  Register object = x1;
-  Label runtime;
-
-  __ Pop(object);
-
-  // Generate code to lookup number in the number string cache.
-  __ LookupNumberStringCache(object, result, x2, x3, x4, &runtime);
-  __ Ret();
-
-  // Handle number to string in the runtime system if not found in the cache.
-  __ Bind(&runtime);
-  __ Push(object);
-  __ TailCallRuntime(Runtime::kNumberToStringSkipCache, 1, 1);
-}
-
-
 void StringHelper::GenerateTwoCharacterStringTableProbe(MacroAssembler* masm,
                                                         Register c1,
                                                         Register c2,
                                                         Register scratch1,
                                                         Register scratch2,
                                                         Register scratch3,
                                                         Register scratch4,
                                                         Register scratch5,
                                                         Label* not_found) {
   ASSERT(!AreAliased(c1, c2, scratch1, scratch2, scratch3, scratch4, scratch5));
@@ skipping 2034 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64