A64: Synchronize with r18256.

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 199 matching lines @@
   static Register registers[] = { x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
       FUNCTION_ADDR(CompareNilIC_Miss);
   descriptor->SetMissHandler(
       ExternalReference(IC_Utility(IC::kCompareNilIC_Miss), isolate));
 }
 
 
-void BinaryOpStub::InitializeInterfaceDescriptor(
+void BinaryOpICStub::InitializeInterfaceDescriptor(
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x1: left operand
   // x0: right operand
   static Register registers[] = { x1, x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ = FUNCTION_ADDR(BinaryOpIC_Miss);
   descriptor->SetMissHandler(
       ExternalReference(IC_Utility(IC::kBinaryOpIC_Miss), isolate));
@@ skipping 788 matching lines @@
     __ PopCPURegList(kCallerSavedFP);
   }
   __ PopCPURegList(saved_regs);
   __ Ret();
 }
 
 
 void StoreBufferOverflowStub::GenerateFixedRegStubsAheadOfTime(
     Isolate* isolate) {
   StoreBufferOverflowStub stub1(kDontSaveFPRegs);
-  stub1.GetCode(isolate)->set_is_pregenerated(true);
+  stub1.GetCode(isolate);
   StoreBufferOverflowStub stub2(kSaveFPRegs);
-  stub2.GetCode(isolate)->set_is_pregenerated(true);
+  stub2.GetCode(isolate);
 }
 
 
 void TranscendentalCacheStub::Generate(MacroAssembler* masm) {
   // Untagged case:
   //  Input: double in d0
   //  Result: double in d0
   //
   // Tagged case:
   //  Input: tagged value in jssp[0]
@@ skipping 181 matching lines @@
 }
 
 
 ExternalReference TranscendentalCacheStub::CFunction(Isolate* isolate) {
   switch (type_) {
     // Add more cases when necessary.
     default:
       // There's no NULL ExternalReference, so fall into an existing case to
       // avoid compiler warnings about not having a return value.
       UNIMPLEMENTED();
-    case TranscendentalCache::SIN:
-      return ExternalReference::math_sin_double_function(isolate);
-    case TranscendentalCache::COS:
-      return ExternalReference::math_cos_double_function(isolate);
-    case TranscendentalCache::TAN:
-      return ExternalReference::math_tan_double_function(isolate);
     case TranscendentalCache::LOG:
       return ExternalReference::math_log_double_function(isolate);
   }
 }
 
 
 Runtime::FunctionId TranscendentalCacheStub::RuntimeFunction() {
   switch (type_) {
     // Add more cases when necessary.
-    case TranscendentalCache::SIN: return Runtime::kMath_sin;
-    case TranscendentalCache::COS: return Runtime::kMath_cos;
-    case TranscendentalCache::TAN: return Runtime::kMath_tan;
     case TranscendentalCache::LOG: return Runtime::kMath_log;
     default:
       UNIMPLEMENTED();
       return Runtime::kAbort;
   }
 }
 
 
 void MathPowStub::Generate(MacroAssembler* masm) {
   // Stack on entry:
@@ skipping 248 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);
-  BinaryOpStub::GenerateAheadOfTime(isolate);
+  BinaryOpICStub::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 15 matching lines @@
   // when the C++ code returns to the stub because LR holds the return address
   // in AAPCS64. If the stub is moved (perhaps during a GC), we could end up
   // returning to dead code.
   // TODO(jbramley): Whilst this is the only analysis that makes sense, I can't
   // find any comment to confirm this, and I don't hit any crashes whatever
   // this function returns. The anaylsis should be properly confirmed.
   return true;
 }
 
 
