A64: Synchronize with r18256.

src/a64/macro-assembler-a64.h

 // 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 44 matching lines @@
 inline MemOperand FieldMemOperand(Register object, int offset);
 inline MemOperand UntagSmiFieldMemOperand(Register object, int offset);
 
 // Generate a MemOperand for loading a SMI from memory.
 inline MemOperand UntagSmiMemOperand(Register object, int offset);
 
 
 // ----------------------------------------------------------------------------
 // MacroAssembler
 
-enum PregenExpectation { MAYBE_PREGENERATED, EXPECT_PREGENERATED };
 enum RememberedSetAction { EMIT_REMEMBERED_SET, OMIT_REMEMBERED_SET };
 enum SmiCheck { INLINE_SMI_CHECK, OMIT_SMI_CHECK };
 enum LinkRegisterStatus { kLRHasNotBeenSaved, kLRHasBeenSaved };
 enum TargetAddressStorageMode {
   CAN_INLINE_TARGET_ADDRESS,
   NEVER_INLINE_TARGET_ADDRESS
 };
 enum UntagMode { kNotSpeculativeUntag, kSpeculativeUntag };
 enum ArrayHasHoles { kArrayCantHaveHoles, kArrayCanHaveHoles };
 enum CopyHint { kCopyUnknown, kCopyShort, kCopyLong };
@@ skipping 1013 matching lines @@
                   RelocInfo::Mode rmode,
                   InvokeFlag flag,
                   CallKind call_kind);
   // Invoke the JavaScript function in the given register.
   // Changes the current context to the context in the function before invoking.
   void InvokeFunction(Register function,
                       const ParameterCount& actual,
                       InvokeFlag flag,
                       const CallWrapper& call_wrapper,
                       CallKind call_kind);
+  void InvokeFunction(Register function,
+                      const ParameterCount& expected,
+                      const ParameterCount& actual,
+                      InvokeFlag flag,
+                      const CallWrapper& call_wrapper,
+                      CallKind call_kind);
   void InvokeFunction(Handle<JSFunction> function,
                       const ParameterCount& expected,
                       const ParameterCount& actual,
                       InvokeFlag flag,
                       const CallWrapper& call_wrapper,
-                      CallKind call_kind,
-                      Register function_reg = NoReg);
+                      CallKind call_kind);
 
 
   // ---- Floating point helpers ----
 
   enum ECMA262ToInt32Result {
     // Provide an untagged int32_t which can be read using result.W(). That is,
     // the upper 32 bits of result are undefined.
     INT32_IN_W,
 
     // Provide an untagged int32_t which can be read using the 64-bit result
@@ skipping 16 matching lines @@
                                 Register heap_number,
                                 Register scratch1,
                                 Register scratch2,
                                 DoubleRegister double_scratch,
                                 ECMA262ToInt32Result format = INT32_IN_X);
 
   // ---- Code generation helpers ----
 
   void set_generating_stub(bool value) { generating_stub_ = value; }
   bool generating_stub() const { return generating_stub_; }
-  void set_allow_stub_calls(bool value) { allow_stub_calls_ = value; }
-  bool allow_stub_calls() const { return allow_stub_calls_; }
 #if DEBUG
   void set_allow_macro_instructions(bool value) {
     allow_macro_instructions_ = value;
   }
   bool allow_macro_instructions() const { return allow_macro_instructions_; }
 #endif
   bool use_real_aborts() const { return use_real_aborts_; }
   void set_has_frame(bool value) { has_frame_ = value; }
   bool has_frame() const { return has_frame_; }
   bool AllowThisStubCall(CodeStub* stub);
@@ skipping 530 matching lines @@
   // The offset is the offset from the start of the object, not the offset from
   // the tagged HeapObject pointer.  For use with FieldOperand(reg, off).
   void RecordWriteField(
       Register object,
       int offset,
       Register value,
       Register scratch,
       LinkRegisterStatus lr_status,
       SaveFPRegsMode save_fp,
       RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
-      SmiCheck smi_check = INLINE_SMI_CHECK,
-      PregenExpectation pregen_expectation = MAYBE_PREGENERATED);
+      SmiCheck smi_check = INLINE_SMI_CHECK);
 
   // As above, but the offset has the tag presubtracted. For use with
   // MemOperand(reg, off).
   inline void RecordWriteContextSlot(
       Register context,
       int offset,
       Register value,
       Register scratch,
       LinkRegisterStatus lr_status,
       SaveFPRegsMode save_fp,
       RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
-      SmiCheck smi_check = INLINE_SMI_CHECK,
-      PregenExpectation pregen_expectation = MAYBE_PREGENERATED) {
+      SmiCheck smi_check = INLINE_SMI_CHECK) {
     RecordWriteField(context,
                      offset + kHeapObjectTag,
                      value,
                      scratch,
                      lr_status,
                      save_fp,
                      remembered_set_action,
-                     smi_check,
-                     pregen_expectation);
+                     smi_check);
   }
 
   // For a given |object| notify the garbage collector that the slot |address|
   // has been written.  |value| is the object being stored. The value and
   // address registers are clobbered by the operation.
   void RecordWrite(
       Register object,
       Register address,
       Register value,
       LinkRegisterStatus lr_status,
       SaveFPRegsMode save_fp,
       RememberedSetAction remembered_set_action = EMIT_REMEMBERED_SET,
-      SmiCheck smi_check = INLINE_SMI_CHECK,
-      PregenExpectation pregen_expecation = MAYBE_PREGENERATED);
+      SmiCheck smi_check = INLINE_SMI_CHECK);
 
   // Checks the color of an object. If the object is already grey or black
   // then we just fall through, since it is already live. If it is white and
   // we can determine that it doesn't need to be scanned, then we just mark it
   // black and fall through. For the rest we jump to the label so the
   // incremental marker can fix its assumptions.
   void EnsureNotWhite(Register object,
                       Register scratch1,
                       Register scratch2,
                       Register scratch3,
@@ skipping 307 matching lines @@
   //
   // This does not distinguish between +0 and -0, so if this distinction is
   // important it must be checked separately.
   void TryConvertDoubleToInt(Register as_int,
                              FPRegister value,
                              FPRegister scratch_d,
                              Label* on_successful_conversion,
                              Label* on_failed_conversion = NULL);
 
   bool generating_stub_;
-  bool allow_stub_calls_;
 #if DEBUG
   // Tell whether any of the macro instruction can be used. When false the
   // MacroAssembler will assert if a method which can emit a variable number
   // of instructions is called.
   bool allow_macro_instructions_;
 #endif
   bool has_frame_;
 
   // The Abort method should call a V8 runtime function, but the CallRuntime
   // mechanism depends on CEntryStub. If use_real_aborts is false, Abort will
@@ skipping 130 matching lines @@
 #error "Unsupported option"
 #define CODE_COVERAGE_STRINGIFY(x) #x
 #define CODE_COVERAGE_TOSTRING(x) CODE_COVERAGE_STRINGIFY(x)
 #define __FILE_LINE__ __FILE__ ":" CODE_COVERAGE_TOSTRING(__LINE__)
 #define ACCESS_MASM(masm) masm->stop(__FILE_LINE__); masm->
 #else
 #define ACCESS_MASM(masm) masm->
 #endif
 
 #endif  // V8_A64_MACRO_ASSEMBLER_A64_H_