simulator-mips.h 20.7 KB
Newer Older
1
// Copyright 2011 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4 5 6 7

// Declares a Simulator for MIPS instructions if we are not generating a native
// MIPS binary. This Simulator allows us to run and debug MIPS code generation
// on regular desktop machines.
8
// V8 calls into generated code via the GeneratedCode wrapper,
9 10 11 12 13 14
// which will start execution in the Simulator or forwards to the real entry
// on a MIPS HW platform.

#ifndef V8_MIPS_SIMULATOR_MIPS_H_
#define V8_MIPS_SIMULATOR_MIPS_H_

15 16
// globals.h defines USE_SIMULATOR.
#include "src/globals.h"
17

18
#if defined(USE_SIMULATOR)
19
// Running with a simulator.
20

21
#include "src/allocation.h"
lpy's avatar
lpy committed
22
#include "src/base/hashmap.h"
23
#include "src/codegen/assembler.h"
24
#include "src/execution/simulator-base.h"
25
#include "src/mips/constants-mips.h"
26

27 28
namespace v8 {
namespace internal {
29

30 31
// -----------------------------------------------------------------------------
// Utility functions
32

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
class CachePage {
 public:
  static const int LINE_VALID = 0;
  static const int LINE_INVALID = 1;

  static const int kPageShift = 12;
  static const int kPageSize = 1 << kPageShift;
  static const int kPageMask = kPageSize - 1;
  static const int kLineShift = 2;  // The cache line is only 4 bytes right now.
  static const int kLineLength = 1 << kLineShift;
  static const int kLineMask = kLineLength - 1;

  CachePage() {
    memset(&validity_map_, LINE_INVALID, sizeof(validity_map_));
  }
48

49 50 51
  char* ValidityByte(int offset) {
    return &validity_map_[offset >> kLineShift];
  }
52

53 54 55
  char* CachedData(int offset) {
    return &data_[offset];
  }
56

57 58 59 60 61
 private:
  char data_[kPageSize];   // The cached data.
  static const int kValidityMapSize = kPageSize >> kLineShift;
  char validity_map_[kValidityMapSize];  // One byte per line.
};
62

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
class SimInstructionBase : public InstructionBase {
 public:
  Type InstructionType() const { return type_; }
  inline Instruction* instr() const { return instr_; }
  inline int32_t operand() const { return operand_; }

 protected:
  SimInstructionBase() : operand_(-1), instr_(nullptr), type_(kUnsupported) {}
  explicit SimInstructionBase(Instruction* instr) {}

  int32_t operand_;
  Instruction* instr_;
  Type type_;

 private:
  DISALLOW_ASSIGN(SimInstructionBase);
};

class SimInstruction : public InstructionGetters<SimInstructionBase> {
 public:
  SimInstruction() {}

  explicit SimInstruction(Instruction* instr) { *this = instr; }

  SimInstruction& operator=(Instruction* instr) {
    operand_ = *reinterpret_cast<const int32_t*>(instr);
    instr_ = instr;
90
    type_ = InstructionBase::InstructionType();
91 92 93 94 95
    DCHECK(reinterpret_cast<void*>(&operand_) == this);
    return *this;
  }
};

96
class Simulator : public SimulatorBase {
97
 public:
98
  friend class MipsDebugger;
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

  // Registers are declared in order. See SMRL chapter 2.
  enum Register {
    no_reg = -1,
    zero_reg = 0,
    at,
    v0, v1,
    a0, a1, a2, a3,
    t0, t1, t2, t3, t4, t5, t6, t7,
    s0, s1, s2, s3, s4, s5, s6, s7,
    t8, t9,
    k0, k1,
    gp,
    sp,
    s8,
    ra,
115
    // LO, HI, and pc.
116 117 118 119 120 121 122 123 124 125 126 127
    LO,
    HI,
    pc,   // pc must be the last register.
    kNumSimuRegisters,
    // aliases
    fp = s8
  };

