[Atomics] Make Atomics.compareExchange 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 67 matching lines @@
 MachineRepresentation AtomicStoreRepresentationOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kAtomicStore, op->opcode());
   return OpParameter<MachineRepresentation>(op);
 }
 
 MachineType AtomicExchangeRepresentationOf(Operator const* op) {
   DCHECK_EQ(IrOpcode::kAtomicExchange, op->opcode());
   return OpParameter<MachineType>(op);
 }
 
+MachineType AtomicCompareExchangeRepresentationOf(Operator const* op) {
+  DCHECK_EQ(IrOpcode::kAtomicCompareExchange, op->opcode());
+  return OpParameter<MachineType>(op);
+}
+
 #define PURE_BINARY_OP_LIST_32(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(Int32Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)     \
@@ skipping 502 matching lines @@
     AtomicExchange##Type##Operator()                                      \
         : Operator1<MachineType>(IrOpcode::kAtomicExchange,               \
                                  Operator::kNoDeopt | Operator::kNoThrow, \
                                  "AtomicExchange", 3, 1, 1, 1, 1, 0,      \
                                  MachineType::Type()) {}                  \
   };                                                                      \
   AtomicExchange##Type##Operator kAtomicExchange##Type;
   ATOMIC_TYPE_LIST(ATOMIC_EXCHANGE)
 #undef ATOMIC_EXCHANGE
 
+#define ATOMIC_COMPARE_EXCHANGE(Type)                                       \
+  struct AtomicCompareExchange##Type##Operator                              \
+      : public Operator1<MachineType> {                                     \
+    AtomicCompareExchange##Type##Operator()                                 \
+        : Operator1<MachineType>(IrOpcode::kAtomicCompareExchange,          \
+                                 Operator::kNoDeopt | Operator::kNoThrow,   \
+                                 "AtomicCompareExchange", 4, 1, 1, 1, 1, 0, \
+                                 MachineType::Type()) {}                    \
+  };                                                                        \
+  AtomicCompareExchange##Type##Operator kAtomicCompareExchange##Type;
+  ATOMIC_TYPE_LIST(ATOMIC_COMPARE_EXCHANGE)
+#undef ATOMIC_COMPARE_EXCHANGE
+
   // The {BitcastWordToTagged} operator must not be marked as pure (especially
   // not idempotent), because otherwise the splitting logic in the Scheduler
   // might decide to split these operators, thus potentially creating live
   // ranges of allocation top across calls or other things that might allocate.
   // See https://bugs.chromium.org/p/v8/issues/detail?id=6059 for more details.
   struct BitcastWordToTaggedOperator : public Operator {
     BitcastWordToTaggedOperator()
         : Operator(IrOpcode::kBitcastWordToTagged,
                    Operator::kEliminatable | Operator::kNoWrite,
                    "BitcastWordToTagged", 1, 0, 0, 1, 0, 0) {}
@@ skipping 247 matching lines @@
 #define EXCHANGE(kRep)                    \
   if (rep == MachineType::kRep()) {       \
     return &cache_.kAtomicExchange##kRep; \
   }
   ATOMIC_TYPE_LIST(EXCHANGE)
 #undef EXCHANGE
   UNREACHABLE();
   return nullptr;
 }
 
+const Operator* MachineOperatorBuilder::AtomicCompareExchange(MachineType rep) {
+#define COMPARE_EXCHANGE(kRep)                   \
+  if (rep == MachineType::kRep()) {              \
+    return &cache_.kAtomicCompareExchange##kRep; \
+  }
+  ATOMIC_TYPE_LIST(COMPARE_EXCHANGE)
+#undef COMPARE_EXCHANGE
+  UNREACHABLE();
+  return nullptr;
+}
+
 #define SIMD_LANE_OPS(Type, lane_count)                                     \
   const Operator* MachineOperatorBuilder::Type##ExtractLane(                \
       int32_t lane_index) {                                                 \
     DCHECK(0 <= lane_index && lane_index < lane_count);                     \
     return new (zone_)                                                      \
         Operator1<int32_t>(IrOpcode::k##Type##ExtractLane, Operator::kPure, \
                            "Extract lane", 1, 0, 0, 1, 0, 0, lane_index);   \
   }                                                                         \
   const Operator* MachineOperatorBuilder::Type##ReplaceLane(                \
       int32_t lane_index) {                                                 \
@@ skipping 37 matching lines @@
     return new (zone_)                                                         \
         Operator1<uint32_t>(IrOpcode::kSimd##format##Swizzle, Operator::kPure, \
                             "Swizzle", 2, 0, 0, 1, 0, 0, swizzle);             \
   }
 SIMD_FORMAT_LIST(SIMD_PERMUTE_OPS)
 #undef SIMD_PERMUTE_OPS
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8