A64: Synchronize with r16756.

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 2212 matching lines @@
   ASSERT(csp.Is(__ StackPointer()));
 
   Isolate* isolate = masm->isolate();
 
   const Register& argv = x21;
   const Register& argc = x22;
   const Register& target = x23;
 
   if (do_gc) {
     // Call Runtime::PerformGC, passing x0 (the result parameter for
-    // PerformGC).
+    // PerformGC) and x1 (the isolate).
+    __ Mov(x1, Operand(ExternalReference::isolate_address(masm->isolate())));
     __ CallCFunction(
-        ExternalReference::perform_gc_function(isolate), 1, 0);
+        ExternalReference::perform_gc_function(isolate), 2, 0);
   }
 
   ExternalReference scope_depth =
       ExternalReference::heap_always_allocate_scope_depth(isolate);
   if (always_allocate) {
     __ Mov(x10, Operand(scope_depth));
     __ Ldr(x11, MemOperand(x10));
     __ Add(x11, x11, 1);
     __ Str(x11, MemOperand(x10));
   }
@@ skipping 498 matching lines @@
     ASSERT(kind() == Code::LOAD_IC);
     // ----------- S t a t e -------------
     //  -- lr    : return address
     //  -- x2    : name
     //  -- x0    : receiver
     //  -- sp[0] : receiver
     // -----------------------------------
     receiver = x0;
   }
 
-  StubCompiler::GenerateLoadStringLength(masm, receiver, x10, x11, &miss,
-                                         support_wrapper_);
+  StubCompiler::GenerateLoadStringLength(masm, receiver, x10, x11, &miss);
 
   __ Bind(&miss);
   StubCompiler::TailCallBuiltin(masm,
                                 BaseLoadStoreStubCompiler::MissBuiltin(kind()));
 }
 
 
 void StoreArrayLengthStub::Generate(MacroAssembler* masm) {
   ASM_LOCATION("StoreArrayLengthStub::Generate");
   // This accepts as a receiver anything JSArray::SetElementsLength accepts
@@ skipping 3115 matching lines @@
                                             Register scratch4,
                                             Label* slow) {
   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.
-  Label not_cached;
   __ Bind(&not_string);
   // Puts the cache result into scratch1.
   NumberToStringStub::GenerateLookupNumberStringCache(
       masm,
       arg,
       scratch1,
       scratch2,
       scratch3,
       scratch4,
-      &not_cached);
+      slow);
   __ Mov(arg, scratch1);
-  __ B(&done);
-
-  // Check if the argument is a safe string wrapper.
-  __ Bind(&not_cached);
-  __ JumpIfSmi(arg, slow);
-  Register map = scratch1;
-  __ JumpIfNotObjectType(arg, map, scratch2, JS_VALUE_TYPE, slow);
-  __ Ldrb(scratch2, FieldMemOperand(map, Map::kBitField2Offset));
-  __ Tbz(scratch2, Map::kStringWrapperSafeForDefaultValueOf, slow);
-  __ Ldr(arg, FieldMemOperand(arg, JSValue::kValueOffset));
 
   __ Bind(&done);
 }
 
 
 void StringAddStub::GenerateRegisterArgsPush(MacroAssembler* masm) {
   __ Push(x0, x1);
 }
 
 
@@ skipping 673 matching lines @@
   __ Mov(result, 1);
   __ Ret();
 
   __ Bind(&not_in_dictionary);
   __ Mov(result, 0);
   __ Ret();
 }
 
 
 template<class T>
-static void CreateArrayDispatch(MacroAssembler* masm) {
-  Register kind = x3;
-  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);
-    T stub(candidate_kind);
-    __ TailCallStub(&stub);
-    __ Bind(&next);
+static void CreateArrayDispatch(MacroAssembler* masm,
+                                AllocationSiteOverrideMode mode) {
+  if (mode == DISABLE_ALLOCATION_SITES) {
+    T stub(GetInitialFastElementsKind(),
+           CONTEXT_CHECK_REQUIRED,
+           mode);
+     __ TailCallStub(&stub);
+
+  } else if (mode == DONT_OVERRIDE) {
+    Register kind = x3;
+    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);
+      T stub(candidate_kind);
+      __ TailCallStub(&stub);
+      __ Bind(&next);
+    }
+
+    // If we reached this point there is a problem.
+    __ Abort(kUnexpectedElementsKindInArrayConstructor);
+
+  } else {
+    UNREACHABLE();
   }
-
-  // If we reached this point there is a problem.
-  __ Abort(kUnexpectedElementsKindInArrayConstructor);
 }
 
 
 // TODO(jbramley): If this needs to be a special case, make it a proper template
 // specialization, and not a separate function.
