A64: Synchronize with r16849.

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 68 matching lines @@
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x3: object literals array
   // x2: object literal index
   // x1: constant properties
   // x0: object literal flags
   static Register registers[] = { x3, x2, x1, x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
-      Runtime::FunctionForId(Runtime::kCreateObjectLiteralShallow)->entry;
+      Runtime::FunctionForId(Runtime::kCreateObjectLiteral)->entry;
 }
 
 
 void CreateAllocationSiteStub::InitializeInterfaceDescriptor(
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x2: cache cell
   static Register registers[] = { x2 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
@@ skipping 2193 matching lines @@
 
   // The call succeeded, so unwind the stack and return.
 
   // Restore callee-saved registers x21-x23.
   __ Mov(x11, argc);
 
   __ Peek(argv, 1 * kPointerSize);
   __ Peek(argc, 2 * kPointerSize);
   __ Peek(target, 3 * kPointerSize);
 
-  __ LeaveExitFrame(save_doubles_, x10);
+  __ LeaveExitFrame(save_doubles_, x10, true);
   ASSERT(jssp.Is(__ StackPointer()));
   // Pop or drop the remaining stack slots and return from the stub.
   //         jssp[24]:    Arguments array (of size argc), including receiver.
   //         jssp[16]:    Preserved x23 (used for target).
   //         jssp[8]:     Preserved x22 (used for argc).
   //         jssp[0]:     Preserved x21 (used for argv).
   __ Drop(x11);
   __ Ret();
 
   // The stack pointer is still csp if we aren't returning, and the frame
@@ skipping 1500 matching lines @@
   __ Add(x6, x10, x11);
 
   // Argument 8 (x7): Indicate that this is a direct call from JavaScript.
   __ Mov(x7, 1);
 
   // Locate the code entry and call it.
   __ Add(code_object, code_object, Code::kHeaderSize - kHeapObjectTag);
   DirectCEntryStub stub;
   stub.GenerateCall(masm, code_object);
 
-  __ LeaveExitFrame(false, x10);
+  __ LeaveExitFrame(false, x10, true);
 
   // The generated regexp code returns an int32 in w0.
   Label failure, exception;
   __ CompareAndBranch(w0, NativeRegExpMacroAssembler::FAILURE, eq, &failure);
   __ CompareAndBranch(w0,
                       NativeRegExpMacroAssembler::EXCEPTION,
                       eq,
                       &exception);
   __ CompareAndBranch(w0, NativeRegExpMacroAssembler::RETRY, eq, &runtime);
 
@@ skipping 947 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::GenerateLookupNumberStringCache(MacroAssembler* masm,
-                                                         Register object,
-                                                         Register result,
-                                                         Register scratch1,
-                                                         Register scratch2,
-                                                         Register scratch3,
-                                                         Label* not_found) {
-  ASSERT(!AreAliased(object, result, scratch1, scratch2, scratch3));
-
-  // 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.
-  __ Ldrsw(mask, UntagSmiFieldMemOperand(number_string_cache,
-                                         FixedArray::kLengthOffset));
-  __ Asr(mask, mask, 1);  // Divide length by two.
-  __ Sub(mask, mask, 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, 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;
-
-  __ JumpIfSmi(object, &is_smi);
-  __ CheckMap(object, scratch1, Heap::kHeapNumberMapRootIndex, not_found,
-              DONT_DO_SMI_CHECK);
-
-  STATIC_ASSERT(kDoubleSize == (kWRegSizeInBytes * 2));
-  __ Add(scratch1, object, HeapNumber::kValueOffset - kHeapObjectTag);
-  __ Ldp(scratch1.W(), scratch2.W(), MemOperand(scratch1));
-  __ Eor(scratch1, scratch1, scratch2);
-  __ And(scratch1, scratch1, mask);
-
-  // 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));
-
-  Register probe = mask;
-  __ Ldr(probe, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
-  __ JumpIfSmi(probe, not_found);
-  __ Ldr(d0, FieldMemOperand(object, HeapNumber::kValueOffset));
-  __ Ldr(d1, FieldMemOperand(probe, HeapNumber::kValueOffset));
-  __ Fcmp(d0, d1);
-  __ B(ne, not_found);
-  __ B(&load_result_from_cache);
-
-  __ Bind(&is_smi);
-  Register scratch = scratch1;
-  __ And(scratch, mask, Operand::UntagSmi(object));
-  // 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));
-
-  // Check if the entry is the smi we are looking for.
-  __ Ldr(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
-  __ 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));
-  __ IncrementCounter(isolate->counters()->number_to_string_native(), 1,
-                      scratch1, scratch2);
-}
-
-
 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.
-  GenerateLookupNumberStringCache(masm, object, result, x2, x3, x4, &runtime);
+  __ 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,
@@ skipping 994 matching lines @@
   ASSERT(!AreAliased(arg, scratch1, scratch2, scratch3, scratch4));
 
   // First check if the argument is already a string.
   Label not_string, done;
   __ JumpIfSmi(arg, &not_string);
   __ JumpIfObjectType(arg, scratch1, scratch1, FIRST_NONSTRING_TYPE, &done, lt);
 
   // Check the number to string cache.
   __ Bind(&not_string);
   // Puts the cache result into scratch1.
-  NumberToStringStub::GenerateLookupNumberStringCache(
-      masm,
-      arg,
-      scratch1,
-      scratch2,
-      scratch3,
-      scratch4,
-      slow);
+  __ LookupNumberStringCache(arg, scratch1, scratch2, scratch3, scratch4, slow);
   __ Mov(arg, scratch1);
 
   __ Bind(&done);
 }
 
 
 void StringAddStub::GenerateRegisterArgsPush(MacroAssembler* masm) {
   __ Push(x0, x1);
 }
 
@@ skipping 1028 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64