A64: Synchronize with r18256.

src/a64/macro-assembler-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 30 matching lines @@
 
 // Define a fake double underscore to use with the ASM_UNIMPLEMENTED macros.
 #define __
 
 
 MacroAssembler::MacroAssembler(Isolate* arg_isolate,
                                byte * buffer,
                                unsigned buffer_size)
     : Assembler(arg_isolate, buffer, buffer_size),
       generating_stub_(false),
-      allow_stub_calls_(true),
 #if DEBUG
       allow_macro_instructions_(true),
 #endif
       has_frame_(false),
       use_real_aborts_(true),
       sp_(jssp), tmp0_(ip0), tmp1_(ip1), fptmp0_(fp_scratch) {
   if (isolate() != NULL) {
     code_object_ = Handle<Object>(isolate()->heap()->undefined_value(),
                                   isolate());
   }
@@ skipping 1211 matching lines @@
 }
 
 
 void MacroAssembler::CallStub(CodeStub* stub, TypeFeedbackId ast_id) {
   ASSERT(AllowThisStubCall(stub));  // Stub calls are not allowed in some stubs.
   Call(stub->GetCode(isolate()), RelocInfo::CODE_TARGET, ast_id);
 }
 
 
 void MacroAssembler::TailCallStub(CodeStub* stub) {
-  ASSERT(allow_stub_calls_ ||
-         stub->CompilingCallsToThisStubIsGCSafe(isolate()));
   Jump(stub->GetCode(isolate()), RelocInfo::CODE_TARGET);
 }
 
 
 void MacroAssembler::CallRuntime(const Runtime::Function* f,
                                  int num_arguments,
                                  SaveFPRegsMode save_doubles) {
   // All arguments must be on the stack before this function is called.
   // x0 holds the return value after the call.
 
@@ skipping 1192 matching lines @@
         FieldMemOperand(expected_reg,
                         SharedFunctionInfo::kFormalParameterCountOffset));
   Ldr(code_reg,
       FieldMemOperand(function, JSFunction::kCodeEntryOffset));
 
   ParameterCount expected(expected_reg);
   InvokeCode(code_reg, expected, actual, flag, call_wrapper, call_kind);
 }
 
 
+void MacroAssembler::InvokeFunction(Register function,
+                                    const ParameterCount& expected,
+                                    const ParameterCount& actual,
+                                    InvokeFlag flag,
+                                    const CallWrapper& call_wrapper,
+                                    CallKind call_kind) {
+  // You can't call a function without a valid frame.
+  ASSERT(flag == JUMP_FUNCTION || has_frame());
+
+  // Contract with called JS functions requires that function is passed in x1.
+  // (See FullCodeGenerator::Generate().)
+  ASSERT(function.Is(x1));
+
+  Register code_reg = x3;
+
+  // Set up the context.
+  Ldr(cp, FieldMemOperand(function, JSFunction::kContextOffset));
+
+  // We call indirectly through the code field in the function to
+  // allow recompilation to take effect without changing any of the
+  // call sites.
+  Ldr(code_reg, FieldMemOperand(function, JSFunction::kCodeEntryOffset));
+  InvokeCode(code_reg, expected, actual, flag, call_wrapper, call_kind);
+}
+
+
 void MacroAssembler::InvokeFunction(Handle<JSFunction> function,
                                     const ParameterCount& expected,
                                     const ParameterCount& actual,
                                     InvokeFlag flag,
                                     const CallWrapper& call_wrapper,
-                                    CallKind call_kind,
-                                    Register function_reg) {
-  // You can't call a function without a valid frame.
-  ASSERT(flag == JUMP_FUNCTION || has_frame());
-
-  // Load the function object, if it isn't already loaded.
-  ASSERT(function_reg.Is(x1) || function_reg.IsNone());
-  if (function_reg.IsNone()) {
-    function_reg = x1;
-    LoadObject(function_reg, function);
-  }
-
-  Register code_reg = x3;
-
-  // Set up the context.
-  Ldr(cp, FieldMemOperand(function_reg, JSFunction::kContextOffset));
-
-  // We call indirectly through the code field in the function to
-  // allow recompilation to take effect without changing any of the
-  // call sites.
-  Ldr(code_reg, FieldMemOperand(function_reg, JSFunction::kCodeEntryOffset));
-  InvokeCode(code_reg, expected, actual, flag, call_wrapper, call_kind);
+                                    CallKind call_kind) {
+  // Contract with called JS functions requires that function is passed in x1.
+  // (See FullCodeGenerator::Generate().)
+  __ LoadObject(x1, function);
+  InvokeFunction(x1, expected, actual, flag, call_wrapper, call_kind);
 }
 
 
 void MacroAssembler::ECMA262ToInt32(Register result,
                                     DoubleRegister input,
                                     Register scratch1,
                                     Register scratch2,
                                     ECMA262ToInt32Result format) {
   ASSERT(!AreAliased(result, scratch1, scratch2));
   ASSERT(result.Is64Bits() && scratch1.Is64Bits() && scratch2.Is64Bits());
@@ skipping 1067 matching lines @@
 
   // Store the result.
   Bind(&store_num);
   Add(scratch1, elements_reg,
       Operand::UntagSmiAndScale(key_reg, kDoubleSizeLog2));
   Str(fpscratch1, FieldMemOperand(scratch1, FixedDoubleArray::kHeaderSize));
 }
 
 
 bool MacroAssembler::AllowThisStubCall(CodeStub* stub) {
-  if (!has_frame_ && stub->SometimesSetsUpAFrame()) return false;
-  return allow_stub_calls_ || stub->CompilingCallsToThisStubIsGCSafe(isolate());
+  return has_frame_ || !stub->SometimesSetsUpAFrame();
 }
 
 
 void MacroAssembler::IndexFromHash(Register hash, Register index) {
   // If the hash field contains an array index pick it out. The assert checks
   // that the constants for the maximum number of digits for an array index
   // cached in the hash field and the number of bits reserved for it does not
   // conflict.
   ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) <
          (1 << String::kArrayIndexValueBits));
