A64: Synchronize with r16756.

src/a64/stub-cache-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 314 matching lines @@
 
 
 // Generate code to load the length from a string object and return the length.
 // If the receiver object is not a string or a wrapped string object the
 // execution continues at the miss label. The register containing the
 // receiver is not clobbered if the receiver is not a string.
 void StubCompiler::GenerateLoadStringLength(MacroAssembler* masm,
                                             Register receiver,
                                             Register scratch1,
                                             Register scratch2,
-                                            Label* miss,
-                                            bool support_wrappers) {
+                                            Label* miss) {
   // Input registers can't alias because we don't want to clobber the
   // receiver register if the object is not a string.
   ASSERT(!AreAliased(receiver, scratch1, scratch2));
 
   Label check_wrapper;
 
   // Check if the object is a string leaving the instance type in the
   // scratch1 register.
-  GenerateStringCheck(masm, receiver, scratch1, miss,
-                      support_wrappers ? &check_wrapper : miss);
+  GenerateStringCheck(masm, receiver, scratch1, miss, &check_wrapper);
 
   // Load length directly from the string.
   __ Ldr(x0, FieldMemOperand(receiver, String::kLengthOffset));
   __ Ret();
 
-  if (support_wrappers) {
-    // Check if the object is a JSValue wrapper.
-    __ Bind(&check_wrapper);
-    __ Cmp(scratch1, Operand(JS_VALUE_TYPE));
-    __ B(ne, miss);
+  // Check if the object is a JSValue wrapper.
+  __ Bind(&check_wrapper);
+  __ Cmp(scratch1, Operand(JS_VALUE_TYPE));
+  __ B(ne, miss);
 
-    // Unwrap the value and check if the wrapped value is a string.
-    __ Ldr(scratch1, FieldMemOperand(receiver, JSValue::kValueOffset));
-    GenerateStringCheck(masm, scratch1, scratch2, miss, miss);
-    __ Ldr(x0, FieldMemOperand(scratch1, String::kLengthOffset));
-    __ Ret();
-  }
+  // Unwrap the value and check if the wrapped value is a string.
+  __ Ldr(scratch1, FieldMemOperand(receiver, JSValue::kValueOffset));
+  GenerateStringCheck(masm, scratch1, scratch2, miss, miss);
+  __ Ldr(x0, FieldMemOperand(scratch1, String::kLengthOffset));
+  __ Ret();
 }
 
 
 void StubCompiler::GenerateLoadFunctionPrototype(MacroAssembler* masm,
                                                  Register receiver,
                                                  Register scratch1,
                                                  Register scratch2,
                                                  Label* miss_label) {
   __ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);
   // TryGetFunctionPrototype can't put the result directly in x0 because the
@@ skipping 402 matching lines @@
   __ InvokeFunction(
       function, arguments, JUMP_FUNCTION, NullCallWrapper(), call_kind);
 }
 
 
 static void PushInterceptorArguments(MacroAssembler* masm,
                                      Register receiver,
                                      Register holder,
                                      Register name,
                                      Handle<JSObject> holder_obj) {
+  STATIC_ASSERT(StubCache::kInterceptorArgsNameIndex == 0);
+  STATIC_ASSERT(StubCache::kInterceptorArgsInfoIndex == 1);
+  STATIC_ASSERT(StubCache::kInterceptorArgsThisIndex == 2);
+  STATIC_ASSERT(StubCache::kInterceptorArgsHolderIndex == 3);
+  STATIC_ASSERT(StubCache::kInterceptorArgsLength == 4);
+
   __ Push(name);
   Handle<InterceptorInfo> interceptor(holder_obj->GetNamedInterceptor());
   ASSERT(!masm->isolate()->heap()->InNewSpace(*interceptor));
   Register scratch = name;
   __ Mov(scratch, Operand(interceptor));
   __ Push(scratch, receiver, holder);
-  __ Ldr(scratch, FieldMemOperand(scratch, InterceptorInfo::kDataOffset));
-  __ Push(scratch);
-  __ Mov(scratch, Operand(ExternalReference::isolate_address(masm->isolate())));
-  __ Push(scratch);
 }
 
 
 static void CompileCallLoadPropertyWithInterceptor(
     MacroAssembler* masm,
     Register receiver,
     Register holder,
     Register name,
     Handle<JSObject> holder_obj) {
   PushInterceptorArguments(masm, receiver, holder, name, holder_obj);
 
   ExternalReference ref =
       ExternalReference(IC_Utility(IC::kLoadPropertyWithInterceptorOnly),
                         masm->isolate());
   // Put the number of on-stack arguments for runtime call in x0.
   // These arguemnts have been pushed by PushInterceptorArguments.
-  __ Mov(x0, 6);
+  __ Mov(x0, StubCache::kInterceptorArgsLength);
   __ Mov(x1, Operand(ref));
 
   CEntryStub stub(1);
   __ CallStub(&stub);
 }
 
 
 static const int kFastApiCallArguments = FunctionCallbackArguments::kArgsLength;
 
 // Reserves space for the extra arguments to API function in the
