A64: Synchronize with r15545.

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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
-#if defined(V8_TARGET_ARCH_A64)
+#if V8_TARGET_ARCH_A64
 
 #include "bootstrapper.h"
 #include "code-stubs.h"
 #include "regexp-macro-assembler.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 
@@ skipping 19 matching lines @@
   // 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;
 }
 
 
+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;
+  descriptor->deoptimization_handler_ = NULL;
+}
+
+
 void KeyedLoadFastElementStub::InitializeInterfaceDescriptor(
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x1: receiver
   // x0: key
   static Register registers[] = { x1, x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
       FUNCTION_ADDR(KeyedLoadIC_MissFromStubFailure);
@@ skipping 153 matching lines @@
   // x0: value
   static Register registers[] = { x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ = FUNCTION_ADDR(ToBooleanIC_Miss);
   descriptor->SetMissHandler(
       ExternalReference(IC_Utility(IC::kToBooleanIC_Miss), isolate));
 }
 
 
+void UnaryOpStub::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_ = FUNCTION_ADDR(UnaryOpIC_Miss);
+}
+
+
+void StoreGlobalStub::InitializeInterfaceDescriptor(
+    Isolate* isolate,
+    CodeStubInterfaceDescriptor* descriptor) {
+  // x1: receiver
+  // x2: key (unused)
+  // x0: value
+  static Register registers[] = { x1, x2, x0 };
+  descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
+  descriptor->register_params_ = registers;
+  descriptor->deoptimization_handler_ =
+      FUNCTION_ADDR(StoreIC_MissFromStubFailure);
+}
+
+
 #define __ ACCESS_MASM(masm)
 
 
 void HydrogenCodeStub::GenerateLightweightMiss(MacroAssembler* masm) {
   // Update the static counter each time a new code stub is generated.
   Isolate* isolate = masm->isolate();
   isolate->counters()->code_stubs()->Increment();
 
   CodeStubInterfaceDescriptor* descriptor = GetInterfaceDescriptor(isolate);
   int param_count = descriptor->register_param_count_;
@@ skipping 787 matching lines @@
   }
 
   // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ InvokeBuiltin(native, JUMP_FUNCTION);
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
 
+
 void StoreBufferOverflowStub::Generate(MacroAssembler* masm) {
   // Preserve caller-saved registers x0-x7 and x10-x15. We don't care if x8, x9,
   // ip0 and ip1 are corrupted by the call into C.
   CPURegList saved_regs = kCallerSaved;
   saved_regs.Remove(ip0);
   saved_regs.Remove(ip1);
   saved_regs.Remove(x8);
   saved_regs.Remove(x9);
 
   // We don't allow a GC during a store buffer overflow so there is no need to
@@ skipping 20 matching lines @@
 
 void StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(
     Isolate* isolate) {
   StoreBufferOverflowStub stub1(kDontSaveFPRegs);
   stub1.GetCode(isolate)->set_is_pregenerated(true);
   StoreBufferOverflowStub stub2(kSaveFPRegs);
   stub2.GetCode(isolate)->set_is_pregenerated(true);
 }
 
 
-void UnaryOpStub::PrintName(StringStream* stream) {
-  const char* op_name = Token::Name(op_);
-  const char* overwrite_name = NULL;
-  switch (mode_) {
-    case UNARY_NO_OVERWRITE:
-      overwrite_name = "Alloc";
-      break;
-    case UNARY_OVERWRITE:
-      overwrite_name = "Overwrite";
-      break;
-    default:
-      UNREACHABLE();
-  }
-  stream->Add("UnaryOpStub_%s_%s_%s",
-              op_name,
-              overwrite_name,
-              UnaryOpIC::GetName(operand_type_));
-}
-
-
-void UnaryOpStub::Generate(MacroAssembler* masm) {
-  switch (operand_type_) {
-    case UnaryOpIC::UNINITIALIZED:
-      GenerateTypeTransition(masm);
-      break;
-    case UnaryOpIC::SMI:
-      GenerateSmiStub(masm);
-      break;
-    case UnaryOpIC::NUMBER:
-      GenerateNumberStub(masm);
-      break;
-    case UnaryOpIC::GENERIC:
-      GenerateGenericStub(masm);
-      break;
-  }
-}
-
-
-void UnaryOpStub::GenerateTypeTransition(MacroAssembler* masm) {
-  __ Mov(x1, Operand(Smi::FromInt(op_)));
-  __ Mov(x2, Operand(Smi::FromInt(mode_)));
-  __ Mov(x3, Operand(Smi::FromInt(operand_type_)));
-  // x0 contains the operand
-  __ Push(x0, x1, x2, x3);
-
-  __ TailCallExternalReference(
-      ExternalReference(IC_Utility(IC::kUnaryOp_Patch), masm->isolate()), 4, 1);
-}
-
-
-void UnaryOpStub::GenerateSmiStub(MacroAssembler* masm) {
-  switch (op_) {
-    case Token::SUB:
-      GenerateSmiStubSub(masm);
-      break;
-    case Token::BIT_NOT:
-      GenerateSmiStubBitNot(masm);
-      break;
-    default:
-      UNREACHABLE();
-  }
-}
-
-
-void UnaryOpStub::GenerateSmiStubSub(MacroAssembler* masm) {
-  Label non_smi, slow;
-  GenerateSmiCodeSub(masm, &non_smi, &slow);
-  __ Bind(&non_smi);
-  __ Bind(&slow);
-  GenerateTypeTransition(masm);
-}
-
-
-void UnaryOpStub::GenerateSmiStubBitNot(MacroAssembler* masm) {
-  Label non_smi;
-  GenerateSmiCodeBitNot(masm, &non_smi);
-  __ Bind(&non_smi);
-  GenerateTypeTransition(masm);
-}
-
-
-void UnaryOpStub::GenerateSmiCodeSub(MacroAssembler* masm,
-                                     Label* non_smi,
-                                     Label* slow) {
-  __ JumpIfNotSmi(x0, non_smi);
-
-  // The result of negating zero or the smallest negative smi is not a smi.
-  __ Ands(x1, x0, 0x7fffffff00000000UL);
-  __ B(eq, slow);
-
-  __ Neg(x0, x0);
-  __ Ret();
-}
-
-
-void UnaryOpStub::GenerateSmiCodeBitNot(MacroAssembler* masm,
-                                        Label* non_smi) {
-  __ JumpIfNotSmi(x0, non_smi);
-
-  // Eor the top 32 bits with 0xffffffff to invert.
-  __ Eor(x0, x0, 0xffffffff00000000UL);
-  __ Ret();
-}
-
-
-void UnaryOpStub::GenerateNumberStub(MacroAssembler* masm) {
-  switch (op_) {
-    case Token::SUB:
-      GenerateNumberStubSub(masm);
-      break;
-    case Token::BIT_NOT:
-      GenerateNumberStubBitNot(masm);
-      break;
-    default:
-      UNREACHABLE();
-  }
-}
-
-
-void UnaryOpStub::GenerateNumberStubSub(MacroAssembler* masm) {
-  Label non_smi, slow, call_builtin;
-  GenerateSmiCodeSub(masm, &non_smi, &call_builtin);
-  __ Bind(&non_smi);
-  GenerateHeapNumberCodeSub(masm, &slow);
-  __ Bind(&slow);
-  GenerateTypeTransition(masm);
-  __ Bind(&call_builtin);
-  __ Push(x0);
-  __ InvokeBuiltin(Builtins::UNARY_MINUS, JUMP_FUNCTION);
-}
-
-
-void UnaryOpStub::GenerateNumberStubBitNot(MacroAssembler* masm) {
-  Label non_smi, slow;
-  GenerateSmiCodeBitNot(masm, &non_smi);
-  __ Bind(&non_smi);
-  GenerateHeapNumberCodeBitNot(masm, &slow);
-  __ Bind(&slow);
-  GenerateTypeTransition(masm);
-}
-
-
-void UnaryOpStub::GenerateHeapNumberCodeSub(MacroAssembler* masm,
-                                            Label* slow) {
-  Register heap_num = x0;
-  Register heap_num_map = x1;
-
-  __ LoadRoot(heap_num_map, Heap::kHeapNumberMapRootIndex);
-  __ JumpIfNotHeapNumber(heap_num, slow, heap_num_map);
-
-  if (mode_ == UNARY_OVERWRITE) {
-    Register exponent = w2;
-
-    // Flip the sign bit of the existing heap number.
-    __ Ldr(exponent, FieldMemOperand(heap_num, HeapNumber::kExponentOffset));
-    __ Eor(exponent, exponent, HeapNumber::kSignMask);
-    __ Str(exponent, FieldMemOperand(heap_num, HeapNumber::kExponentOffset));
-  } else {
-    Register allocated_num = x0;
-    Register double_bits = x2;
-    Register heap_num_orig = x3;
-
-    __ Mov(heap_num_orig, heap_num);
-
-    // Create a new heap number.
-    Label slow_allocate_heapnumber, heapnumber_allocated;
-    __ AllocateHeapNumber(allocated_num, &slow_allocate_heapnumber, x6, x7,
-                          heap_num_map);
-    __ B(&heapnumber_allocated);
-
-    __ Bind(&slow_allocate_heapnumber);
-    {
-      FrameScope scope(masm, StackFrame::INTERNAL);
-      __ Push(heap_num_orig);
-      __ CallRuntime(Runtime::kNumberAlloc, 0);
-      __ Pop(heap_num_orig);
-      // allocated_num is x0, so contains the result of the runtime allocation.
-    }
-
-    __ Bind(&heapnumber_allocated);
-    // Load the original heap number as a double precision float, and flip the
-    // sign bit.
-    STATIC_ASSERT(HeapNumber::kExponentOffset ==
-                  (HeapNumber::kMantissaOffset + 4));
-    __ Ldr(double_bits, FieldMemOperand(heap_num_orig,
-                                        HeapNumber::kMantissaOffset));
-    __ Eor(double_bits, double_bits, Double::kSignMask);
-
-    // Store the negated double to the newly allocated heap number.
-    __ Str(double_bits, FieldMemOperand(allocated_num,
-                                        HeapNumber::kValueOffset));
-  }
-  __ Ret();
-}
-
-
-void UnaryOpStub::GenerateHeapNumberCodeBitNot(MacroAssembler* masm,
-                                               Label* slow) {
-  Register heap_num = x0;
-  Register smi_num = x0;
-
-  __ JumpIfNotHeapNumber(heap_num, slow);
-
-  // Convert the heap number to a smi.
-  __ HeapNumberECMA262ToInt32(smi_num, heap_num, x6, x7, d0,
-                              MacroAssembler::SMI);
-
-  // Eor the top 32 bits with 0xffffffff to invert.
-  __ Eor(x0, smi_num, 0xffffffff00000000UL);
-  __ Ret();
-}
-
-
-void UnaryOpStub::GenerateGenericStub(MacroAssembler* masm) {
-  switch (op_) {
-    case Token::SUB: {
-      Label non_smi, slow;
-      GenerateSmiCodeSub(masm, &non_smi, &slow);
-      __ Bind(&non_smi);
-      GenerateHeapNumberCodeSub(masm, &slow);
-      __ Bind(&slow);
-      __ Push(x0);
-      __ InvokeBuiltin(Builtins::UNARY_MINUS, JUMP_FUNCTION);
-      break;
-    }
-    case Token::BIT_NOT: {
-      Label non_smi, slow;
-      GenerateSmiCodeBitNot(masm, &non_smi);
-      __ Bind(&non_smi);
-      GenerateHeapNumberCodeBitNot(masm, &slow);
-      __ Bind(&slow);
-      __ Push(x0);
-      __ InvokeBuiltin(Builtins::BIT_NOT, JUMP_FUNCTION);
-      break;
-    }
-    default:
-      UNREACHABLE();
-  }
-}
-
-
 void BinaryOpStub::Initialize() {
   // Nothing to do here.
 }
 
 
 void BinaryOpStub::GenerateTypeTransition(MacroAssembler* masm) {
   ASM_LOCATION("BinaryOpStub::GenerateTypeTransition");
   Label get_result;
 
   __ Mov(x12, Operand(Smi::FromInt(MinorKey())));
@@ skipping 1160 matching lines @@
 void CodeStub::GenerateStubsAheadOfTime(Isolate* isolate) {
   // It is important that the following stubs are generated in this order
   // because pregenerated stubs can only call other pregenerated stubs.
   // RecordWriteStub uses StoreBufferOverflowStub, which in turn uses
   // CEntryStub.
   CEntryStub::GenerateAheadOfTime(isolate);
   StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(isolate);
   StubFailureTrampolineStub::GenerateAheadOfTime(isolate);
   RecordWriteStub::GenerateFixedRegStubsAheadOfTime(isolate);
   ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
+  CreateAllocationSiteStub::GenerateAheadOfTime(isolate);
 }
 
 
 void CodeStub::GenerateFPStubs(Isolate* isolate) {
   // Floating-point code doesn't get special handling in A64, so there's
   // nothing to do here.
   USE(isolate);
 }
 
 
@@ skipping 224 matching lines @@
 
 void CEntryStub::Generate(MacroAssembler* masm) {
   // The Abort mechanism relies on CallRuntime, which in turn relies on
   // CEntryStub, so until this stub has been generated, we have to use a
   // fall-back Abort mechanism.
   //
   // Note that this stub must be generated before any use of Abort.
   masm->set_use_real_aborts(false);
 
   ASM_LOCATION("CEntryStub::Generate entry");
+  ProfileEntryHookStub::MaybeCallEntryHook(masm);
+
   // Register parameters:
   //    x0: argc (including receiver, untagged)
   //    x1: target
   //
   // The stack on entry holds the arguments and the receiver, with the receiver
   // at the highest address:
   //
   //    jssp]argc-1]: receiver
   //    jssp[argc-2]: arg[argc-2]
   //    ...           ...
@@ skipping 1705 matching lines @@
   ASSERT_EQ(*TypeFeedbackCells::UninitializedSentinel(masm->isolate()),
             masm->isolate()->heap()->the_hole_value());
 
   // Load the cache state.
   __ Ldr(x3, FieldMemOperand(x2, Cell::kValueOffset));
 
   // A monomorphic cache hit or an already megamorphic state: invoke the
   // function without changing the state.
   __ Cmp(x3, x1);
   __ B(eq, &done);
-  __ JumpIfRoot(x3, Heap::kUndefinedValueRootIndex, &done);
 
-  // Special handling of the Array() function, which caches not only the
-  // monomorphic Array function but the initial ElementsKind with special
-  // sentinels
-  Handle<Object> terminal_kind_sentinel =
-      TypeFeedbackCells::MonomorphicArraySentinel(masm->isolate(),
-                                                  LAST_FAST_ELEMENTS_KIND);
-  __ JumpIfNotSmi(x3, &miss);
-  __ Cmp(x3, Operand(terminal_kind_sentinel));
-  __ B(gt, &miss);
+  // If we came here, we need to see if we are the array function.
+  // If we didn't have a matching function, and we didn't find the megamorph
+  // sentinel, then we have in the cell either some other function or an
+  // AllocationSite. Do a map check on the object in ecx.
+  __ Ldr(x5, FieldMemOperand(x3, AllocationSite::kMapOffset));
+  __ JumpIfNotRoot(x5, Heap::kAllocationSiteMapRootIndex, &miss);
+
   // Make sure the function is the Array() function
   __ LoadArrayFunction(x3);
   __ Cmp(x1, x3);
   __ B(ne, &megamorphic);
   __ B(&done);
 
   __ Bind(&miss);
 
   // A monomorphic miss (i.e, here the cache is not uninitialized) goes
   // megamorphic.
   __ JumpIfRoot(x3, Heap::kTheHoleValueRootIndex, &initialize);
   // MegamorphicSentinel is an immortal immovable object (undefined) so no
   // write-barrier is needed.
   __ Bind(&megamorphic);
   __ LoadRoot(x3, Heap::kUndefinedValueRootIndex);
   __ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
   __ B(&done);
 
   // An uninitialized cache is patched with the function or sentinel to
   // indicate the ElementsKind if function is the Array constructor.
   __ Bind(&initialize);
   // Make sure the function is the Array() function
   __ LoadArrayFunction(x3);
   __ Cmp(x1, x3);
   __ B(ne, &not_array_function);
 
-  // The target function is the Array constructor, install a sentinel value in
-  // the constructor's type info cell that will track the initial ElementsKind
-  // that should be used for the array when its constructed.
-  Handle<Object> initial_kind_sentinel =
-      TypeFeedbackCells::MonomorphicArraySentinel(masm->isolate(),
-          GetInitialFastElementsKind());
-  __ Mov(x3, Operand(initial_kind_sentinel));
-  __ Str(x3, FieldMemOperand(x2, Cell::kValueOffset));
+  // 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;
+    __ Push(x0, x1, x2);
+    __ CallStub(&create_stub);
+    __ Pop(x2, x1, x0);
+  }
   __ B(&done);
 
   __ Bind(&not_array_function);
   // An uninitialized cache is patched with the function.
   __ Str(x1, FieldMemOperand(x2, Cell::kValueOffset));
   // No need for a write barrier here - cells are rescanned.
 
   __ Bind(&done);
 }
 
@@ skipping 2080 matching lines @@
   }
   masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE);
   __ Add(__ StackPointer(), __ StackPointer(),
          Operand(x1, LSL, kPointerSizeLog2));
   // Return to IC Miss stub, continuation still on stack.
   __ Ret();
 }
 
 
 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