  // Coprocessor registers.
  // Generated code will always use doubles. So we will only use even registers.
  enum FPURegister {
    f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11,
128
    f12, f13, f14, f15,   // f12 and f14 are arguments FPURegisters.
129 130 131 132 133
    f16, f17, f18, f19, f20, f21, f22, f23, f24, f25,
    f26, f27, f28, f29, f30, f31,
    kNumFPURegisters
  };

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
  // MSA registers
  enum MSARegister {
    w0,
    w1,
    w2,
    w3,
    w4,
    w5,
    w6,
    w7,
    w8,
    w9,
    w10,
    w11,
    w12,
    w13,
    w14,
    w15,
    w16,
    w17,
    w18,
    w19,
    w20,
    w21,
    w22,
    w23,
    w24,
    w25,
    w26,
    w27,
    w28,
    w29,
    w30,
    w31,
    kNumMSARegisters
  };

171
  explicit Simulator(Isolate* isolate);
172 173 174 175
  ~Simulator();

  // The currently executing Simulator instance. Potentially there can be one
  // for each native thread.
176
  V8_EXPORT_PRIVATE static Simulator* current(v8::internal::Isolate* isolate);
177 178 179 180 181

  // Accessors for register state. Reading the pc value adheres to the MIPS
  // architecture specification and is off by a 8 from the currently executing
  // instruction.
  void set_register(int reg, int32_t value);
182
  void set_dw_register(int dreg, const int* dbl);
183
  int32_t get_register(int reg) const;
184
  double get_double_from_register_pair(int reg);
185
  // Same for FPURegisters.
186 187 188
  void set_fpu_register(int fpureg, int64_t value);
  void set_fpu_register_word(int fpureg, int32_t value);
  void set_fpu_register_hi_word(int fpureg, int32_t value);
189
  void set_fpu_register_float(int fpureg, float value);
190
  void set_fpu_register_double(int fpureg, double value);
191 192 193 194 195 196
  void set_fpu_register_invalid_result64(float original, float rounded);
  void set_fpu_register_invalid_result(float original, float rounded);
  void set_fpu_register_word_invalid_result(float original, float rounded);
  void set_fpu_register_invalid_result64(double original, double rounded);
  void set_fpu_register_invalid_result(double original, double rounded);
  void set_fpu_register_word_invalid_result(double original, double rounded);
197 198 199 200
  int64_t get_fpu_register(int fpureg) const;
  int32_t get_fpu_register_word(int fpureg) const;
  int32_t get_fpu_register_signed_word(int fpureg) const;
  int32_t get_fpu_register_hi_word(int fpureg) const;
201
  float get_fpu_register_float(int fpureg) const;
202
  double get_fpu_register_double(int fpureg) const;
203 204 205 206
  template <typename T>
  void get_msa_register(int wreg, T* value);
  template <typename T>
  void set_msa_register(int wreg, const T* value);
207 208
  void set_fcsr_bit(uint32_t cc, bool value);
  bool test_fcsr_bit(uint32_t cc);
209
  void set_fcsr_rounding_mode(FPURoundingMode mode);
210
  void set_msacsr_rounding_mode(FPURoundingMode mode);
211
  unsigned int get_fcsr_rounding_mode();
212
  unsigned int get_msacsr_rounding_mode();
213
  bool set_fcsr_round_error(double original, double rounded);
214 215 216
  bool set_fcsr_round_error(float original, float rounded);
  bool set_fcsr_round64_error(double original, double rounded);
  bool set_fcsr_round64_error(float original, float rounded);
217 218
  void round_according_to_fcsr(double toRound, double& rounded,
                               int32_t& rounded_int, double fs);
219 220
  void round_according_to_fcsr(float toRound, float& rounded,
                               int32_t& rounded_int, float fs);
221 222
  template <typename Tfp, typename Tint>
  void round_according_to_msacsr(Tfp toRound, Tfp& rounded, Tint& rounded_int);
223 224 225 226
  void round64_according_to_fcsr(double toRound, double& rounded,
                                 int64_t& rounded_int, double fs);
  void round64_according_to_fcsr(float toRound, float& rounded,
                                 int64_t& rounded_int, float fs);
227 228 229 230
  // Special case of set_register and get_register to access the raw PC value.
  void set_pc(int32_t value);
  int32_t get_pc() const;

231
  Address get_sp() const { return static_cast<Address>(get_register(sp)); }
232

233
  // Accessor to the internal simulator stack area.
234
  uintptr_t StackLimit(uintptr_t c_limit) const;
235 236 237 238