-static void CreateArrayDispatchOneArgument(MacroAssembler* masm) {
+static void CreateArrayDispatchOneArgument(MacroAssembler* masm,
+                                           AllocationSiteOverrideMode mode) {
   // x0 - argc
   // x1 - constructor?
-  // x2 - type info cell
-  // x3 - kind
+  // x2 - type info cell (if mode != DISABLE_ALLOCATION_SITES)
+  // x3 - kind (if mode != DISABLE_ALLOCATION_SITES)
   // sp[0] - last argument
 
   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);
+  Label normal_sequence;
+  if (mode == DONT_OVERRIDE) {
+    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);
 
-  // Is the low bit set? If so, the array is holey.
-  Label normal_sequence;
-  __ Tbnz(kind, 0, &normal_sequence);
+    // Is the low bit set? If so, the array is holey.
+    __ 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 (only if we have an allocation site in the cell).
-  __ Orr(kind, kind, 1);
-  __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex,
-                &normal_sequence);
+  if (mode == DISABLE_ALLOCATION_SITES) {
+    ElementsKind initial = GetInitialFastElementsKind();
+    ElementsKind holey_initial = GetHoleyElementsKind(initial);
 
-  __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kValueOffset));
-  __ Ldr(x10, FieldMemOperand(x10, 0));
-  __ JumpIfNotRoot(x10, Heap::kAllocationSiteMapRootIndex, &normal_sequence);
+    ArraySingleArgumentConstructorStub stub_holey(holey_initial,
+                                                  CONTEXT_CHECK_REQUIRED,
+                                                  DISABLE_ALLOCATION_SITES);
+    __ TailCallStub(&stub_holey);
 
-  // Save the resulting elements kind in type info.
-  // TODO(jbramley): Tag and store at the same time.
-  __ SmiTag(x10, kind);
-  __ Ldr(x11, FieldMemOperand(type_info_cell, Cell::kValueOffset));
-  __ Str(x10, FieldMemOperand(x11, AllocationSite::kTransitionInfoOffset));
+    __ Bind(&normal_sequence);
+    ArraySingleArgumentConstructorStub stub(initial,
+                                            CONTEXT_CHECK_REQUIRED,
+                                            DISABLE_ALLOCATION_SITES);
+    __ TailCallStub(&stub);
+  } else if (mode == DONT_OVERRIDE) {
+    // We are going to create a holey array, but our kind is non-holey.
+    // Fix kind and retry (only if we have an allocation site in the cell).
+    __ Orr(kind, kind, 1);
 
-  __ 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);
+    __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kValueOffset));
+
+    if (FLAG_debug_code) {
+      __ Ldr(x10, FieldMemOperand(x10, 0));
+      __ JumpIfNotRoot(x10, Heap::kAllocationSiteMapRootIndex,
+                       &normal_sequence);
+      __ Assert(eq, kExpectedAllocationSiteInCell);
+      __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kValueOffset));
+    }
+
+    // Save the resulting elements kind in type info.
+    // TODO(jbramley): Tag and store at the same time.
+    __ SmiTag(x10, kind);
+    __ Ldr(x11, FieldMemOperand(type_info_cell, Cell::kValueOffset));
+    __ Str(x10, FieldMemOperand(x11, AllocationSite::kTransitionInfoOffset));
+
+    __ 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(kUnexpectedElementsKindInArrayConstructor);
+  } else {
+    UNREACHABLE();
   }
-
-  // If we reached this point there is a problem.
-  __ Abort(kUnexpectedElementsKindInArrayConstructor);
 }
 
 
 template<class T>
 static void ArrayConstructorStubAheadOfTimeHelper(Isolate* isolate) {
+  ElementsKind initial_kind = GetInitialFastElementsKind();
+  ElementsKind initial_holey_kind = GetHoleyElementsKind(initial_kind);
+
   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 (AllocationSite::GetMode(kind) != DONT_TRACK_ALLOCATION_SITE) {
+    if ((AllocationSite::GetMode(kind) != DONT_TRACK_ALLOCATION_SITE) ||
+        (!FLAG_track_allocation_sites &&
+         ((kind == initial_kind) || (kind == initial_holey_kind)))) {
       T stub1(kind, CONTEXT_CHECK_REQUIRED, DISABLE_ALLOCATION_SITES);
       stub1.GetCode(isolate)->set_is_pregenerated(true);
     }
   }
 }
 
 
 void ArrayConstructorStubBase::GenerateStubsAheadOfTime(Isolate* isolate) {
   ArrayConstructorStubAheadOfTimeHelper<ArrayNoArgumentConstructorStub>(
       isolate);
@@ skipping 12 matching lines @@
     InternalArrayNoArgumentConstructorStub stubh1(kinds[i]);
     stubh1.GetCode(isolate)->set_is_pregenerated(true);
     InternalArraySingleArgumentConstructorStub stubh2(kinds[i]);
     stubh2.GetCode(isolate)->set_is_pregenerated(true);
     InternalArrayNArgumentsConstructorStub stubh3(kinds[i]);
     stubh3.GetCode(isolate)->set_is_pregenerated(true);
   }
 }
 
 
