[interpreter] Introduce fused bytecodes for common sequences.

src/interpreter/bytecodes.h

 // Copyright 2015 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_INTERPRETER_BYTECODES_H_
 #define V8_INTERPRETER_BYTECODES_H_
 
 #include <iosfwd>
 
 // Clients of this interface shouldn't depend on lots of interpreter internals.
@@ skipping 101 matching lines @@
   V(StaLookupSlotStrict, AccumulatorUse::kReadWrite, OperandType::kIdx)       \
                                                                               \
   /* Register-accumulator transfers */                                        \
   V(Ldar, AccumulatorUse::kWrite, OperandType::kReg)                          \
   V(Star, AccumulatorUse::kRead, OperandType::kRegOut)                        \
                                                                               \
   /* Register-register transfers */                                           \
   V(Mov, AccumulatorUse::kNone, OperandType::kReg, OperandType::kRegOut)      \
                                                                               \
   /* LoadIC operations */                                                     \
-  V(LoadIC, AccumulatorUse::kWrite, OperandType::kReg, OperandType::kIdx,     \
-    OperandType::kIdx)                                                        \
-  V(KeyedLoadIC, AccumulatorUse::kReadWrite, OperandType::kReg,               \
+  V(LdaNamedProperty, AccumulatorUse::kWrite, OperandType::kReg,              \
+    OperandType::kIdx, OperandType::kIdx)                                     \
+  V(LdaKeyedProperty, AccumulatorUse::kReadWrite, OperandType::kReg,          \
     OperandType::kIdx)                                                        \
                                                                               \
   /* StoreIC operations */                                                    \
-  V(StoreICSloppy, AccumulatorUse::kRead, OperandType::kReg,                  \
+  V(StaNamedPropertySloppy, AccumulatorUse::kRead, OperandType::kReg,         \
     OperandType::kIdx, OperandType::kIdx)                                     \
-  V(StoreICStrict, AccumulatorUse::kRead, OperandType::kReg,                  \
+  V(StaNamedPropertyStrict, AccumulatorUse::kRead, OperandType::kReg,         \
     OperandType::kIdx, OperandType::kIdx)                                     \
-  V(KeyedStoreICSloppy, AccumulatorUse::kRead, OperandType::kReg,             \
+  V(StaKeyedPropertySloppy, AccumulatorUse::kRead, OperandType::kReg,         \
     OperandType::kReg, OperandType::kIdx)                                     \
-  V(KeyedStoreICStrict, AccumulatorUse::kRead, OperandType::kReg,             \
+  V(StaKeyedPropertyStrict, AccumulatorUse::kRead, OperandType::kReg,         \

[rmcilroy, 2016/05/18 16:09:41]

Could we do this renaming in a seperate CL as well please? It is difficult to
eyeball the changes in the bytecode expectations coming from the Ldr fused
bytecodes with this mechanical change also in the same CL.

[oth, 2016/05/18 20:22:25]

Done.

     OperandType::kReg, OperandType::kIdx)                                     \
                                                                               \
   /* Binary Operators */                                                      \
   V(Add, AccumulatorUse::kReadWrite, OperandType::kReg)                       \
   V(Sub, AccumulatorUse::kReadWrite, OperandType::kReg)                       \
   V(Mul, AccumulatorUse::kReadWrite, OperandType::kReg)                       \
   V(Div, AccumulatorUse::kReadWrite, OperandType::kReg)                       \
   V(Mod, AccumulatorUse::kReadWrite, OperandType::kReg)                       \
   V(BitwiseOr, AccumulatorUse::kReadWrite, OperandType::kReg)                 \
   V(BitwiseXor, AccumulatorUse::kReadWrite, OperandType::kReg)                \
@@ skipping 102 matching lines @@
                                                                               \
   /* Debugger */                                                              \
   V(Debugger, AccumulatorUse::kNone)                                          \
   DEBUG_BREAK_BYTECODE_LIST(V)                                                \
                                                                               \
   /* Illegal bytecode (terminates execution) */                               \
   V(Illegal, AccumulatorUse::kNone)                                           \
                                                                               \
   /* No operation (used to maintain source positions for peephole */          \
   /* eliminated bytecodes). */                                                \
-  V(Nop, AccumulatorUse::kNone)
+  V(Nop, AccumulatorUse::kNone)                                               \
+                                                                              \
+  /* Fused bytecodes emitted by the peephole optimizer. */                    \
+  V(LdrUndefined, AccumulatorUse::kNone, OperandType::kRegOut)                \
+  V(LdrContextSlot, AccumulatorUse::kNone, OperandType::kReg,                 \
+    OperandType::kIdx, OperandType::kRegOut)                                  \
+  V(LdrGlobal, AccumulatorUse::kNone, OperandType::kIdx, OperandType::kIdx,   \
+    OperandType::kRegOut)                                                     \
+  V(LdrNamedProperty, AccumulatorUse::kNone, OperandType::kReg,               \
+    OperandType::kIdx, OperandType::kIdx, OperandType::kRegOut)               \
+  V(LdrKeyedProperty, AccumulatorUse::kRead, OperandType::kReg,               \
+    OperandType::kIdx, OperandType::kRegOut)

[rmcilroy, 2016/05/17 15:49:33]

I'd prefer these lived next to the Lda versions - we have other bytecodes which
are only emitted by the peephole optmizer and we don't put them in their own
group, I think it would be better to group by behaviour than how they are
emitted.

[oth, 2016/05/18 20:22:25]

Done.

 
 enum class AccumulatorUse : uint8_t {
   kNone = 0,
   kRead = 1 << 0,
   kWrite = 1 << 1,
   kReadWrite = kRead | kWrite
 };
 
 V8_INLINE AccumulatorUse operator&(AccumulatorUse lhs, AccumulatorUse rhs) {
   int result = static_cast<int>(lhs) & static_cast<int>(rhs);
@@ skipping 166 matching lines @@
   // Returns string representation of |operand_type|.
   static const char* OperandTypeToString(OperandType operand_type);
 
   // Returns string representation of |operand_scale|.
   static const char* OperandScaleToString(OperandScale operand_scale);
 
   // Returns string representation of |operand_size|.
   static const char* OperandSizeToString(OperandSize operand_size);
 
   // Returns byte value of bytecode.
-  static uint8_t ToByte(Bytecode bytecode);
+  static uint8_t ToByte(Bytecode bytecode) {
+    DCHECK_LE(bytecode, Bytecode::kLast);
+    return static_cast<uint8_t>(bytecode);
+  }
 
   // Returns bytecode for |value|.
   static Bytecode FromByte(uint8_t value);
 
   // Returns the number of operands expected by |bytecode|.
   static int NumberOfOperands(Bytecode bytecode);
 
   // Returns the number of register operands expected by |bytecode|.
   static int NumberOfRegisterOperands(Bytecode bytecode);
 
@@ skipping 186 matching lines @@
 std::ostream& operator<<(std::ostream& os, const AccumulatorUse& use);
 std::ostream& operator<<(std::ostream& os, const OperandScale& operand_scale);
 std::ostream& operator<<(std::ostream& os, const OperandSize& operand_size);
 std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_INTERPRETER_BYTECODES_H_