-  if (entry_hook_ != NULL) {
-    // TODO(all) this needs a literal pool blocking scope and predictable code
-    // size.
+  if (masm->isolate()->function_entry_hook() != NULL) {
+    // TODO(all): This needs to be reliably consistent with
+    // kReturnAddressDistanceFromFunctionStart in ::Generate.
+    Assembler::BlockConstPoolScope no_const_pools(masm);
+    AllowStubCallsScope allow_stub_calls(masm, true);
     ProfileEntryHookStub stub;
     __ Push(lr);
     __ CallStub(&stub);
     __ Pop(lr);
   }
 }
 
 
 void ProfileEntryHookStub::Generate(MacroAssembler* masm) {
   // The entry hook is a "BumpSystemStackPointer" instruction (sub), followed by
   // a "Push lr" instruction, followed by a call.
   // TODO(jbramley): Verify that this call is always made with relocation.
   static const int kReturnAddressDistanceFromFunctionStart =
       Assembler::kCallSizeWithRelocation + (2 * kInstructionSize);
 
-  // Save live volatile registers.
-  __ Push(lr, x1, x5);
-  static const int kNumSavedRegs = 3;
+  // Save all kCallerSaved registers (including lr), since this can be called
+  // from anywhere.
+  // TODO(jbramley): What about FP registers?
+  __ PushCPURegList(kCallerSaved);
+  ASSERT(kCallerSaved.IncludesAliasOf(lr));
+  const int kNumSavedRegs = kCallerSaved.Count();
 
   // Compute the function's address as the first argument.
   __ Sub(x0, lr, kReturnAddressDistanceFromFunctionStart);
 
-#if defined(V8_HOST_ARCH_A64)
-  __ Mov(x10, Operand(reinterpret_cast<intptr_t>(&entry_hook_)));
-  __ Ldr(x10, MemOperand(x10));
+#if V8_HOST_ARCH_A64
+  uintptr_t entry_hook =
+      reinterpret_cast<uintptr_t>(masm->isolate()->function_entry_hook());
+  __ Mov(x10, entry_hook);
 #else
   // Under the simulator we need to indirect the entry hook through a trampoline
   // function at a known address.
-  Address trampoline_address = reinterpret_cast<Address>(
-      reinterpret_cast<intptr_t>(EntryHookTrampoline));
-  ApiFunction dispatcher(trampoline_address);
+  ApiFunction dispatcher(FUNCTION_ADDR(EntryHookTrampoline));
   __ Mov(x10, Operand(ExternalReference(&dispatcher,
                                         ExternalReference::BUILTIN_CALL,
                                         masm->isolate())));
 #endif
 
   // The caller's return address is above the saved temporaries.
   // Grab its location for the second argument to the hook.
   __ Add(x1, __ StackPointer(), kNumSavedRegs * kPointerSize);
 
   {
     // Create a dummy frame, as CallCFunction requires this.
     FrameScope frame(masm, StackFrame::MANUAL);
     __ CallCFunction(x10, 2, 0);
   }
 
-  __ Pop(x5, x1, lr);
+  __ PopCPURegList(kCallerSaved);
   __ Ret();
 }
 
 
 void DirectCEntryStub::Generate(MacroAssembler* masm) {
   // When calling into C++ code the stack pointer must be csp.
   // Therefore this code must use csp for peek/poke operations when the
   // stub is generated. When the stub is called
   // (via DirectCEntryStub::GenerateCall), the caller must setup an ExitFrame
   // and configure the stack pointer *before* doing the call.
@@ skipping 300 matching lines @@
   Register type_info_cell = x2;
   Register kind = x3;
 
   STATIC_ASSERT(FAST_SMI_ELEMENTS == 0);
   STATIC_ASSERT(FAST_HOLEY_SMI_ELEMENTS == 1);
   STATIC_ASSERT(FAST_ELEMENTS == 2);
   STATIC_ASSERT(FAST_HOLEY_ELEMENTS == 3);
   STATIC_ASSERT(FAST_DOUBLE_ELEMENTS == 4);
   STATIC_ASSERT(FAST_HOLEY_DOUBLE_ELEMENTS == 5);
 
-  Handle<Object> undefined_sentinel(
-      masm->isolate()->heap()->undefined_value(),
-      masm->isolate());
-
   // Is the low bit set? If so, the array is holey.
   Label normal_sequence;
   __ Tbnz(kind, 0, &normal_sequence);
 
   // Look at the last argument.
   // TODO(jbramley): What does a 0 argument represent?
   __ Peek(x10, 0);
   __ Cbz(x10, &normal_sequence);
 
   // We are going to create a holey array, but our kind is non-holey.
-  // Fix kind and retry.
+  // Fix kind and retry (only if we have an allocation site in the cell).
   __ Orr(kind, kind, 1);
-  __ Cmp(type_info_cell, Operand(undefined_sentinel));
-  __ B(eq, &normal_sequence);
+  __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex,
+                &normal_sequence);
+
+  __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kValueOffset));
+  __ Ldr(x10, FieldMemOperand(x10, 0));
+  __ JumpIfNotRoot(x10, Heap::kAllocationSiteMapRootIndex, &normal_sequence);
 
   // Save the resulting elements kind in type info.
   // TODO(jbramley): Tag and store at the same time.
   __ SmiTag(x10, kind);
