Line data    Source code

       1             : // Copyright 2015 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             : #include "src/compiler/opcodes.h"
       6             : #include "testing/gtest-support.h"
       7             : 
       8             : namespace v8 {
       9             : namespace internal {
      10             : namespace compiler {
      11             : 
      12             : namespace {
      13             : 
      14             : bool IsCommonOpcode(IrOpcode::Value opcode) {
      15         717 :   switch (opcode) {
      16             : #define OPCODE(Opcode)      \
      17             :   case IrOpcode::k##Opcode: \
      18             :     return true;
      19             :     COMMON_OP_LIST(OPCODE)
      20             :     CONTROL_OP_LIST(OPCODE)
      21             : #undef OPCODE
      22             :     default:
      23             :       return false;
      24             :   }
      25             : }
      26             : 
      27             : 
      28             : bool IsControlOpcode(IrOpcode::Value opcode) {
      29         717 :   switch (opcode) {
      30             : #define OPCODE(Opcode)      \
      31             :   case IrOpcode::k##Opcode: \
      32             :     return true;
      33             :     CONTROL_OP_LIST(OPCODE)
      34             : #undef OPCODE
      35             :     default:
      36             :       return false;
      37             :   }
      38             : }
      39             : 
      40             : 
      41             : bool IsJsOpcode(IrOpcode::Value opcode) {
      42         717 :   switch (opcode) {
      43             : #define OPCODE(Opcode)      \
      44             :   case IrOpcode::k##Opcode: \
      45             :     return true;
      46             :     JS_OP_LIST(OPCODE)
      47             : #undef OPCODE
      48             :     default:
      49             :       return false;
      50             :   }
      51             : }
      52             : 
      53             : 
      54             : bool IsConstantOpcode(IrOpcode::Value opcode) {
      55         717 :   switch (opcode) {
      56             : #define OPCODE(Opcode)      \
      57             :   case IrOpcode::k##Opcode: \
      58             :     return true;
      59             :     CONSTANT_OP_LIST(OPCODE)
      60             : #undef OPCODE
      61             :     default:
      62             :       return false;
      63             :   }
      64             : }
      65             : 
      66             : 
      67             : bool IsComparisonOpcode(IrOpcode::Value opcode) {
      68         717 :   switch (opcode) {
      69             : #define OPCODE(Opcode)      \
      70             :   case IrOpcode::k##Opcode: \
      71             :     return true;
      72             :     JS_COMPARE_BINOP_LIST(OPCODE)
      73             :     SIMPLIFIED_COMPARE_BINOP_LIST(OPCODE)
      74             :     MACHINE_COMPARE_BINOP_LIST(OPCODE)
      75             : #undef OPCODE
      76             :     default:
      77             :       return false;
      78             :   }
      79             : }
      80             : 
      81             : 
      82             : const IrOpcode::Value kInvalidOpcode = static_cast<IrOpcode::Value>(123456789);
      83             : 
      84             : char const* const kMnemonics[] = {
      85             : #define OPCODE(Opcode) #Opcode,
      86             :     ALL_OP_LIST(OPCODE)
      87             : #undef OPCODE
      88             : };
      89             : 
      90             : const IrOpcode::Value kOpcodes[] = {
      91             : #define OPCODE(Opcode) IrOpcode::k##Opcode,
      92             :     ALL_OP_LIST(OPCODE)
      93             : #undef OPCODE
      94             : };
      95             : 
      96             : }  // namespace
      97             : 
      98       15128 : TEST(IrOpcodeTest, IsCommonOpcode) {
      99             :   EXPECT_FALSE(IrOpcode::IsCommonOpcode(kInvalidOpcode));
     100        4303 :   TRACED_FOREACH(IrOpcode::Value, opcode, kOpcodes) {
     101        2151 :     EXPECT_EQ(IsCommonOpcode(opcode), IrOpcode::IsCommonOpcode(opcode));
     102         717 :   }
     103           1 : }
     104             : 
     105       15128 : TEST(IrOpcodeTest, IsControlOpcode) {
     106             :   EXPECT_FALSE(IrOpcode::IsControlOpcode(kInvalidOpcode));
     107        4303 :   TRACED_FOREACH(IrOpcode::Value, opcode, kOpcodes) {
     108        2151 :     EXPECT_EQ(IsControlOpcode(opcode), IrOpcode::IsControlOpcode(opcode));
     109         717 :   }
     110           1 : }
     111             : 
     112       15128 : TEST(IrOpcodeTest, IsJsOpcode) {
     113             :   EXPECT_FALSE(IrOpcode::IsJsOpcode(kInvalidOpcode));
     114        4303 :   TRACED_FOREACH(IrOpcode::Value, opcode, kOpcodes) {
     115        2151 :     EXPECT_EQ(IsJsOpcode(opcode), IrOpcode::IsJsOpcode(opcode));
     116         717 :   }
     117           1 : }
     118             : 
     119       15128 : TEST(IrOpcodeTest, IsConstantOpcode) {
     120             :   EXPECT_FALSE(IrOpcode::IsConstantOpcode(kInvalidOpcode));
     121        4303 :   TRACED_FOREACH(IrOpcode::Value, opcode, kOpcodes) {
     122        2151 :     EXPECT_EQ(IsConstantOpcode(opcode), IrOpcode::IsConstantOpcode(opcode));
     123         717 :   }
     124           1 : }
     125             : 
     126       15128 : TEST(IrOpcodeTest, IsComparisonOpcode) {
     127             :   EXPECT_FALSE(IrOpcode::IsComparisonOpcode(kInvalidOpcode));
     128        4303 :   TRACED_FOREACH(IrOpcode::Value, opcode, kOpcodes) {
     129        2151 :     EXPECT_EQ(IsComparisonOpcode(opcode), IrOpcode::IsComparisonOpcode(opcode));
     130         717 :   }
     131           1 : }
     132             : 
     133       15128 : TEST(IrOpcodeTest, Mnemonic) {
     134           1 :   EXPECT_STREQ("UnknownOpcode", IrOpcode::Mnemonic(kInvalidOpcode));
     135        4303 :   TRACED_FOREACH(IrOpcode::Value, opcode, kOpcodes) {
     136         717 :     EXPECT_STREQ(kMnemonics[opcode], IrOpcode::Mnemonic(opcode));
     137         717 :   }
     138           1 : }
     139             : 
     140             : }  // namespace compiler
     141             : }  // namespace internal
     142        9075 : }  // namespace v8