A64: Synchronize with r15204.

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 403 matching lines @@
 
 // Generate code to check that a global property cell is empty. Create
 // the property cell at compilation time if no cell exists for the
 // property.
 static void GenerateCheckPropertyCell(MacroAssembler* masm,
                                       Handle<GlobalObject> global,
                                       Handle<Name> name,
                                       Register scratch,
                                       Register the_hole,
                                       Label* miss) {
-  Handle<JSGlobalPropertyCell> cell =
-      GlobalObject::EnsurePropertyCell(global, name);
+  Handle<Cell> cell = GlobalObject::EnsurePropertyCell(global, name);
   ASSERT(cell->value()->IsTheHole());
   __ Mov(scratch, Operand(cell));
-  __ Ldr(scratch,
-         FieldMemOperand(scratch, JSGlobalPropertyCell::kValueOffset));
+  __ Ldr(scratch, FieldMemOperand(scratch, Cell::kValueOffset));
   __ Cmp(scratch, the_hole);
   __ B(ne, miss);
 }
 
 
 // Generate StoreTransition code, value is passed in x0 register.
 // When leaving generated code after success, the receiver_reg and name_reg may
 // be clobbered. Upon branch to miss_label, the receiver and name registers have
 // their original values.
 void StubCompiler::GenerateStoreTransition(MacroAssembler* masm,
@@ skipping 69 matching lines @@
         GenerateDictionaryNegativeLookup(
             masm, miss_restore_name, holder_reg, name, scratch1, scratch2);
       }
     }
   }
 
   // We've possibly already clobbered name_reg at this point, so use it for
   // storage_reg.
   Register storage_reg = name_reg;
 
-  if (FLAG_track_fields && representation.IsSmi()) {
+  if (details.type() == CONSTANT_FUNCTION) {
+    Handle<HeapObject> constant(
+        HeapObject::cast(descriptors->GetValue(descriptor)));
+    __ LoadHeapObject(scratch1, constant);
+    __ Cmp(value_reg, scratch1);
+    __ B(ne, miss_restore_name);
+  } else if (FLAG_track_fields && representation.IsSmi()) {
     __ JumpIfNotSmi(value_reg, miss_restore_name);
   } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) {
     __ JumpIfSmi(value_reg, miss_restore_name);
   } else if (FLAG_track_double_fields && representation.IsDouble()) {
     Label do_store, heap_number;
     __ AllocateHeapNumber(storage_reg, slow, scratch1, scratch2);
 
     // TODO(jbramley): Is fp_scratch the most appropriate FP scratch register?
     // It's only used in Fcmp, but it's not really safe to use it like this.
     __ JumpIfNotSmi(value_reg, &heap_number);
     __ SmiUntagToDouble(fp_scratch, value_reg);
     __ B(&do_store);
 
     __ Bind(&heap_number);
     __ CheckMap(value_reg, scratch1, Heap::kHeapNumberMapRootIndex,
                 miss_restore_name, DONT_DO_SMI_CHECK);
     __ Ldr(fp_scratch, FieldMemOperand(value_reg, HeapNumber::kValueOffset));
 
     __ Bind(&do_store);
     __ Str(fp_scratch, FieldMemOperand(storage_reg, HeapNumber::kValueOffset));
   }
 
   // Stub never generated for non-global objects that require access checks.
   ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());
 
   // Perform map transition for the receiver if necessary.