-  __ Str(x10, FieldMemOperand(type_info_cell, kPointerSize));
+  __ Ldr(x11, FieldMemOperand(type_info_cell, Cell::kValueOffset));
+  __ Str(x10, FieldMemOperand(x11, AllocationSite::kPayloadOffset));
 
   __ Bind(&normal_sequence);
   int last_index = GetSequenceIndexFromFastElementsKind(
       TERMINAL_FAST_ELEMENTS_KIND);
   for (int i = 0; i <= last_index; ++i) {
     Label next;
     ElementsKind candidate_kind = GetFastElementsKindFromSequenceIndex(i);
     // TODO(jbramley): Is this the best way to handle this? Can we make the tail
     // calls conditional, rather than hopping over each one?
     __ CompareAndBranch(kind, candidate_kind, ne, &next);
     ArraySingleArgumentConstructorStub stub(candidate_kind);
     __ TailCallStub(&stub);
     __ Bind(&next);
   }
 
   // If we reached this point there is a problem.
   __ Abort("Unexpected ElementsKind in array constructor");
 }
 
 
 template<class T>
 static void ArrayConstructorStubAheadOfTimeHelper(Isolate* isolate) {
   int to_index = GetSequenceIndexFromFastElementsKind(
       TERMINAL_FAST_ELEMENTS_KIND);
   for (int i = 0; i <= to_index; ++i) {
     ElementsKind kind = GetFastElementsKindFromSequenceIndex(i);
     T stub(kind);
     stub.GetCode(isolate)->set_is_pregenerated(true);
-    if (AllocationSiteInfo::GetMode(kind) != DONT_TRACK_ALLOCATION_SITE) {
-      T stub1(kind, true);
+    if (AllocationSite::GetMode(kind) != DONT_TRACK_ALLOCATION_SITE) {
+      T stub1(kind, CONTEXT_CHECK_REQUIRED, DISABLE_ALLOCATION_SITES);
       stub1.GetCode(isolate)->set_is_pregenerated(true);
     }
   }
 }
 
 
 void ArrayConstructorStubBase::GenerateStubsAheadOfTime(Isolate* isolate) {
   ArrayConstructorStubAheadOfTimeHelper<ArrayNoArgumentConstructorStub>(
       isolate);
   ArrayConstructorStubAheadOfTimeHelper<ArraySingleArgumentConstructorStub>(
@@ skipping 19 matching lines @@
 
 
 void ArrayConstructorStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- x0 : argc (only if argument_count_ == ANY)
   //  -- x1 : constructor
   //  -- x2 : type info cell
   //  -- sp[0] : return address
   //  -- sp[4] : last argument
   // -----------------------------------
-  Handle<Object> undefined_sentinel(
-      masm->isolate()->heap()->undefined_value(), masm->isolate());
-
   Register argc = x0;
   Register constructor = x1;
   Register type_info_cell = x2;
 
   if (FLAG_debug_code) {
     // The array construct code is only set for the global and natives
     // builtin Array functions which always have maps.
 
     Label unexpected_map, map_ok;
     // Initial map for the builtin Array function should be a map.
     __ Ldr(x10, FieldMemOperand(constructor,
                                 JSFunction::kPrototypeOrInitialMapOffset));
     // Will both indicate a NULL and a Smi.
     __ JumpIfSmi(x10, &unexpected_map);
     __ JumpIfObjectType(x10, x10, x11, MAP_TYPE, &map_ok);
     __ Bind(&unexpected_map);
     __ Abort("Unexpected initial map for Array function");
     __ Bind(&map_ok);
 
     // In type_info_cell, we expect either undefined or a valid Cell.
     Label okay_here;
     Handle<Map> cell_map(masm->isolate()->heap()->global_property_cell_map());
-    __ CompareAndBranch(type_info_cell, Operand(undefined_sentinel),
-                        eq, &okay_here);
+    __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &okay_here);
     __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kMapOffset));
     __ Cmp(x10, Operand(cell_map));
     __ Assert(eq, "Expected property cell in type_info_cell");
     __ Bind(&okay_here);
   }
 
   Register kind = x3;
   Label no_info, switch_ready;
   // Get the elements kind and case on that.