  // Executes MIPS instructions until the PC reaches end_sim_pc.
  void Execute();

239
  template <typename Return, typename... Args>
240
  Return Call(Address entry, Args... args) {
241 242 243
    return VariadicCall<Return>(this, &Simulator::CallImpl, entry, args...);
  }

244
  // Alternative: call a 2-argument double function.
245
  double CallFP(Address entry, double d0, double d1);
246 247 248 249 250 251 252

  // Push an address onto the JS stack.
  uintptr_t PushAddress(uintptr_t address);

  // Pop an address from the JS stack.
  uintptr_t PopAddress();

253 254 255 256
  // Debugger input.
  void set_last_debugger_input(char* input);
  char* last_debugger_input() { return last_debugger_input_; }

257 258 259
  // Redirection support.
  static void SetRedirectInstruction(Instruction* instruction);

260
  // ICache checking.
261
  static bool ICacheMatch(void* one, void* two);
262 263
  static void FlushICache(base::CustomMatcherHashMap* i_cache, void* start,
                          size_t size);
264 265 266 267 268

  // Returns true if pc register contains one of the 'special_values' defined
  // below (bad_ra, end_sim_pc).
  bool has_bad_pc() const;

269 270 271 272 273 274 275 276 277 278 279 280 281 282
 private:
  enum special_values {
    // Known bad pc value to ensure that the simulator does not execute
    // without being properly setup.
    bad_ra = -1,
    // A pc value used to signal the simulator to stop execution.  Generally
    // the ra is set to this value on transition from native C code to
    // simulated execution, so that the simulator can "return" to the native
    // C code.
    end_sim_pc = -2,
    // Unpredictable value.
    Unpredictable = 0xbadbeaf
  };

283
  V8_EXPORT_PRIVATE intptr_t CallImpl(Address entry, int argument_count,
284
                                      const intptr_t* arguments);
285

286 287 288
  // Unsupported instructions use Format to print an error and stop execution.
  void Format(Instruction* instr, const char* format);

289 290 291
  // Helpers for data value tracing.
  enum TraceType { BYTE, HALF, WORD, DWORD, FLOAT, DOUBLE, FLOAT_DOUBLE };

292 293
  // MSA Data Format
  enum MSADataFormat { MSA_VECT = 0, MSA_BYTE, MSA_HALF, MSA_WORD, MSA_DWORD };
294 295
  typedef union {
    int8_t b[kMSALanesByte];
296
    uint8_t ub[kMSALanesByte];
297
    int16_t h[kMSALanesHalf];
298
    uint16_t uh[kMSALanesHalf];
299
    int32_t w[kMSALanesWord];
300
    uint32_t uw[kMSALanesWord];
301
    int64_t d[kMSALanesDword];
302
    uint64_t ud[kMSALanesDword];
303
  } msa_reg_t;
304

305 306 307 308 309 310 311 312 313 314 315 316
  // Read and write memory.
  inline uint32_t ReadBU(int32_t addr);
  inline int32_t ReadB(int32_t addr);
  inline void WriteB(int32_t addr, uint8_t value);
  inline void WriteB(int32_t addr, int8_t value);

  inline uint16_t ReadHU(int32_t addr, Instruction* instr);
  inline int16_t ReadH(int32_t addr, Instruction* instr);
  // Note: Overloaded on the sign of the value.
  inline void WriteH(int32_t addr, uint16_t value, Instruction* instr);
  inline void WriteH(int32_t addr, int16_t value, Instruction* instr);

317
  inline int ReadW(int32_t addr, Instruction* instr, TraceType t = WORD);
318
  inline void WriteW(int32_t addr, int value, Instruction* instr);
319 320
  void WriteConditionalW(int32_t addr, int32_t value, Instruction* instr,
                         int32_t rt_reg);
321 322 323 324

  inline double ReadD(int32_t addr, Instruction* instr);
  inline void WriteD(int32_t addr, double value, Instruction* instr);

325 326 327 328 329 330
  template <typename T>
  T ReadMem(int32_t addr, Instruction* instr);

