[Atomics] Make Atomics.store a builtin using TF

src/compiler/machine-operator.cc

 // Copyright 2014 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/compiler/machine-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 
@@ skipping 61 matching lines @@
 CheckedStoreRepresentation CheckedStoreRepresentationOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kCheckedStore, op->opcode());
   return OpParameter<CheckedStoreRepresentation>(op);
 }
 
 MachineRepresentation StackSlotRepresentationOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kStackSlot, op->opcode());
   return OpParameter<MachineRepresentation>(op);
 }
 
+MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
+  DCHECK_EQ(IrOpcode::kAtomicStore, op->opcode());
+  return OpParameter<MachineRepresentation>(op);
+}
+
 #define PURE_OP_LIST(V)                                                       \
   V(Word32And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
   V(Word32Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)       \
   V(Word32Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
   V(Word32Shl, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word32Shr, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word32Sar, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word32Ror, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word32Equal, Operator::kCommutative, 2, 0, 1)                             \
   V(Word32Clz, Operator::kNoProperties, 1, 0, 1)                              \
@@ skipping 317 matching lines @@
   V(kTagged)
 
 #define ATOMIC_TYPE_LIST(V) \
   V(Int8)                   \
   V(Uint8)                  \
   V(Int16)                  \
   V(Uint16)                 \
   V(Int32)                  \
   V(Uint32)
 
+#define ATOMIC_REPRESENTATION_LIST(V) \
+  V(kWord8)                           \
+  V(kWord16)                          \
+  V(kWord32)
+
 struct MachineOperatorGlobalCache {
 #define PURE(Name, properties, value_input_count, control_input_count,         \
              output_count)                                                     \
   struct Name##Operator final : public Operator {                              \
     Name##Operator()                                                           \
         : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name,     \
                    value_input_count, 0, control_input_count, output_count, 0, \
                    0) {}                                                       \
   };                                                                           \
   Name##Operator k##Name;
@@ skipping 71 matching lines @@
   };                                                                           \
   Store##Type##NoWriteBarrier##Operator kStore##Type##NoWriteBarrier;          \
   Store##Type##MapWriteBarrier##Operator kStore##Type##MapWriteBarrier;        \
   Store##Type##PointerWriteBarrier##Operator                                   \
       kStore##Type##PointerWriteBarrier;                                       \
   Store##Type##FullWriteBarrier##Operator kStore##Type##FullWriteBarrier;      \
   CheckedStore##Type##Operator kCheckedStore##Type;
   MACHINE_REPRESENTATION_LIST(STORE)
 #undef STORE
 
-#define ATOMIC(Type)                                                          \
+#define ATOMIC_LOAD(Type)                                                     \
   struct AtomicLoad##Type##Operator final                                     \
       : public Operator1<LoadRepresentation> {                                \
     AtomicLoad##Type##Operator()                                              \
         : Operator1<LoadRepresentation>(                                      \
               IrOpcode::kAtomicLoad, Operator::kNoThrow | Operator::kNoWrite, \
               "AtomicLoad", 2, 1, 1, 1, 1, 0, MachineType::Type()) {}         \
   };                                                                          \
   AtomicLoad##Type##Operator kAtomicLoad##Type;
-  ATOMIC_TYPE_LIST(ATOMIC)
-#undef ATOMIC
+  ATOMIC_TYPE_LIST(ATOMIC_LOAD)
+#undef ATOMIC_LOAD
+
+#define ATOMIC_STORE(Type)                                                     \
+  struct AtomicStore##Type##Operator                                           \
+      : public Operator1<MachineRepresentation> {                              \
+    AtomicStore##Type##Operator()                                              \
+        : Operator1<MachineRepresentation>(                                    \
+              IrOpcode::kAtomicStore, Operator::kNoRead | Operator::kNoThrow,  \
+              "AtomicStore", 3, 1, 1, 0, 1, 0, MachineRepresentation::Type) {} \
+  };                                                                           \
+  AtomicStore##Type##Operator kAtomicStore##Type;
+  ATOMIC_REPRESENTATION_LIST(ATOMIC_STORE)
+#undef STORE
 };
 
 
 static base::LazyInstance<MachineOperatorGlobalCache>::type kCache =
     LAZY_INSTANCE_INITIALIZER;
 
 
 MachineOperatorBuilder::MachineOperatorBuilder(Zone* zone,
                                                MachineRepresentation word,
                                                Flags flags)
@@ skipping 113 matching lines @@
 #define LOAD(Type)                    \
   if (rep == MachineType::Type()) {   \
     return &cache_.kAtomicLoad##Type; \
   }
   ATOMIC_TYPE_LIST(LOAD)
 #undef LOAD
   UNREACHABLE();
   return nullptr;
 }
 
+const Operator* MachineOperatorBuilder::AtomicStore(MachineRepresentation rep) {
+#define STORE(kRep)                         \
+  if (rep == MachineRepresentation::kRep) { \
+    return &cache_.kAtomicStore##kRep;      \
+  }
+  ATOMIC_REPRESENTATION_LIST(STORE)
+#undef STORE
+  UNREACHABLE();
+  return nullptr;
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8