[arm64] Add monitor notifiers to NEON loads and stores.

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 2262 matching lines @@
   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 NotifyLoad();
     void NotifyLoadExcl(uintptr_t addr, TransactionSize size);
-    void NotifyStore(uintptr_t addr);
+    void NotifyStore();
     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);
+      void NotifyStore_Locked(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);
+    void NotifyStore_Locked(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_;
@@ skipping 100 matching lines @@
     Simulator::current(isolate)->PopAddress();
   }
 };
 
 #endif  // !defined(USE_SIMULATOR)
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_ARM64_SIMULATOR_ARM64_H_