LCOV - code coverage report
Current view: top level - src/interpreter - bytecode-operands.h (source / functions) Hit Total Coverage
Test: app.info Lines: 13 13 100.0 %
Date: 2017-04-26 Functions: 4 4 100.0 %

          Line data    Source code
       1             : // Copyright 2016 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_INTERPRETER_BYTECODE_OPERANDS_H_
       6             : #define V8_INTERPRETER_BYTECODE_OPERANDS_H_
       7             : 
       8             : #include "src/globals.h"
       9             : 
      10             : namespace v8 {
      11             : namespace internal {
      12             : namespace interpreter {
      13             : 
      14             : #define INVALID_OPERAND_TYPE_LIST(V) V(None, OperandTypeInfo::kNone)
      15             : 
      16             : #define REGISTER_INPUT_OPERAND_TYPE_LIST(V)        \
      17             :   V(Reg, OperandTypeInfo::kScalableSignedByte)     \
      18             :   V(RegList, OperandTypeInfo::kScalableSignedByte) \
      19             :   V(RegPair, OperandTypeInfo::kScalableSignedByte)
      20             : 
      21             : #define REGISTER_OUTPUT_OPERAND_TYPE_LIST(V)          \
      22             :   V(RegOut, OperandTypeInfo::kScalableSignedByte)     \
      23             :   V(RegOutPair, OperandTypeInfo::kScalableSignedByte) \
      24             :   V(RegOutTriple, OperandTypeInfo::kScalableSignedByte)
      25             : 
      26             : #define SIGNED_SCALABLE_SCALAR_OPERAND_TYPE_LIST(V) \
      27             :   V(Imm, OperandTypeInfo::kScalableSignedByte)
      28             : 
      29             : #define UNSIGNED_SCALABLE_SCALAR_OPERAND_TYPE_LIST(V) \
      30             :   V(Idx, OperandTypeInfo::kScalableUnsignedByte)      \
      31             :   V(UImm, OperandTypeInfo::kScalableUnsignedByte)     \
      32             :   V(RegCount, OperandTypeInfo::kScalableUnsignedByte)
      33             : 
      34             : #define UNSIGNED_FIXED_SCALAR_OPERAND_TYPE_LIST(V)    \
      35             :   V(Flag8, OperandTypeInfo::kFixedUnsignedByte)       \
      36             :   V(IntrinsicId, OperandTypeInfo::kFixedUnsignedByte) \
      37             :   V(RuntimeId, OperandTypeInfo::kFixedUnsignedShort)
      38             : 
      39             : // Carefully ordered for operand type range checks below.
      40             : #define NON_REGISTER_OPERAND_TYPE_LIST(V)       \
      41             :   INVALID_OPERAND_TYPE_LIST(V)                  \
      42             :   UNSIGNED_FIXED_SCALAR_OPERAND_TYPE_LIST(V)    \
      43             :   UNSIGNED_SCALABLE_SCALAR_OPERAND_TYPE_LIST(V) \
      44             :   SIGNED_SCALABLE_SCALAR_OPERAND_TYPE_LIST(V)
      45             : 
      46             : // Carefully ordered for operand type range checks below.
      47             : #define REGISTER_OPERAND_TYPE_LIST(V) \
      48             :   REGISTER_INPUT_OPERAND_TYPE_LIST(V) \
      49             :   REGISTER_OUTPUT_OPERAND_TYPE_LIST(V)
      50             : 
      51             : // The list of operand types used by bytecodes.
      52             : // Carefully ordered for operand type range checks below.
      53             : #define OPERAND_TYPE_LIST(V)        \
      54             :   NON_REGISTER_OPERAND_TYPE_LIST(V) \
      55             :   REGISTER_OPERAND_TYPE_LIST(V)
      56             : 
      57             : // Enumeration of scaling factors applicable to scalable operands. Code
      58             : // relies on being able to cast values to integer scaling values.
      59             : #define OPERAND_SCALE_LIST(V) \
      60             :   V(Single, 1)                \
      61             :   V(Double, 2)                \
      62             :   V(Quadruple, 4)
      63             : 
      64             : enum class OperandScale : uint8_t {
      65             : #define DECLARE_OPERAND_SCALE(Name, Scale) k##Name = Scale,
      66             :   OPERAND_SCALE_LIST(DECLARE_OPERAND_SCALE)
      67             : #undef DECLARE_OPERAND_SCALE
      68             :       kLast = kQuadruple
      69             : };
      70             : 
      71             : // Enumeration of the size classes of operand types used by
      72             : // bytecodes. Code relies on being able to cast values to integer
      73             : // types to get the size in bytes.
      74             : enum class OperandSize : uint8_t {
      75             :   kNone = 0,
      76             :   kByte = 1,
      77             :   kShort = 2,
      78             :   kQuad = 4,
      79             :   kLast = kQuad
      80             : };
      81             : 
      82             : // Primitive operand info used that summarize properties of operands.
      83             : // Columns are Name, IsScalable, IsUnsigned, UnscaledSize.
      84             : #define OPERAND_TYPE_INFO_LIST(V)                         \
      85             :   V(None, false, false, OperandSize::kNone)               \
      86             :   V(ScalableSignedByte, true, false, OperandSize::kByte)  \
      87             :   V(ScalableUnsignedByte, true, true, OperandSize::kByte) \
      88             :   V(FixedUnsignedByte, false, true, OperandSize::kByte)   \
      89             :   V(FixedUnsignedShort, false, true, OperandSize::kShort)
      90             : 
      91             : enum class OperandTypeInfo : uint8_t {
      92             : #define DECLARE_OPERAND_TYPE_INFO(Name, ...) k##Name,
      93             :   OPERAND_TYPE_INFO_LIST(DECLARE_OPERAND_TYPE_INFO)
      94             : #undef DECLARE_OPERAND_TYPE_INFO
      95             : };
      96             : 
      97             : // Enumeration of operand types used by bytecodes.
      98             : enum class OperandType : uint8_t {
      99             : #define DECLARE_OPERAND_TYPE(Name, _) k##Name,
     100             :   OPERAND_TYPE_LIST(DECLARE_OPERAND_TYPE)
     101             : #undef DECLARE_OPERAND_TYPE
     102             : #define COUNT_OPERAND_TYPES(x, _) +1
     103             :   // The COUNT_OPERAND macro will turn this into kLast = -1 +1 +1... which will
     104             :   // evaluate to the same value as the last operand.
     105             :   kLast = -1 OPERAND_TYPE_LIST(COUNT_OPERAND_TYPES)
     106             : #undef COUNT_OPERAND_TYPES
     107             : };
     108             : 
     109             : enum class AccumulatorUse : uint8_t {
     110             :   kNone = 0,
     111             :   kRead = 1 << 0,
     112             :   kWrite = 1 << 1,
     113             :   kReadWrite = kRead | kWrite
     114             : };
     115             : 
     116             : inline AccumulatorUse operator&(AccumulatorUse lhs, AccumulatorUse rhs) {
     117             :   int result = static_cast<int>(lhs) & static_cast<int>(rhs);
     118             :   return static_cast<AccumulatorUse>(result);
     119             : }
     120             : 
     121             : inline AccumulatorUse operator|(AccumulatorUse lhs, AccumulatorUse rhs) {
     122       30097 :   int result = static_cast<int>(lhs) | static_cast<int>(rhs);
     123             :   return static_cast<AccumulatorUse>(result);
     124             : }
     125             : 
     126             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
     127             :                                            const AccumulatorUse& use);
     128             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
     129             :                                            const OperandScale& operand_scale);
     130             : V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
     131             :                                            const OperandSize& operand_size);
     132             : std::ostream& operator<<(std::ostream& os, const OperandType& operand_type);
     133             : 
     134             : class BytecodeOperands {
     135             :  public:
     136             :   // Returns true if |accumulator_use| reads the accumulator.
     137    47544533 :   static constexpr bool ReadsAccumulator(AccumulatorUse accumulator_use) {
     138    63980538 :     return accumulator_use == AccumulatorUse::kRead ||
     139    63980538 :            accumulator_use == AccumulatorUse::kReadWrite;
     140             :   }
     141             : 
     142             :   // Returns true if |accumulator_use| writes the accumulator.
     143    47544513 :   static constexpr bool WritesAccumulator(AccumulatorUse accumulator_use) {
     144    63980543 :     return accumulator_use == AccumulatorUse::kWrite ||
     145    47544513 :            accumulator_use == AccumulatorUse::kReadWrite;
     146             :   }
     147             : 
     148             :   // Returns true if |operand_type| is a scalable signed byte.
     149    57263791 :   static constexpr bool IsScalableSignedByte(OperandType operand_type) {
     150    57263791 :     return operand_type >= OperandType::kImm &&
     151    57263791 :            operand_type <= OperandType::kRegOutTriple;
     152             :   }
     153             : 
     154             :   // Returns true if |operand_type| is a scalable unsigned byte.
     155    86985358 :   static constexpr bool IsScalableUnsignedByte(OperandType operand_type) {
     156    86985358 :     return operand_type >= OperandType::kIdx &&
     157    86985358 :            operand_type <= OperandType::kRegCount;
     158             :   }
     159             : };
     160             : 
     161             : }  // namespace interpreter
     162             : }  // namespace internal
     163             : }  // namespace v8
     164             : 
     165             : #endif  // V8_INTERPRETER_BYTECODE_OPERANDS_H_

Generated by: LCOV version 1.10