@@ skipping 304 matching lines @@
                                         name, miss_label);
 
     // Call a runtime function to load the interceptor property.
     FrameScope scope(masm, StackFrame::INTERNAL);
     // The name_ register must be preserved across the call.
     __ Push(name_);
     PushInterceptorArguments(masm, receiver, holder, name_, interceptor_holder);
     __ CallExternalReference(
         ExternalReference(IC_Utility(IC::kLoadPropertyWithInterceptorForCall),
                           masm->isolate()),
-        6);
+        StubCache::kInterceptorArgsLength);
     __ Pop(name_);
   }
 
 
   void LoadWithInterceptor(MacroAssembler* masm,
                            Register receiver,
                            Register holder,
                            Handle<JSObject> holder_obj,
                            Register scratch,
                            Label* interceptor_succeeded) {
@@ skipping 269 matching lines @@
 void BaseLoadStubCompiler::GenerateLoadCallback(
     const CallOptimization& call_optimization) {
   GenerateFastApiCall(
       masm(), call_optimization, receiver(), scratch3(), 0, NULL);
 }
 
 
 void BaseLoadStubCompiler::GenerateLoadCallback(
     Register reg,
     Handle<ExecutableAccessorInfo> callback) {
+  ASSERT(!AreAliased(scratch2(), scratch3(), scratch4(), reg));
+
   // Build ExecutableAccessorInfo::args_ list on the stack and push property
   // name below the exit frame to make GC aware of them and store pointers to
   // them.
+  STATIC_ASSERT(PropertyCallbackArguments::kThisIndex == 0);
+  STATIC_ASSERT(PropertyCallbackArguments::kDataIndex == -1);
+  STATIC_ASSERT(PropertyCallbackArguments::kReturnValueOffset == -2);
+  STATIC_ASSERT(PropertyCallbackArguments::kReturnValueDefaultValueIndex == -3);
+  STATIC_ASSERT(PropertyCallbackArguments::kIsolateIndex == -4);
+  STATIC_ASSERT(PropertyCallbackArguments::kHolderIndex == -5);
+
   __ Push(receiver());
   Register args_addr = scratch2();
   __ Mov(args_addr, __ StackPointer());
 
   if (heap()->InNewSpace(callback->data())) {
     __ Mov(scratch3(), Operand(callback));
     __ Ldr(scratch3(), FieldMemOperand(scratch3(),
                                        ExecutableAccessorInfo::kDataOffset));
   } else {
     __ Mov(scratch3(), Operand(Handle<Object>(callback->data(), isolate())));
   }
   // TODO(jbramley): Find another scratch register and combine the pushes
-  // together. Can we use scratch1() and scratch2() here?
-  __ Push(reg, scratch3());
-  __ LoadRoot(scratch3(), Heap::kUndefinedValueRootIndex);
-  __ Mov(scratch4(), Operand(ExternalReference::isolate_address(isolate())));
-  __ Push(scratch3(), scratch3(), scratch4(), name());
+  // together. Can we use scratch1() here?
+  // Push:
+  //   - callback data
+  //   - undefined
+  //   - undefined
+  //   - isolate
+  //   - reg
+  //   - name
+  __ LoadRoot(scratch4(), Heap::kUndefinedValueRootIndex);
+  __ Push(scratch3(), scratch4());
+  __ Mov(scratch3(), Operand(ExternalReference::isolate_address(isolate())));
+  __ Push(scratch4(), scratch3(), reg, name());
 
   // Pass the Handle<Name> of the property name to the runtime.
   __ Mov(x0, __ StackPointer());
 
   FrameScope frame_scope(masm(), StackFrame::MANUAL);
   const int kApiStackSpace = 1;
   __ EnterExitFrame(false, scratch4(),
       kApiStackSpace + MacroAssembler::kCallApiFunctionSpillSpace);
 
   // Create ExecutableAccessorInfo instance on the stack above the exit frame
@@ skipping 26 matching lines @@
   ApiFunction fun(getter_address);
   ExternalReference::Type type = ExternalReference::DIRECT_GETTER_CALL;
   ExternalReference ref = ExternalReference(&fun, type, isolate());
 
   Address thunk_address = FUNCTION_ADDR(&InvokeAccessorGetterCallback);
   ExternalReference::Type thunk_type = ExternalReference::PROFILING_GETTER_CALL;
   ApiFunction thunk_fun(thunk_address);
   ExternalReference thunk_ref =
       ExternalReference(&thunk_fun, thunk_type, isolate());
 
-  // TODO(jbramley): I don't know where '5' comes from, but this goes away at
+  // TODO(jbramley): I don't know where '6' comes from, but this goes away at
   // some point.
   __ CallApiFunctionAndReturn(ref,
                               getter_address,
                               thunk_ref,
                               x2,
                               kStackUnwindSpace,
                               spill_offset,
-                              5);
+                              6);
 }
 
 
 void BaseLoadStubCompiler::GenerateLoadInterceptor(
     Register holder_reg,
     Handle<JSObject> object,
     Handle<JSObject> interceptor_holder,
     LookupResult* lookup,
     Handle<Name> name) {
   ASSERT(!AreAliased(receiver(), this->name(),
@@ skipping 67 matching lines @@
     GenerateLoadPostInterceptor(holder_reg, interceptor_holder, name, lookup);
   } else {  // !compile_followup_inline
     // Call the runtime system to load the interceptor.
     // Check that the maps haven't changed.
     PushInterceptorArguments(
         masm(), receiver(), holder_reg, this->name(), interceptor_holder);
 
     ExternalReference ref =
         ExternalReference(IC_Utility(IC::kLoadPropertyWithInterceptorForLoad),
                           isolate());
-    __ TailCallExternalReference(ref, 6, 1);
+    __ TailCallExternalReference(ref, StubCache::kInterceptorArgsLength, 1);
   }
 }
 
 
 void CallStubCompiler::GenerateNameCheck(Handle<Name> name, Label* miss) {
   Register name_reg = x2;
 
   if (kind_ == Code::KEYED_CALL_IC) {
     __ Cmp(name_reg, Operand(name));
     __ B(ne, miss);
@@ skipping 1639 matching lines @@
 
   // Miss case, call the runtime.
   __ Bind(&miss_force_generic);
   TailCallBuiltin(masm, Builtins::kKeyedLoadIC_MissForceGeneric);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64