[Atomics] Implement ldaxr/stlxr instructions in ARM64 simulator

src/arm64/simulator-arm64.h

 // Copyright 2013 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_ARM64_SIMULATOR_ARM64_H_
 #define V8_ARM64_SIMULATOR_ARM64_H_
 
 #include <stdarg.h>
 #include <vector>
 
@@ skipping 847 matching lines @@
   static const char* vreg_names[];
 
   // Debugger input.
   void set_last_debugger_input(char* input) {
     DeleteArray(last_debugger_input_);
     last_debugger_input_ = input;
   }
   char* last_debugger_input() { return last_debugger_input_; }
   char* last_debugger_input_;
 
+  // Synchronization primitives. See ARM DDI 0487A.a, B2.10. Pair types not
+  // implemented.
+  enum class MonitorAccess {
+    Open,
+    Exclusive,
+  };
+
+  enum class TransactionSize {
+    None = 0,
+    Byte = 1,
+    HalfWord = 2,
+    Word = 4,
+  };
+
+  TransactionSize get_transaction_size(unsigned size);
+
+  // The least-significant bits of the address are ignored. The number of bits
+  // is implementation-defined, between 3 and 11. See ARM DDI 0487A.a, B2.10.3.
+  static const uintptr_t kExclusiveTaggedAddrMask = ~((1 << 11) - 1);
+
+  class LocalMonitor {
+   public:
+    LocalMonitor();
+
+    // These functions manage the state machine for the local monitor, but do
+    // not actually perform loads and stores. NotifyStoreExcl only returns
+    // true if the exclusive store is allowed; the global monitor will still
+    // have to be checked to see whether the memory should be updated.
+    void NotifyLoad(uintptr_t addr);
+    void NotifyLoadExcl(uintptr_t addr, TransactionSize size);
+    void NotifyStore(uintptr_t addr);
+    bool NotifyStoreExcl(uintptr_t addr, TransactionSize size);
+
+   private:
+    void Clear();
+
+    MonitorAccess access_state_;
+    uintptr_t tagged_addr_;
+    TransactionSize size_;
+  };
+
+  class GlobalMonitor {
+   public:
+    GlobalMonitor();
+
+    class Processor {
+     public:
+      Processor();
+
+     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 NotifyLoadExcl_Locked(uintptr_t addr);
+      void NotifyStore_Locked(uintptr_t addr, bool is_requesting_processor);
+      bool NotifyStoreExcl_Locked(uintptr_t addr, bool is_requesting_processor);
+
+      MonitorAccess access_state_;
+      uintptr_t tagged_addr_;
+      Processor* next_;
+      Processor* prev_;
+      // A stxr can fail due to background cache evictions. Rather than
+      // simulating this, we'll just occasionally introduce cases where an
+      // exclusive store 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 NotifyLoadExcl_Locked(uintptr_t addr, Processor* processor);
+    void NotifyStore_Locked(uintptr_t addr, Processor* processor);
+    bool NotifyStoreExcl_Locked(uintptr_t addr, Processor* processor);
+
+    // Called when the simulator is destroyed.
+    void RemoveProcessor(Processor* processor);
+
+   private:
+    bool IsProcessorInLinkedList_Locked(Processor* processor) const;
+    void PrependProcessor_Locked(Processor* processor);
+
+    Processor* head_;
+  };
+
+  LocalMonitor local_monitor_;
+  GlobalMonitor::Processor global_monitor_processor_;
+  static base::LazyInstance<GlobalMonitor>::type global_monitor_;
+
  private:
   void Init(FILE* stream);
 
   int  log_parameters_;
   Isolate* isolate_;
 };
 
 
 // When running with the simulator transition into simulated execution at this
 // point.
@@ skipping 28 matching lines @@
     Simulator::current(isolate)->PopAddress();
   }
 };
 
 #endif  // !defined(USE_SIMULATOR)
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ARM64_SIMULATOR_ARM64_H_