Disentangle assembler from isolate.

src/x64/macro-assembler-x64.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_X64_MACRO_ASSEMBLER_X64_H_
 #define V8_X64_MACRO_ASSEMBLER_X64_H_
 
-#include "src/assembler.h"
 #include "src/bailout-reason.h"
 #include "src/base/flags.h"
 #include "src/frames.h"
 #include "src/globals.h"
 #include "src/x64/assembler-x64.h"
 #include "src/x64/frames-x64.h"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 67 matching lines @@
   ScaleFactor scale;
 };
 
 
 // MacroAssembler implements a collection of frequently used macros.
 class MacroAssembler: public Assembler {
  public:
   MacroAssembler(Isolate* isolate, void* buffer, int size,
                  CodeObjectRequired create_code_object);
 
+  int jit_cookie() const { return jit_cookie_; }
+
   // Prevent the use of the RootArray during the lifetime of this
   // scope object.
   class NoRootArrayScope BASE_EMBEDDED {
    public:
     explicit NoRootArrayScope(MacroAssembler* assembler)
         : variable_(&assembler->root_array_available_),
           old_value_(assembler->root_array_available_) {
       assembler->root_array_available_ = false;
     }
     ~NoRootArrayScope() {
       *variable_ = old_value_;
     }
    private:
     bool* variable_;
     bool old_value_;
   };
 
+  Isolate* isolate() const { return isolate_; }
+
   // Operand pointing to an external reference.
   // May emit code to set up the scratch register. The operand is
   // only guaranteed to be correct as long as the scratch register
   // isn't changed.
   // If the operand is used more than once, use a scratch register
   // that is guaranteed not to be clobbered.
   Operand ExternalOperand(ExternalReference reference,
                           Register scratch = kScratchRegister);
   // Loads and stores the value of an external reference.
   // Special case code for load and store to take advantage of
@@ skipping 1401 matching lines @@
 
  private:
   // Order general registers are pushed by Pushad.
   // rax, rcx, rdx, rbx, rsi, rdi, r8, r9, r11, r12, r14, r15.
   static const int kSafepointPushRegisterIndices[Register::kNumRegisters];
   static const int kNumSafepointSavedRegisters = 12;
   static const int kSmiShift = kSmiTagSize + kSmiShiftSize;
 
   bool generating_stub_;
   bool has_frame_;
+  Isolate* isolate_;
   bool root_array_available_;
+  int jit_cookie_;
 
   // Returns a register holding the smi value. The register MUST NOT be
   // modified. It may be the "smi 1 constant" register.
   Register GetSmiConstant(Smi* value);
 
   int64_t RootRegisterDelta(ExternalReference other);
 
   // Moves the smi value to the destination register.
   void LoadSmiConstant(Register dst, Smi* value);
 
@@ skipping 130 matching lines @@
 inline Operand StackOperandForReturnAddress(int32_t disp) {
   return Operand(rsp, disp);
 }
 
 #define ACCESS_MASM(masm) masm->
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_X64_MACRO_ASSEMBLER_X64_H_