  template <typename T>
  void WriteMem(int32_t addr, T value, Instruction* instr);

331 332
  void TraceRegWr(int32_t value, TraceType t = WORD);
  void TraceRegWr(int64_t value, TraceType t = DWORD);
333 334
  template <typename T>
  void TraceMSARegWr(T* value, TraceType t);
335 336
  template <typename T>
  void TraceMSARegWr(T* value);
337 338 339 340
  void TraceMemWr(int32_t addr, int32_t value, TraceType t = WORD);
  void TraceMemRd(int32_t addr, int32_t value, TraceType t = WORD);
  void TraceMemWr(int32_t addr, int64_t value, TraceType t = DWORD);
  void TraceMemRd(int32_t addr, int64_t value, TraceType t = DWORD);
341 342 343 344
  template <typename T>
  void TraceMemRd(int32_t addr, T value);
  template <typename T>
  void TraceMemWr(int32_t addr, T value);
345 346
  EmbeddedVector<char, 128> trace_buf_;

347 348 349 350 351 352 353 354
  // Operations depending on endianness.
  // Get Double Higher / Lower word.
  inline int32_t GetDoubleHIW(double* addr);
  inline int32_t GetDoubleLOW(double* addr);
  // Set Double Higher / Lower word.
  inline int32_t SetDoubleHIW(double* addr);
  inline int32_t SetDoubleLOW(double* addr);

355 356
  SimInstruction instr_;

357
  // Executing is handled based on the instruction type.
358
  void DecodeTypeRegister();
359

360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
  // Functions called from DecodeTypeRegister.
  void DecodeTypeRegisterCOP1();

  void DecodeTypeRegisterCOP1X();

  void DecodeTypeRegisterSPECIAL();

  void DecodeTypeRegisterSPECIAL2();

  void DecodeTypeRegisterSPECIAL3();

  // Called from DecodeTypeRegisterCOP1.
  void DecodeTypeRegisterSRsType();

  void DecodeTypeRegisterDRsType();

  void DecodeTypeRegisterWRsType();

  void DecodeTypeRegisterLRsType();

380 381 382 383 384 385 386 387 388 389 390 391
  int DecodeMsaDataFormat();
  void DecodeTypeMsaI8();
  void DecodeTypeMsaI5();
  void DecodeTypeMsaI10();
  void DecodeTypeMsaELM();
  void DecodeTypeMsaBIT();
  void DecodeTypeMsaMI10();
  void DecodeTypeMsa3R();
  void DecodeTypeMsa3RF();
  void DecodeTypeMsaVec();
  void DecodeTypeMsa2R();
  void DecodeTypeMsa2RF();
392 393
  template <typename T>
  T MsaI5InstrHelper(uint32_t opcode, T ws, int32_t i5);
394 395
  template <typename T>
  T MsaBitInstrHelper(uint32_t opcode, T wd, T ws, int32_t m);
396 397
  template <typename T>
  T Msa3RInstrHelper(uint32_t opcode, T wd, T ws, T wt);
398

399
  inline int32_t rs_reg() const { return instr_.RsValue(); }
400 401 402 403
  inline int32_t rs() const { return get_register(rs_reg()); }
  inline uint32_t rs_u() const {
    return static_cast<uint32_t>(get_register(rs_reg()));
  }
404
  inline int32_t rt_reg() const { return instr_.RtValue(); }
405 406 407 408
  inline int32_t rt() const { return get_register(rt_reg()); }
  inline uint32_t rt_u() const {
    return static_cast<uint32_t>(get_register(rt_reg()));
  }
409 410 411 412 413 414 415
  inline int32_t rd_reg() const { return instr_.RdValue(); }
  inline int32_t fr_reg() const { return instr_.FrValue(); }
  inline int32_t fs_reg() const { return instr_.FsValue(); }
  inline int32_t ft_reg() const { return instr_.FtValue(); }
  inline int32_t fd_reg() const { return instr_.FdValue(); }
  inline int32_t sa() const { return instr_.SaValue(); }
  inline int32_t lsa_sa() const { return instr_.LsaSaValue(); }
416 417 418
  inline int32_t ws_reg() const { return instr_.WsValue(); }
  inline int32_t wt_reg() const { return instr_.WtValue(); }
  inline int32_t wd_reg() const { return instr_.WdValue(); }
419 420 421 422 423

  inline void SetResult(int32_t rd_reg, int32_t alu_out) {
    set_register(rd_reg, alu_out);
    TraceRegWr(alu_out);
  }
424

425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
  inline void SetFPUWordResult(int32_t fd_reg, int32_t alu_out) {
    set_fpu_register_word(fd_reg, alu_out);
    TraceRegWr(get_fpu_register_word(fd_reg));
  }