-bool CEntryStub::IsPregenerated(Isolate* isolate) {
-  USE(isolate);
-  return result_size_ == 1;
-}
-
-
 void CEntryStub::GenerateAheadOfTime(Isolate* isolate) {
   CEntryStub stub(1, kDontSaveFPRegs);
-  stub.GetCode(isolate)->set_is_pregenerated(true);
+  stub.GetCode(isolate);
   CEntryStub stub_fp(1, kSaveFPRegs);
-  stub_fp.GetCode(isolate)->set_is_pregenerated(true);
+  stub_fp.GetCode(isolate);
 }
 
 
 void CEntryStub::GenerateCore(MacroAssembler* masm,
                               Label* throw_normal,
                               Label* throw_termination,
                               Label* throw_out_of_memory,
                               bool do_gc,
                               bool always_allocate) {
   // x0  : Result parameter for PerformGC, if do_gc is true.
@@ skipping 3409 matching lines @@
   __ Cbz(x3, &skip_write_barrier);
 
   __ Str(left, FieldMemOperand(result, ConsString::kFirstOffset));
   __ RecordWriteField(result,
                       ConsString::kFirstOffset,
                       left,
                       x3,
                       kLRHasNotBeenSaved,
                       kDontSaveFPRegs,
                       EMIT_REMEMBERED_SET,
-                      INLINE_SMI_CHECK,
-                      EXPECT_PREGENERATED);
+                      INLINE_SMI_CHECK);
   __ Str(right, FieldMemOperand(result, ConsString::kSecondOffset));
   __ RecordWriteField(result,
                       ConsString::kSecondOffset,
                       right,
                       x3,
                       kLRHasNotBeenSaved,
                       kDontSaveFPRegs,
                       EMIT_REMEMBERED_SET,
-                      INLINE_SMI_CHECK,
-                      EXPECT_PREGENERATED);
+                      INLINE_SMI_CHECK);
   __ B(&after_writing);
   __ Bind(&skip_write_barrier);
 
   __ Str(left, FieldMemOperand(result, ConsString::kFirstOffset));
   __ Str(right, FieldMemOperand(result, ConsString::kSecondOffset));
   __ Bind(&after_writing);
 
   __ IncrementCounter(counters->string_add_native(), 1, x3, x4);
   __ Ret();
 
@@ skipping 153 matching lines @@
 
 void StringAddStub::GenerateRegisterArgsPush(MacroAssembler* masm) {
   __ Push(x0, x1);
 }
 
 
 void StringAddStub::GenerateRegisterArgsPop(MacroAssembler* masm) {
   __ Pop(x1, x0);
 }
 