-  __ CompareAndBranch(type_info_cell, Operand(undefined_sentinel),
-                      eq, &no_info);
+  __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &no_info);
   __ Ldr(kind, FieldMemOperand(type_info_cell, PropertyCell::kValueOffset));
-  __ JumpIfNotSmi(kind, &no_info);
-  __ SmiUntag(kind);
+
+  // The type cell may have undefined in its value.
+  __ JumpIfRoot(kind, Heap::kUndefinedValueRootIndex, &no_info);
+
+  // We should have an allocation site object
+  if (FLAG_debug_code) {
+    __ Ldr(x10, FieldMemOperand(kind, AllocationSite::kMapOffset));
+    __ CompareRoot(x10, Heap::kAllocationSiteMapRootIndex);
+    __ Assert(eq, "Expected AllocationSite object.");
+  }
+
+  __ Ldrsw(kind, UntagSmiFieldMemOperand(kind, AllocationSite::kPayloadOffset));
   __ B(&switch_ready);
 
   __ Bind(&no_info);
   __ Mov(kind, GetInitialFastElementsKind());
   __ Bind(&switch_ready);
 
   if (argument_count_ == ANY) {
     Label zero_case, n_case;
     __ Cbz(argc, &zero_case);
     __ Cmp(argc, 1);
@@ skipping 114 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64