@@ skipping 334 matching lines @@
 
 
 void MacroAssembler::RecordWriteField(
     Register object,
     int offset,
     Register value,
     Register scratch,
     LinkRegisterStatus lr_status,
     SaveFPRegsMode save_fp,
     RememberedSetAction remembered_set_action,
-    SmiCheck smi_check,
-    PregenExpectation pregen_expectation) {
+    SmiCheck smi_check) {
   // First, check if a write barrier is even needed. The tests below
   // catch stores of Smis.
   Label done;
 
   // Skip the barrier if writing a smi.
   if (smi_check == INLINE_SMI_CHECK) {
     JumpIfSmi(value, &done);
   }
 
   // Although the object register is tagged, the offset is relative to the start
   // of the object, so offset must be a multiple of kPointerSize.
   ASSERT(IsAligned(offset, kPointerSize));
 
   Add(scratch, object, offset - kHeapObjectTag);
   if (emit_debug_code()) {
     Label ok;
     Tst(scratch, (1 << kPointerSizeLog2) - 1);
     B(eq, &ok);
     Abort(kUnalignedCellInWriteBarrier);
     Bind(&ok);
   }
 
   RecordWrite(object,
               scratch,
               value,
               lr_status,
               save_fp,
               remembered_set_action,
-              OMIT_SMI_CHECK,
-              pregen_expectation);
+              OMIT_SMI_CHECK);
 
   Bind(&done);
 
   // Clobber clobbered input registers when running with the debug-code flag
   // turned on to provoke errors.
   if (emit_debug_code()) {
     Mov(value, Operand(BitCast<int64_t>(kZapValue + 4)));
     Mov(scratch, Operand(BitCast<int64_t>(kZapValue + 8)));
   }
 }
 
 
 // Will clobber: object, address, value, Tmp0(), Tmp1().
 // If lr_status is kLRHasBeenSaved, lr will also be clobbered.
 //
 // The register 'object' contains a heap object pointer. The heap object tag is
 // shifted away.
-//
-// If pregen_expectation is EXPECT_PREGENERATED, this will assert that the
-// stub used was pregenerated. This is done to ensure that
-// RecordWriteStub::kAheadOfTime stays in sync with real usage. If
-// pregen_expectation is false, no assertion is made, since another call site
-// might pregenerate the stub with the same parameters.
 void MacroAssembler::RecordWrite(Register object,
                                  Register address,
                                  Register value,
                                  LinkRegisterStatus lr_status,
                                  SaveFPRegsMode fp_mode,
                                  RememberedSetAction remembered_set_action,
-                                 SmiCheck smi_check,
-                                 PregenExpectation pregen_expectation) {
+                                 SmiCheck smi_check) {
   // The compiled code assumes that record write doesn't change the
   // context register, so we check that none of the clobbered
   // registers are cp.
   ASSERT(!address.is(cp) && !value.is(cp));
 
   if (emit_debug_code()) {
     Ldr(Tmp0(), MemOperand(address));
     Cmp(Tmp0(), value);
     Check(eq, kWrongAddressOrValuePassedToRecordWrite);
   }
@@ skipping 18 matching lines @@
   CheckPageFlagClear(object,
                      value,  // Used as scratch.
                      MemoryChunk::kPointersFromHereAreInterestingMask,
                      &done);
 
   // Record the actual write.
   if (lr_status == kLRHasNotBeenSaved) {
     Push(lr);
   }
   RecordWriteStub stub(object, value, address, remembered_set_action, fp_mode);
-  if (pregen_expectation == EXPECT_PREGENERATED) {
-    // If we expected a pregenerated stub, ensure that we get one.
-    // A failure at this assertion probably indicates that the
-    // RecordWriteStub::kAheadOfTime list needs to be updated.
-    ASSERT(stub.IsPregenerated(isolate()));
-  }
   CallStub(&stub);
   if (lr_status == kLRHasNotBeenSaved) {
     Pop(lr);
   }
 
   Bind(&done);
 
   // Clobber clobbered registers when running with the debug-code flag
   // turned on to provoke errors.
   if (emit_debug_code()) {
@@ skipping 766 matching lines @@
   }
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64