-  if (object->map()->unused_property_fields() == 0) {
+  if ((details.type() == FIELD) &&
+      (object->map()->unused_property_fields() == 0)) {
     // The properties must be extended before we can store the value.
     // We jump to a runtime call that extends the properties array.
     __ Mov(scratch1, Operand(transition));
     __ Push(receiver_reg, scratch1, value_reg);
     __ TailCallExternalReference(
         ExternalReference(IC_Utility(IC::kSharedStoreIC_ExtendStorage),
                           masm->isolate()),
         3,
         1);
     return;
   }
 
   // Update the map of the object.
   __ Mov(scratch1, Operand(transition));
   __ Str(scratch1, FieldMemOperand(receiver_reg, HeapObject::kMapOffset));
 
   // Update the write barrier for the map field and pass the now unused
   // name_reg as scratch register.
   __ RecordWriteField(receiver_reg,
                       HeapObject::kMapOffset,
                       scratch1,
                       scratch2,
                       kLRHasNotBeenSaved,
                       kDontSaveFPRegs,
                       OMIT_REMEMBERED_SET,
                       OMIT_SMI_CHECK);
+
+  if (details.type() == CONSTANT_FUNCTION) {
+    ASSERT(value_reg.is(x0));
+    __ Ret();
+    return;
+  }
+
   int index = transition->instance_descriptors()->GetFieldIndex(
       transition->LastAdded());
 
   // Adjust for the number of properties stored in the object. Even in the
   // face of a transition we can use the old map here because the size of the
   // object and the number of in-object properties is not going to change.
   index -= object->map()->inobject_properties();
 
   // TODO(verwaest): Share this code as a code stub.
   SmiCheck smi_check = representation.IsTagged()
@@ skipping 418 matching lines @@
 
   Address function_address = v8::ToCData<Address>(api_call_info->callback());
   bool returns_handle =
       !CallbackTable::ReturnsVoid(masm->isolate(), function_address);
   ApiFunction fun(function_address);
   ExternalReference::Type type =
       returns_handle ?
           ExternalReference::DIRECT_API_CALL :
           ExternalReference::DIRECT_API_CALL_NEW;
   ExternalReference ref = ExternalReference(&fun, type, masm->isolate());
+
+  Address thunk_address =
+      returns_handle ?
+          FUNCTION_ADDR(&InvokeInvocationCallback) :
+          FUNCTION_ADDR(&InvokeFunctionCallback);
+  ExternalReference::Type thunk_type =
+      returns_handle ?
+          ExternalReference::PROFILING_API_CALL :
+          ExternalReference::PROFILING_API_CALL_NEW;
+  ApiFunction thunk_fun(thunk_address);
+  ExternalReference thunk_ref =
+      ExternalReference(&thunk_fun, thunk_type, masm->isolate());
+
   AllowExternalCallThatCantCauseGC scope(masm);
   // CallApiFunctionAndReturn can spill registers inside the exit frame,
   // after the return address and the v8::Arguments structure.
   const int spill_offset = 1 + kApiArgsStackSpace;
   __ CallApiFunctionAndReturn(ref,
+                              function_address,
+                              thunk_ref,
+                              x1,
                               kStackUnwindSpace,
                               spill_offset,
                               returns_handle,
                               kFastApiCallArguments + 1);
 }
 
 
 class CallInterceptorCompiler BASE_EMBEDDED {
  public:
   CallInterceptorCompiler(StubCompiler* stub_compiler,
@@ skipping 469 matching lines @@
   //  - the property name
   //  - the receiver.
   //
   // The memory allocated inside the ExitFrame will be freed when we'll leave
   // the ExitFrame in CallApiFunctionAndReturn.
   const int kStackUnwindSpace = kFastApiCallArguments + 1;
 
   // Do the API call.
   Address getter_address = v8::ToCData<Address>(callback->getter());
   bool returns_handle = !CallbackTable::ReturnsVoid(isolate(), getter_address);
+
   ApiFunction fun(getter_address);
   ExternalReference::Type type =
       returns_handle ?
           ExternalReference::DIRECT_GETTER_CALL :
           ExternalReference::DIRECT_GETTER_CALL_NEW;
   ExternalReference ref = ExternalReference(&fun, type, isolate());
+
+  Address thunk_address = returns_handle
+      ? FUNCTION_ADDR(&InvokeAccessorGetter)
+      : FUNCTION_ADDR(&InvokeAccessorGetterCallback);
+  ExternalReference::Type thunk_type =
+      returns_handle ?
+          ExternalReference::PROFILING_GETTER_CALL :
+          ExternalReference::PROFILING_GETTER_CALL_NEW;
+  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
   // some point.
   __ CallApiFunctionAndReturn(ref,
+                              getter_address,
+                              thunk_ref,
+                              x2,
                               kStackUnwindSpace,
                               spill_offset,
                               returns_handle,
                               5);
 }
 
 
 void BaseLoadStubCompiler::GenerateLoadInterceptor(
     Register holder_reg,
     Handle<JSObject> object,
@@ skipping 107 matching lines @@
   __ Peek(receiver, argc * kPointerSize);
 
   // Check that the maps haven't changed.
   __ JumpIfSmi(receiver, miss);
   CheckPrototypes(object, receiver, holder, x3, x1, x4, name, miss);
 }
 
 
 // Load the function object into x1 register.
 void CallStubCompiler::GenerateLoadFunctionFromCell(
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
     Label* miss) {
   // Get the value from the cell.
   __ Mov(x3, Operand(cell));
   Register function_reg = x1;
-  __ Ldr(function_reg, FieldMemOperand(x3, JSGlobalPropertyCell::kValueOffset));
+  __ Ldr(function_reg, FieldMemOperand(x3, Cell::kValueOffset));
 
   // Check that the cell contains the same function.
   if (heap()->InNewSpace(*function)) {
     // We can't embed a pointer to a function in new space so we have
     // to verify that the shared function info is unchanged. This has
     // the nice side effect that multiple closures based on the same
     // function can all use this call IC. Before we load through the
     // function, we have to verify that it still is a function.
     __ JumpIfSmi(function_reg, miss);
     __ JumpIfNotObjectType(function_reg, x3, x3, JS_FUNCTION_TYPE, miss);
@@ skipping 52 matching lines @@
 
   // Handle call cache miss.
   __ Bind(&miss);
   GenerateMissBranch();
 
   // Return the generated code.
   return GetCode(Code::FIELD, name);
 }
 
 
+Handle<Code> CallStubCompiler::CompileArrayCodeCall(
+    Handle<Object> object,
+    Handle<JSObject> holder,
+    Handle<Cell> cell,
+    Handle<JSFunction> function,
+    Handle<String> name,
+    Code::StubType type) {
+  // ----------- S t a t e -------------
+  //  -- x2    : name
+  //  -- lr    : return address
+  //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
+  //  -- ...
+  //  -- sp[argc * 8]           : receiver
+  // -----------------------------------
+  Label miss;
+
+  // Check that function is still array.
+  const int argc = arguments().immediate();
+  GenerateNameCheck(name, &miss);
+
+  Register receiver = x1;
+  if (cell.is_null()) {
+    __ Peek(receiver, argc * kPointerSize);
+
+    // Check that the receiver isn't a smi.
+    __ JumpIfSmi(receiver, &miss);
+
+    // Check that the maps haven't changed.
+    CheckPrototypes(Handle<JSObject>::cast(object), receiver, holder, x3, x0,
+                    x4, name, &miss);
+  } else {
+    ASSERT(cell->value() == *function);
+    GenerateGlobalReceiverCheck(Handle<JSObject>::cast(object), holder, name,
+                                &miss);
+    GenerateLoadFunctionFromCell(cell, function, &miss);
+  }
+
+  Handle<Smi> kind(Smi::FromInt(GetInitialFastElementsKind()), isolate());
+  Handle<Cell> kind_feedback_cell = isolate()->factory()->NewCell(kind);
+  __ Mov(x0, argc);
+  __ Mov(x1, Operand(function));
+  __ Mov(x2, Operand(kind_feedback_cell));
+
+  ArrayConstructorStub stub(isolate());
+  __ TailCallStub(&stub);
+
+  __ Bind(&miss);
+  GenerateMissBranch();
+
+  // Return the generated code.
+  return GetCode(type, name);
+}
+
+
 Handle<Code> CallStubCompiler::CompileArrayPushCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2    : name (Must be preserved on miss.)
   //  -- lr    : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // If object is not an array, bail out to regular call.
   if (!object->IsJSArray() || !cell.is_null()) return Handle<Code>::null();
@@ skipping 239 matching lines @@
     __ Bind(&call_builtin);
     __ TailCallExternalReference(
         ExternalReference(Builtins::c_ArrayPush, isolate()), argc + 1, 1);
   }
 
   // Handle call cache miss.
   __ Bind(&miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return GetCode(function);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileArrayPopCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2    : name
   //  -- lr    : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // If object is not an array, bail out to regular call.
   if (!object->IsJSArray() || !cell.is_null()) return Handle<Code>::null();
@@ skipping 54 matching lines @@
 
   __ Bind(&call_builtin);
   __ TailCallExternalReference(
       ExternalReference(Builtins::c_ArrayPop, isolate()), argc + 1, 1);
 
   // Handle call cache miss.
   __ Bind(&miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return GetCode(function);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileStringCharCodeAtCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2                     : function name
   //  -- lr                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // If object is not a string, bail out to regular call.
   if (!object->IsString() || !cell.is_null()) return Handle<Code>::null();
@@ skipping 54 matching lines @@
     __ Ret();
   }
 
   __ Bind(&miss);
   // Restore function name in x2.
   __ Mov(x2, Operand(name));
   __ Bind(&name_miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return GetCode(function);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileStringCharAtCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2                     : function name
   //  -- lr                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   // If object is not a string, bail out to regular call.
   if (!object->IsString() || !cell.is_null()) return Handle<Code>::null();
@@ skipping 56 matching lines @@
     __ Ret();
   }
 
   __ Bind(&miss);
   // Restore function name in x2.
   __ Mov(x2, Operand(name));
   __ Bind(&name_miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return GetCode(function);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileStringFromCharCodeCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2                     : function name
   //  -- lr                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
   const int argc = arguments().immediate();
 
   // If the object is not a JSObject or we got an unexpected number of
@@ skipping 41 matching lines @@
   // because the function makes no use of it.
   __ Bind(&slow);
   ParameterCount expected(function);
   __ InvokeFunction(function, expected, arguments(),
                     JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
 
   __ Bind(&miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return cell.is_null() ? GetCode(function) : GetCode(Code::NORMAL, name);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileMathFloorCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2                     : function name (must be preserved on miss)
   //  -- lr                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
   Label miss;
   Label return_result;
   Register result = x0;
@@ skipping 85 matching lines @@
   // Tail call the full function. We do not have to patch the receiver
   // because the function makes no use of it.
   ParameterCount expected(function);
   __ InvokeFunction(function, expected, arguments(),
                     JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
 
   __ Bind(&miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return cell.is_null() ? GetCode(function) : GetCode(Code::NORMAL, name);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileMathAbsCall(
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
-    Handle<String> name) {
+    Handle<String> name,
+    Code::StubType type) {
   // ----------- S t a t e -------------
   //  -- x2                     : function name
   //  -- lr                     : return address
   //  -- sp[(argc - n - 1) * 8] : arg[n] (zero-based)
   //  -- ...
   //  -- sp[argc * 8]           : receiver
   // -----------------------------------
 
   const int argc = arguments().immediate();
 
@@ skipping 56 matching lines @@
   // because the function makes no use of it.
   __ Bind(&slow);
   ParameterCount expected(function);
   __ InvokeFunction(function, expected, arguments(),
                     JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
 
   __ Bind(&miss);
   GenerateMissBranch();
 
   // Return the generated code.
-  return cell.is_null() ? GetCode(function) : GetCode(Code::NORMAL, name);
+  return GetCode(type, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileFastApiCall(
     const CallOptimization& optimization,
     Handle<Object> object,
     Handle<JSObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<Cell> cell,
     Handle<JSFunction> function,
     Handle<String> name) {
   Counters* counters = isolate()->counters();
 
   ASSERT(optimization.is_simple_api_call());
   // Bail out if object is a global object as we don't want to
   // repatch it to global receiver.
   if (object->IsGlobalObject()) return Handle<Code>::null();
   if (!cell.is_null()) return Handle<Code>::null();
   if (!object->IsJSObject()) return Handle<Code>::null();
@@ skipping 154 matching lines @@
 
 
 Handle<Code> CallStubCompiler::CompileCallConstant(
     Handle<Object> object,
     Handle<JSObject> holder,
     Handle<Name> name,
     CheckType check,
     Handle<JSFunction> function) {
   if (HasCustomCallGenerator(function)) {
     Handle<Code> code = CompileCustomCall(object, holder,
-                                          Handle<JSGlobalPropertyCell>::null(),
-                                          function, Handle<String>::cast(name));
+                                          Handle<Cell>::null(),
+                                          function, Handle<String>::cast(name),
+                                          Code::CONSTANT_FUNCTION);
     // A null handle means bail out to the regular compiler code below.
     if (!code.is_null()) return code;
   }
 
   Label success;
 
   CompileHandlerFrontend(object, holder, name, check, &success);
   __ Bind(&success);
   CompileHandlerBackend(function);
 
@@ skipping 42 matching lines @@
   GenerateMissBranch();
 
   // Return the generated code.
   return GetCode(Code::INTERCEPTOR, name);
 }
 
 
 Handle<Code> CallStubCompiler::CompileCallGlobal(
     Handle<JSObject> object,
     Handle<GlobalObject> holder,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<PropertyCell> cell,
     Handle<JSFunction> function,
     Handle<Name> name) {
   // ----------- S t a t e -------------
   //  -- x2    : name
   //  -- lr    : return address
   // -----------------------------------
   if (HasCustomCallGenerator(function)) {
     Handle<Code> code = CompileCustomCall(
-        object, holder, cell, function, Handle<String>::cast(name));
+        object, holder, cell, function, Handle<String>::cast(name),
+        Code::NORMAL);
     // A null handle means bail out to the regular compiler code below.
     if (!code.is_null()) return code;
   }
 
   Label miss;
   GenerateNameCheck(name, &miss);
 
   // Get the number of arguments.
   const int argc = arguments().immediate();
 
@@ skipping 152 matching lines @@
   __ Bind(&miss);
   TailCallBuiltin(masm(), MissBuiltin(kind()));
 
   // Return the generated code.
   return GetICCode(kind(), Code::INTERCEPTOR, name);
 }
 
 
 Handle<Code> StoreStubCompiler::CompileStoreGlobal(
     Handle<GlobalObject> object,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<PropertyCell> cell,
     Handle<Name> name) {
   Label miss;
 
   ASM_LOCATION("StoreStubCompiler::CompileStoreGlobal");
 
   // Check that the map of the global has not changed.
   __ Ldr(scratch1(), FieldMemOperand(receiver(), HeapObject::kMapOffset));
   __ Cmp(scratch1(), Operand(Handle<Map>(object->map())));
   __ B(ne, &miss);
 
   // Check that the value in the cell is not the hole. If it is, this
   // cell could have been deleted and reintroducing the global needs
   // to update the property details in the property dictionary of the
   // global object. We bail out to the runtime system to do that.
   __ Mov(scratch1(), Operand(cell));
   __ Ldr(scratch2(), FieldMemOperand(scratch1(),
-                                     JSGlobalPropertyCell::kValueOffset));
+                                     Cell::kValueOffset));
   __ JumpIfRoot(scratch2(), Heap::kTheHoleValueRootIndex, &miss);
 
   // Store the value in the cell.
   __ Str(value(), FieldMemOperand(scratch1(),
-                                  JSGlobalPropertyCell::kValueOffset));
+                                  Cell::kValueOffset));
   // Cells are always rescanned, so no write barrier here.
 
   Counters* counters = isolate()->counters();
   __ IncrementCounter(counters->named_store_global_inline(), 1,
                       scratch1(), scratch2());
   __ Ret();
 
   // Handle store cache miss.
   __ Bind(&miss);
   __ IncrementCounter(counters->named_store_global_inline_miss(), 1,
@@ skipping 106 matching lines @@
 }
 
 
 #undef __
 #define __ ACCESS_MASM(masm())
 
 
 Handle<Code> LoadStubCompiler::CompileLoadGlobal(
     Handle<JSObject> object,
     Handle<GlobalObject> global,
-    Handle<JSGlobalPropertyCell> cell,
+    Handle<PropertyCell> cell,
     Handle<Name> name,
     bool is_dont_delete) {
   Label success, miss;
 
   __ CheckMap(
       receiver(), scratch1(), Handle<Map>(object->map()), &miss, DO_SMI_CHECK);
   HandlerFrontendHeader(
       object, receiver(), Handle<JSObject>::cast(global), name, &miss);
 
   // Get the value from the cell.
   __ Mov(x3, Operand(cell));
-  __ Ldr(x4, FieldMemOperand(x3, JSGlobalPropertyCell::kValueOffset));
+  __ Ldr(x4, FieldMemOperand(x3, Cell::kValueOffset));
 
   // Check for deleted property if property can actually be deleted.
   if (!is_dont_delete) {
     __ JumpIfRoot(x4, Heap::kTheHoleValueRootIndex, &miss);
   }
 
   HandlerFrontendFooter(&success, &miss);
   __ bind(&success);
 
   Counters* counters = isolate()->counters();
@@ skipping 585 matching lines @@
   // ----------- S t a t e -------------
 
   GenerateStoreFastSmiOrDoubleElement(masm, is_js_array, FAST_DOUBLE_ELEMENTS,
                                       store_mode, true);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64