+void ArrayConstructorStub::GenerateDispatchToArrayStub(
+    MacroAssembler* masm,
+    AllocationSiteOverrideMode mode) {
+  Register argc = x0;
+  if (argument_count_ == ANY) {
+    Label zero_case, n_case;
+    __ Cbz(argc, &zero_case);
+    __ Cmp(argc, 1);
+    __ B(ne, &n_case);
+
+    // One argument.
+    CreateArrayDispatchOneArgument(masm, mode);
+
+    __ Bind(&zero_case);
+    // No arguments.
+    CreateArrayDispatch<ArrayNoArgumentConstructorStub>(masm, mode);
+
+    __ Bind(&n_case);
+    // N arguments.
+    CreateArrayDispatch<ArrayNArgumentsConstructorStub>(masm, mode);
+
+  } else if (argument_count_ == NONE) {
+    CreateArrayDispatch<ArrayNoArgumentConstructorStub>(masm, mode);
+  } else if (argument_count_ == ONE) {
+    CreateArrayDispatchOneArgument(masm, mode);
+  } else if (argument_count_ == MORE_THAN_ONE) {
+    CreateArrayDispatch<ArrayNArgumentsConstructorStub>(masm, mode);
+  } else {
+    UNREACHABLE();
+  }
+}
+
+
 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
   // -----------------------------------
-  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(kUnexpectedInitialMapForArrayFunction);
     __ Bind(&map_ok);
 
     // In type_info_cell, we expect either undefined or a valid Cell.
     Label okay_here;
     Handle<Map> cell_map = masm->isolate()->factory()->cell_map();
     __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &okay_here);
     __ Ldr(x10, FieldMemOperand(type_info_cell, Cell::kMapOffset));
     __ Cmp(x10, Operand(cell_map));
     __ Assert(eq, kExpectedPropertyCellInTypeInfoCell);
     __ Bind(&okay_here);
   }
 
   Register kind = x3;
-  Label no_info, switch_ready;
+  Label no_info;
   // Get the elements kind and case on that.
   __ JumpIfRoot(type_info_cell, Heap::kUndefinedValueRootIndex, &no_info);
   __ Ldr(kind, FieldMemOperand(type_info_cell, PropertyCell::kValueOffset));
 
-  // The type cell may have undefined in its value.
-  __ JumpIfRoot(kind, Heap::kUndefinedValueRootIndex, &no_info);
-
-  // The type cell has either an AllocationSite or a JSFunction.
+  // If the type cell is undefined, or contains anything other than an
+  // AllocationSite, call an array constructor that doesn't use AllocationSites.
   __ Ldr(x10, FieldMemOperand(kind, AllocationSite::kMapOffset));
   __ JumpIfNotRoot(x10, Heap::kAllocationSiteMapRootIndex, &no_info);
 
   __ Ldrsw(kind,
            UntagSmiFieldMemOperand(kind,
                                    AllocationSite::kTransitionInfoOffset));
-  __ B(&switch_ready);
+  GenerateDispatchToArrayStub(masm, DONT_OVERRIDE);
 
   __ 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);
-    __ B(ne, &n_case);
-
-    // One argument.
-    CreateArrayDispatchOneArgument(masm);
-
-    __ Bind(&zero_case);
-    // No arguments.
-    CreateArrayDispatch<ArrayNoArgumentConstructorStub>(masm);
-
-    __ Bind(&n_case);
-    // N arguments.
-    CreateArrayDispatch<ArrayNArgumentsConstructorStub>(masm);
-
-  } else if (argument_count_ == NONE) {
-    CreateArrayDispatch<ArrayNoArgumentConstructorStub>(masm);
-  } else if (argument_count_ == ONE) {
-    CreateArrayDispatchOneArgument(masm);
-  } else if (argument_count_ == MORE_THAN_ONE) {
-    CreateArrayDispatch<ArrayNArgumentsConstructorStub>(masm);
-  } else {
-    UNREACHABLE();
-  }
+  GenerateDispatchToArrayStub(masm, DISABLE_ALLOCATION_SITES);
 }
 
 
 void InternalArrayConstructorStub::GenerateCase(
     MacroAssembler* masm, ElementsKind kind) {
   Label zero_case, n_case;
   Register argc = x0;
 
   __ Cbz(argc, &zero_case);
   __ CompareAndBranch(argc, 1, ne, &n_case);
@@ skipping 81 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64