-#define MINOR_KEY_FOR(obj, value, addr, action, fp_mode)        \
-  ((obj) | ((value) << 5) | ((addr) << 10) | ((action) << 15) | \
-  ((fp_mode) << 16))
-
-const int RecordWriteStub::kAheadOfTime[] = {
-  // Arguments to MinorKeyFor() are object, value and address registers.
-
-  // Used in StoreArrayLiteralElementStub::Generate.
-  MINOR_KEY_FOR(10, 0, 11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in FastNewClosure::Generate.
-  MINOR_KEY_FOR(5, 4, 1, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in KeyedStoreStubCompiler::GenerateStoreFastElement.
-  MINOR_KEY_FOR(3, 2, 10, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in KeyedStoreStubCompiler::GenerateStoreFastDoubleElement.
-  MINOR_KEY_FOR(2, 3, 10, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in ElementsTransitionGenerator::GenerateSmiToDouble.
-  MINOR_KEY_FOR(2, 3, 6, OMIT_REMEMBERED_SET, kDontSaveFPRegs),
-  MINOR_KEY_FOR(2, 10, 6, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in ElementsTransitionGenerator::GenerateDoubleToObject.
-  MINOR_KEY_FOR(7, 5, 13, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-  MINOR_KEY_FOR(2, 7, 13, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-  MINOR_KEY_FOR(2, 3, 13, OMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in KeyedStoreIC::GenerateGeneric helper function.
-  MINOR_KEY_FOR(4, 10, 11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in RegExpExecStub::Generate.
-  MINOR_KEY_FOR(21, 10, 11, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // Used in StringAddStub::Generate.
-  MINOR_KEY_FOR(0, 10, 3, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-  MINOR_KEY_FOR(0, 11, 3, EMIT_REMEMBERED_SET, kDontSaveFPRegs),
-
-  // TODO(jbramley): There are many more sites that want a pregenerated
-  // instance of this stub, but they are currently unimplemented. Once they are
-  // implemented, they should be added to this list.
-
-  // Null termination.
-  // It is safe to encode this as 0 because the three registers used for
-  // RecordWriteStub must not be aliased, and 0 represents (x0, x0, x0).
-  0
-};
-
-
-#undef MINOR_KEY_FOR
-
-
-void RecordWriteStub::GenerateFixedRegStubsAheadOfTime(Isolate* isolate) {
-  // Pregenerate all of the stub variants in the kAheadOfTime list.
-  for (const int* entry = kAheadOfTime; *entry != 0; entry++) {
-    // kAheadOfTime is a list of minor keys, so extract the relevant fields
-    // from the minor key.
-    Register object = Register::XRegFromCode(ObjectBits::decode(*entry));
-    Register value = Register::XRegFromCode(ValueBits::decode(*entry));
-    Register address = Register::XRegFromCode(AddressBits::decode(*entry));
-    RememberedSetAction action = RememberedSetActionBits::decode(*entry);
-    SaveFPRegsMode fp_mode = SaveFPRegsModeBits::decode(*entry);
-
-    RecordWriteStub stub(object, value, address, action, fp_mode);
-    stub.GetCode(isolate)->set_is_pregenerated(true);
-  }
-}
-
 
 bool CodeStub::CanUseFPRegisters() {
   // FP registers always available on A64.
   return true;
 }
 
 
-bool RecordWriteStub::IsPregenerated(Isolate* isolate) {
-  USE(isolate);
-  // If the stub exists in the kAheadOfTime list, it is pregenerated.
-  for (const int* entry = kAheadOfTime; *entry != 0; entry++) {
-    if (*entry == MinorKeyFor(object_, value_, address_,
-                              remembered_set_action_, save_fp_regs_mode_)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-
 void RecordWriteStub::GenerateIncremental(MacroAssembler* masm, Mode mode) {
   // We need some extra registers for this stub, they have been allocated
   // but we need to save them before using them.
   regs_.Save(masm);
 
   if (remembered_set_action_ == EMIT_REMEMBERED_SET) {
     Label dont_need_remembered_set;
 
     Register value = regs_.scratch0();
     __ Ldr(value, MemOperand(regs_.address()));
@@ skipping 201 matching lines @@
   __ TailCallRuntime(Runtime::kStoreArrayLiteralElement, 5, 1);
 
   // Array literal has ElementsKind of FAST_*_ELEMENTS and value is an object.
   __ Bind(&fast_elements);
   __ Ldr(x10, FieldMemOperand(array, JSObject::kElementsOffset));
   __ Add(x11, x10, Operand::UntagSmiAndScale(index_smi, kPointerSizeLog2));
   __ Add(x11, x11, FixedArray::kHeaderSize - kHeapObjectTag);
   __ Str(value, MemOperand(x11));
   // Update the write barrier for the array store.
   __ RecordWrite(x10, x11, value, kLRHasNotBeenSaved, kDontSaveFPRegs,
-                 EMIT_REMEMBERED_SET, OMIT_SMI_CHECK, EXPECT_PREGENERATED);
+                 EMIT_REMEMBERED_SET, OMIT_SMI_CHECK);
   __ Ret();
 
   // Array literal has ElementsKind of FAST_*_SMI_ELEMENTS or FAST_*_ELEMENTS,
   // and value is Smi.
   __ Bind(&smi_element);
   __ Ldr(x10, FieldMemOperand(array, JSObject::kElementsOffset));
   __ Add(x11, x10, Operand::UntagSmiAndScale(index_smi, kPointerSizeLog2));
   __ Str(value, FieldMemOperand(x11, FixedArray::kHeaderSize));
   __ Ret();
 
@@ skipping 38 matching lines @@
   __ InvokeFunction(
       x1, argument_count, JUMP_FUNCTION, NullCallWrapper(), CALL_AS_METHOD);
 }
 
 
 void ProfileEntryHookStub::MaybeCallEntryHook(MacroAssembler* masm) {
   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) {
   MacroAssembler::NoUseRealAbortsScope no_use_real_aborts(masm);
@@ skipping 445 matching lines @@
 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);
+    stub.GetCode(isolate);
     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);
+      stub1.GetCode(isolate);
     }
   }
 }
 
 
 void ArrayConstructorStubBase::GenerateStubsAheadOfTime(Isolate* isolate) {
   ArrayConstructorStubAheadOfTimeHelper<ArrayNoArgumentConstructorStub>(
       isolate);
   ArrayConstructorStubAheadOfTimeHelper<ArraySingleArgumentConstructorStub>(
       isolate);
   ArrayConstructorStubAheadOfTimeHelper<ArrayNArgumentsConstructorStub>(
       isolate);
 }
 
 
 void InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(
     Isolate* isolate) {
   ElementsKind kinds[2] = { FAST_ELEMENTS, FAST_HOLEY_ELEMENTS };
   for (int i = 0; i < 2; i++) {
     // For internal arrays we only need a few things
     InternalArrayNoArgumentConstructorStub stubh1(kinds[i]);
-    stubh1.GetCode(isolate)->set_is_pregenerated(true);
+    stubh1.GetCode(isolate);
     InternalArraySingleArgumentConstructorStub stubh2(kinds[i]);
-    stubh2.GetCode(isolate)->set_is_pregenerated(true);
+    stubh2.GetCode(isolate);
     InternalArrayNArgumentsConstructorStub stubh3(kinds[i]);
-    stubh3.GetCode(isolate)->set_is_pregenerated(true);
+    stubh3.GetCode(isolate);
   }
 }
 
 
 void ArrayConstructorStub::GenerateDispatchToArrayStub(
     MacroAssembler* masm,
     AllocationSiteOverrideMode mode) {
   Register argc = x0;
   if (argument_count_ == ANY) {
     Label zero_case, n_case;
@@ skipping 173 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64