[arm64] Use exclusive instructions in exchange

src/arm64/instrument-arm64.cc

 // 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.
 
 #include "src/arm64/instrument-arm64.h"
 
 namespace v8 {
 namespace internal {
 
 Counter::Counter(const char* name, CounterType type)
@@ skipping 43 matching lines @@
 CounterType Counter::type() {
   return type_;
 }
 
 
 typedef struct {
   const char* name;
   CounterType type;
 } CounterDescriptor;
 
+static const CounterDescriptor kCounterList[] = {
+    {"Instruction", Cumulative},
 
-static const CounterDescriptor kCounterList[] = {
-  {"Instruction", Cumulative},
+    {"Move Immediate", Gauge},
+    {"Add/Sub DP", Gauge},
+    {"Logical DP", Gauge},
+    {"Other Int DP", Gauge},
+    {"FP DP", Gauge},
 
-  {"Move Immediate", Gauge},
-  {"Add/Sub DP", Gauge},
-  {"Logical DP", Gauge},
-  {"Other Int DP", Gauge},
-  {"FP DP", Gauge},
+    {"Conditional Select", Gauge},
+    {"Conditional Compare", Gauge},
 
-  {"Conditional Select", Gauge},
-  {"Conditional Compare", Gauge},
+    {"Unconditional Branch", Gauge},
+    {"Compare and Branch", Gauge},
+    {"Test and Branch", Gauge},
+    {"Conditional Branch", Gauge},
 
-  {"Unconditional Branch", Gauge},
-  {"Compare and Branch", Gauge},
-  {"Test and Branch", Gauge},
-  {"Conditional Branch", Gauge},
+    {"Load Integer", Gauge},
+    {"Load FP", Gauge},
+    {"Load Pair", Gauge},
+    {"Load Literal", Gauge},
+    {"Load Exclusive", Gauge},
+    {"Load Acquire", Gauge},
 
-  {"Load Integer", Gauge},
-  {"Load FP", Gauge},
-  {"Load Pair", Gauge},
-  {"Load Literal", Gauge},
+    {"Store Integer", Gauge},
+    {"Store FP", Gauge},
+    {"Store Pair", Gauge},
+    {"Store Exclusive", Gauge},
+    {"Store Release", Gauge},
 
-  {"Store Integer", Gauge},
-  {"Store FP", Gauge},
-  {"Store Pair", Gauge},
-
-  {"PC Addressing", Gauge},
-  {"Other", Gauge},
-  {"SP Adjust", Gauge},
+    {"PC Addressing", Gauge},
+    {"Other", Gauge},
+    {"SP Adjust", Gauge},
 };
 
-
 Instrument::Instrument(const char* datafile, uint64_t sample_period)
     : output_stream_(stderr), sample_period_(sample_period) {
 
   // Set up the output stream. If datafile is non-NULL, use that file. If it
   // can't be opened, or datafile is NULL, use stderr.
   if (datafile != NULL) {
     output_stream_ = fopen(datafile, "w");
     if (output_stream_ == NULL) {
       fprintf(stderr, "Can't open output file %s. Using stderr.\n", datafile);
       output_stream_ = stderr;
@@ skipping 315 matching lines @@
   Update();
   InstrumentLoadStore(instr);
 }
 
 
 void Instrument::VisitLoadStoreUnsignedOffset(Instruction* instr) {
   Update();
   InstrumentLoadStore(instr);
 }
 
+void Instrument::VisitLoadStoreExclusive(Instruction* instr) {
+  Update();
+  static Counter* load_counter = GetCounter("Load Exclusive");
+  static Counter* store_counter = GetCounter("Store Exclusive");
+
+  switch (instr->Mask(LoadStoreAcquireReleaseMask)) {
+    case LDXRB:   // Fall-through.
+    case LDXRH:   // Fall-through.
+    case LDXR_w:  // Fall-through.
+    case LDXR_x:
+      load_counter->Increment();
+      break;
+    case STXRB:   // Fall-through.
+    case STXRH:   // Fall-through.
+    case STXR_w:  // Fall-through.
+    case STXR_x:
+      store_counter->Increment();
+      break;
+    default:
+      UNREACHABLE();
+  }
+}
+
 void Instrument::VisitLoadStoreAcquireRelease(Instruction* instr) {
   Update();
   static Counter* load_counter = GetCounter("Load Acquire");
   static Counter* store_counter = GetCounter("Store Release");
 
   switch (instr->Mask(LoadStoreAcquireReleaseMask)) {
     case LDAR_b:   // Fall-through.
     case LDAR_h:   // Fall-through.
     case LDAR_w:   // Fall-through.
     case LDAR_x:   // Fall-through.
@@ skipping 163 matching lines @@
 
 void Instrument::VisitUnimplemented(Instruction* instr) {
   Update();
   static Counter* counter = GetCounter("Other");
   counter->Increment();
 }
 
 
 }  // namespace internal
 }  // namespace v8