[turbofan] Add the StackSlot operator to turbofan.

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 73 matching lines @@
   DCHECK_EQ(IrOpcode::kCheckedLoad, op->opcode());
   return OpParameter<CheckedLoadRepresentation>(op);
 }
 
 
 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);
+}
 
 #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)                             \
@@ skipping 170 matching lines @@
     CheckedLoad##Type##Operator()                                              \
         : Operator1<CheckedLoadRepresentation>(                                \
               IrOpcode::kCheckedLoad, Operator::kNoThrow | Operator::kNoWrite, \
               "CheckedLoad", 3, 1, 1, 1, 1, 0, MachineType::Type()) {}         \
   };                                                                           \
   Load##Type##Operator kLoad##Type;                                            \
   CheckedLoad##Type##Operator kCheckedLoad##Type;
   MACHINE_TYPE_LIST(LOAD)
 #undef LOAD
 
+#define STACKSLOT(Type)                                                       \
+  struct StackSlot##Type##Operator final                                      \
+      : public Operator1<MachineRepresentation> {                             \
+    StackSlot##Type##Operator()                                               \
+        : Operator1<MachineRepresentation>(                                   \
+              IrOpcode::kStackSlot, Operator::kNoThrow, "StackSlot", 0, 0, 0, \
+              1, 0, 0, MachineType::Type().representation()) {}               \
+  };                                                                          \
+  StackSlot##Type##Operator kStackSlot##Type;
+  MACHINE_TYPE_LIST(STACKSLOT)
+#undef STACKSLOT
+
 #define STORE(Type)                                                            \
   struct Store##Type##Operator : public Operator1<StoreRepresentation> {       \
     explicit Store##Type##Operator(WriteBarrierKind write_barrier_kind)        \
         : Operator1<StoreRepresentation>(                                      \
               IrOpcode::kStore, Operator::kNoRead | Operator::kNoThrow,        \
               "Store", 3, 1, 1, 0, 1, 0,                                       \
               StoreRepresentation(MachineRepresentation::Type,                 \
                                   write_barrier_kind)) {}                      \
   };                                                                           \
   struct Store##Type##NoWriteBarrier##Operator final                           \
@@ skipping 80 matching lines @@
 #define LOAD(Type)                  \
   if (rep == MachineType::Type()) { \
     return &cache_.kLoad##Type;     \
   }
     MACHINE_TYPE_LIST(LOAD)
 #undef LOAD
   UNREACHABLE();
   return nullptr;
 }
 
+const Operator* MachineOperatorBuilder::StackSlot(MachineRepresentation rep) {
+#define STACKSLOT(Type)                              \
+  if (rep == MachineType::Type().representation()) { \
+    return &cache_.kStackSlot##Type;                 \
+  }
+  MACHINE_TYPE_LIST(STACKSLOT)
+#undef STACKSLOT
+  UNREACHABLE();
+  return nullptr;
+}
 
 const Operator* MachineOperatorBuilder::Store(StoreRepresentation store_rep) {
   switch (store_rep.representation()) {
 #define STORE(kRep)                                         \
   case MachineRepresentation::kRep:                         \
     switch (store_rep.write_barrier_kind()) {               \
       case kNoWriteBarrier:                                 \
         return &cache_.k##Store##kRep##NoWriteBarrier;      \
       case kMapWriteBarrier:                                \
         return &cache_.k##Store##kRep##MapWriteBarrier;     \
@@ skipping 39 matching lines @@
     case MachineRepresentation::kNone:
       break;
   }
   UNREACHABLE();
   return nullptr;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8