  inline void SetFPUResult(int32_t fd_reg, int64_t alu_out) {
    set_fpu_register(fd_reg, alu_out);
    TraceRegWr(get_fpu_register(fd_reg));
  }

  inline void SetFPUFloatResult(int32_t fd_reg, float alu_out) {
    set_fpu_register_float(fd_reg, alu_out);
    TraceRegWr(get_fpu_register_word(fd_reg), FLOAT);
  }

  inline void SetFPUDoubleResult(int32_t fd_reg, double alu_out) {
    set_fpu_register_double(fd_reg, alu_out);
    TraceRegWr(get_fpu_register(fd_reg), DOUBLE);
  }

445 446
  void DecodeTypeImmediate();
  void DecodeTypeJump();
447 448

  // Used for breakpoints and traps.
449
  void SoftwareInterrupt();
450

451 452
  // Compact branch guard.
  void CheckForbiddenSlot(int32_t current_pc) {
453
    Instruction* instr_after_compact_branch =
454
        reinterpret_cast<Instruction*>(current_pc + kInstrSize);
455
    if (instr_after_compact_branch->IsForbiddenAfterBranch()) {
456 457 458 459
      FATAL(
          "Error: Unexpected instruction 0x%08x immediately after a "
          "compact branch instruction.",
          *reinterpret_cast<uint32_t*>(instr_after_compact_branch));
460 461 462
    }
  }

463 464 465 466 467 468 469 470 471 472 473 474
  // Stop helper functions.
  bool IsWatchpoint(uint32_t code);
  void PrintWatchpoint(uint32_t code);
  void HandleStop(uint32_t code, Instruction* instr);
  bool IsStopInstruction(Instruction* instr);
  bool IsEnabledStop(uint32_t code);
  void EnableStop(uint32_t code);
  void DisableStop(uint32_t code);
  void IncreaseStopCounter(uint32_t code);
  void PrintStopInfo(uint32_t code);


475 476 477 478
  // Executes one instruction.
  void InstructionDecode(Instruction* instr);
  // Execute one instruction placed in a branch delay slot.
  void BranchDelayInstructionDecode(Instruction* instr) {
479 480 481 482 483 484
    if (instr->InstructionBits() == nopInstr) {
      // Short-cut generic nop instructions. They are always valid and they
      // never change the simulator state.
      return;
    }

485
    if (instr->IsForbiddenInBranchDelay()) {
486 487
      FATAL("Eror:Unexpected %i opcode in a branch delay slot.",
            instr->OpcodeValue());
488 489
    }
    InstructionDecode(instr);
490
    SNPrintF(trace_buf_, " ");
491 492
  }

493
  // ICache.
494 495 496 497 498 499
  static void CheckICache(base::CustomMatcherHashMap* i_cache,
                          Instruction* instr);
  static void FlushOnePage(base::CustomMatcherHashMap* i_cache, intptr_t start,
                           int size);
  static CachePage* GetCachePage(base::CustomMatcherHashMap* i_cache,
                                 void* page);
500

501 502 503 504 505 506 507 508 509
  enum Exception {
    none,
    kIntegerOverflow,
    kIntegerUnderflow,
    kDivideByZero,
    kNumExceptions
  };

  // Exceptions.
510
  void SignalException(Exception e);
511

512 513
  // Handle arguments and return value for runtime FP functions.
  void GetFpArgs(double* x, double* y, int32_t* z);
514 515
  void SetFpResult(const double& result);

516
  void CallInternal(Address entry);
517 518 519 520 521

  // Architecture state.
  // Registers.
  int32_t registers_[kNumSimuRegisters];
  // Coprocessor Registers.
522 523
  // Note: FP32 mode uses only the lower 32-bit part of each element,
  // the upper 32-bit is unpredictable.
524 525 526
  // Note: FPUregisters_[] array is increased to 64 * 8B = 32 * 16B in
  // order to support MSA registers
  int64_t FPUregisters_[kNumFPURegisters * 2];
527 528
  // FPU control register.
  uint32_t FCSR_;
529 530
  // MSA control register.
  uint32_t MSACSR_;
531 532

