src/v8/test/cctest/compiler/value-helper.h

   1 // Copyright 2014 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_CCTEST_COMPILER_VALUE_HELPER_H_
   6 #define V8_CCTEST_COMPILER_VALUE_HELPER_H_
   7
   8 #include "src/v8.h"
   9
  10 #include "src/compiler/common-operator.h"
  11 #include "src/compiler/node.h"
  12 #include "src/compiler/node-matchers.h"
  13 #include "src/isolate.h"
  14 #include "src/objects.h"
  15 #include "test/cctest/cctest.h"
  16
  17 namespace v8 {
  18 namespace internal {
  19 namespace compiler {
  20
  21 // A collection of utilities related to numerical and heap values, including
  22 // example input values of various types, including int32_t, uint32_t, double,
  23 // etc.
  24 class ValueHelper {
  25  public:
  26   Isolate* isolate_;
  27
  28   ValueHelper() : isolate_(CcTest::InitIsolateOnce()) {}
  29
  30   template <typename T>
  31   void CheckConstant(T expected, Node* node) {
  32     CHECK_EQ(expected, ValueOf<T>(node->op()));
  33   }
  34
  35   void CheckFloat64Constant(double expected, Node* node) {
  36     CHECK_EQ(IrOpcode::kFloat64Constant, node->opcode());
  37     CHECK_EQ(expected, ValueOf<double>(node->op()));
  38   }
  39
  40   void CheckNumberConstant(double expected, Node* node) {
  41     CHECK_EQ(IrOpcode::kNumberConstant, node->opcode());
  42     CHECK_EQ(expected, ValueOf<double>(node->op()));
  43   }
  44
  45   void CheckInt32Constant(int32_t expected, Node* node) {
  46     CHECK_EQ(IrOpcode::kInt32Constant, node->opcode());
  47     CHECK_EQ(expected, ValueOf<int32_t>(node->op()));
  48   }
  49
  50   void CheckUint32Constant(int32_t expected, Node* node) {
  51     CHECK_EQ(IrOpcode::kInt32Constant, node->opcode());
  52     CHECK_EQ(expected, ValueOf<uint32_t>(node->op()));
  53   }
  54
  55   void CheckHeapConstant(Object* expected, Node* node) {
  56     CHECK_EQ(IrOpcode::kHeapConstant, node->opcode());
  57     CHECK_EQ(expected, *ValueOf<Handle<Object> >(node->op()));
  58   }
  59
  60   void CheckTrue(Node* node) {
  61     CheckHeapConstant(isolate_->heap()->true_value(), node);
  62   }
  63
  64   void CheckFalse(Node* node) {
  65     CheckHeapConstant(isolate_->heap()->false_value(), node);
  66   }
  67
  68   static std::vector<double> float64_vector() {
  69     static const double nan = v8::base::OS::nan_value();
  70     static const double values[] = {
  71         0.125,           0.25,            0.375,          0.5,
  72         1.25,            -1.75,           2,              5.125,
  73         6.25,            0.0,             -0.0,           982983.25,
  74         888,             2147483647.0,    -999.75,        3.1e7,
  75         -2e66,           3e-88,           -2147483648.0,  V8_INFINITY,
  76         -V8_INFINITY,    nan,             2147483647.375, 2147483647.75,
  77         2147483648.0,    2147483648.25,   2147483649.25,  -2147483647.0,
  78         -2147483647.125, -2147483647.875, -2147483648.25, -2147483649.5};
  79     return std::vector<double>(&values[0], &values[ARRAY_SIZE(values)]);
  80   }
  81
  82   static const std::vector<int32_t> int32_vector() {
  83     std::vector<uint32_t> values = uint32_vector();
  84     return std::vector<int32_t>(values.begin(), values.end());
  85   }
  86
  87   static const std::vector<uint32_t> uint32_vector() {
  88     static const uint32_t kValues[] = {
  89         0x00000000, 0x00000001, 0xffffffff, 0x1b09788b, 0x04c5fce8, 0xcc0de5bf,
  90         0x273a798e, 0x187937a3, 0xece3af83, 0x5495a16b, 0x0b668ecc, 0x11223344,
  91         0x0000009e, 0x00000043, 0x0000af73, 0x0000116b, 0x00658ecc, 0x002b3b4c,
  92         0x88776655, 0x70000000, 0x07200000, 0x7fffffff, 0x56123761, 0x7fffff00,
  93         0x761c4761, 0x80000000, 0x88888888, 0xa0000000, 0xdddddddd, 0xe0000000,
  94         0xeeeeeeee, 0xfffffffd, 0xf0000000, 0x007fffff, 0x003fffff, 0x001fffff,
  95         0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, 0x0000ffff, 0x00007fff,
  96         0x00003fff, 0x00001fff, 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff};
  97     return std::vector<uint32_t>(&kValues[0], &kValues[ARRAY_SIZE(kValues)]);
  98   }
  99
 100   static const std::vector<double> nan_vector(size_t limit = 0) {
 101     static const double nan = v8::base::OS::nan_value();
 102     static const double values[] = {-nan,               -V8_INFINITY * -0.0,
 103                                     -V8_INFINITY * 0.0, V8_INFINITY * -0.0,
 104                                     V8_INFINITY * 0.0,  nan};
 105     return std::vector<double>(&values[0], &values[ARRAY_SIZE(values)]);
 106   }
 107
 108   static const std::vector<uint32_t> ror_vector() {
 109     static const uint32_t kValues[31] = {
 110         1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
 111         17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
 112     return std::vector<uint32_t>(&kValues[0], &kValues[ARRAY_SIZE(kValues)]);
 113   }
 114 };
 115
 116 // Helper macros that can be used in FOR_INT32_INPUTS(i) { ... *i ... }
 117 // Watch out, these macros aren't hygenic; they pollute your scope. Thanks STL.
 118 #define FOR_INPUTS(ctype, itype, var)                           \
 119   std::vector<ctype> var##_vec = ValueHelper::itype##_vector(); \
 120   for (std::vector<ctype>::iterator var = var##_vec.begin();    \
 121        var != var##_vec.end(); ++var)
 122
 123 #define FOR_INT32_INPUTS(var) FOR_INPUTS(int32_t, int32, var)
 124 #define FOR_UINT32_INPUTS(var) FOR_INPUTS(uint32_t, uint32, var)
 125 #define FOR_FLOAT64_INPUTS(var) FOR_INPUTS(double, float64, var)
 126
 127 }  // namespace compiler
 128 }  // namespace internal
 129 }  // namespace v8
 130
 131 #endif  // V8_CCTEST_COMPILER_VALUE_HELPER_H_