  // Simulator support.
533 534
  // Allocate 1MB for stack.
  static const size_t stack_size_ = 1 * 1024*1024;
535 536
  char* stack_;
  bool pc_modified_;
537
  uint64_t icount_;
538 539
  int break_count_;

540 541 542
  // Debugger input.
  char* last_debugger_input_;

543 544
  v8::internal::Isolate* isolate_;

545 546 547
  // Registered breakpoints.
  Instruction* break_pc_;
  Instr break_instr_;
548 549 550 551 552

  // Stop is disabled if bit 31 is set.
  static const uint32_t kStopDisabledBit = 1 << 31;

  // A stop is enabled, meaning the simulator will stop when meeting the
553 554
  // instruction, if bit 31 of watched_stops_[code].count is unset.
  // The value watched_stops_[code].count & ~(1 << 31) indicates how many times
555 556 557 558 559
  // the breakpoint was hit or gone through.
  struct StopCountAndDesc {
    uint32_t count;
    char* desc;
  };
560
  StopCountAndDesc watched_stops_[kMaxStopCode + 1];
561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636

  // Synchronization primitives.
  enum class MonitorAccess {
    Open,
    RMW,
  };

  enum class TransactionSize {
    None = 0,
    Word = 4,
  };

  // The least-significant bits of the address are ignored. The number of bits
  // is implementation-defined, between 3 and minimum page size.
  static const uintptr_t kExclusiveTaggedAddrMask = ~((1 << 3) - 1);

  class LocalMonitor {
   public:
    LocalMonitor();

    // These functions manage the state machine for the local monitor, but do
    // not actually perform loads and stores. NotifyStoreConditional only
    // returns true if the store conditional is allowed; the global monitor will
    // still have to be checked to see whether the memory should be updated.
    void NotifyLoad();
    void NotifyLoadLinked(uintptr_t addr, TransactionSize size);
    void NotifyStore();
    bool NotifyStoreConditional(uintptr_t addr, TransactionSize size);

   private:
    void Clear();

    MonitorAccess access_state_;
    uintptr_t tagged_addr_;
    TransactionSize size_;
  };

  class GlobalMonitor {
   public:
    class LinkedAddress {
     public:
      LinkedAddress();

     private:
      friend class GlobalMonitor;
      // These functions manage the state machine for the global monitor, but do
      // not actually perform loads and stores.
      void Clear_Locked();
      void NotifyLoadLinked_Locked(uintptr_t addr);
      void NotifyStore_Locked();
      bool NotifyStoreConditional_Locked(uintptr_t addr,
                                         bool is_requesting_thread);

      MonitorAccess access_state_;
      uintptr_t tagged_addr_;
      LinkedAddress* next_;
      LinkedAddress* prev_;
      // A scd can fail due to background cache evictions. Rather than
      // simulating this, we'll just occasionally introduce cases where an
      // store conditional fails. This will happen once after every
      // kMaxFailureCounter exclusive stores.
      static const int kMaxFailureCounter = 5;
      int failure_counter_;
    };

    // Exposed so it can be accessed by Simulator::{Read,Write}Ex*.
    base::Mutex mutex;

    void NotifyLoadLinked_Locked(uintptr_t addr, LinkedAddress* linked_address);
    void NotifyStore_Locked(LinkedAddress* linked_address);
    bool NotifyStoreConditional_Locked(uintptr_t addr,
                                       LinkedAddress* linked_address);

    // Called when the simulator is destroyed.
    void RemoveLinkedAddress(LinkedAddress* linked_address);

637 638
    static GlobalMonitor* Get();

639
   private:
640 641 642 643
    // Private constructor. Call {GlobalMonitor::Get()} to get the singleton.
    GlobalMonitor() = default;
    friend class base::LeakyObject<GlobalMonitor>;

644 645 646
    bool IsProcessorInLinkedList_Locked(LinkedAddress* linked_address) const;
    void PrependProcessor_Locked(LinkedAddress* linked_address);

647
    LinkedAddress* head_ = nullptr;
648 649 650 651
  };

  LocalMonitor local_monitor_;
  GlobalMonitor::LinkedAddress global_monitor_thread_;
652 653
};

654 655
}  // namespace internal
}  // namespace v8
656

657
#endif  // defined(USE_SIMULATOR)
658
#endif  // V8_MIPS_SIMULATOR_MIPS_H_