OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "src/compiler/common-operator.h" | 5 #include "src/compiler/common-operator.h" |
6 | 6 |
7 #include <limits> | 7 #include <limits> |
8 | 8 |
9 #include "src/compiler/operator-properties-inl.h" | 9 #include "src/compiler/operator-properties-inl.h" |
10 #include "test/unittests/test-utils.h" | 10 #include "test/unittests/test-utils.h" |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
126 | 126 |
127 CommonOperatorBuilder* common() { return &common_; } | 127 CommonOperatorBuilder* common() { return &common_; } |
128 | 128 |
129 private: | 129 private: |
130 CommonOperatorBuilder common_; | 130 CommonOperatorBuilder common_; |
131 }; | 131 }; |
132 | 132 |
133 | 133 |
134 const int kArguments[] = {1, 5, 6, 42, 100, 10000, kMaxInt}; | 134 const int kArguments[] = {1, 5, 6, 42, 100, 10000, kMaxInt}; |
135 | 135 |
136 const float kFloat32Values[] = { | 136 |
137 std::numeric_limits<float>::min(), -1.0f, -0.0f, 0.0f, 1.0f, | 137 const float kFloatValues[] = {-std::numeric_limits<float>::infinity(), |
138 std::numeric_limits<float>::max()}; | 138 std::numeric_limits<float>::min(), |
| 139 -1.0f, |
| 140 -0.0f, |
| 141 0.0f, |
| 142 1.0f, |
| 143 std::numeric_limits<float>::max(), |
| 144 std::numeric_limits<float>::infinity(), |
| 145 std::numeric_limits<float>::quiet_NaN(), |
| 146 std::numeric_limits<float>::signaling_NaN()}; |
| 147 |
| 148 |
| 149 const double kDoubleValues[] = {-std::numeric_limits<double>::infinity(), |
| 150 std::numeric_limits<double>::min(), |
| 151 -1.0, |
| 152 -0.0, |
| 153 0.0, |
| 154 1.0, |
| 155 std::numeric_limits<double>::max(), |
| 156 std::numeric_limits<double>::infinity(), |
| 157 std::numeric_limits<double>::quiet_NaN(), |
| 158 std::numeric_limits<double>::signaling_NaN()}; |
139 | 159 |
140 } // namespace | 160 } // namespace |
141 | 161 |
142 | 162 |
143 TEST_F(CommonOperatorTest, Float32Constant) { | 163 TEST_F(CommonOperatorTest, Float32Constant) { |
144 TRACED_FOREACH(float, value, kFloat32Values) { | 164 TRACED_FOREACH(float, value, kFloatValues) { |
145 const Operator* op = common()->Float32Constant(value); | 165 const Operator* op = common()->Float32Constant(value); |
146 EXPECT_FLOAT_EQ(value, OpParameter<float>(op)); | 166 EXPECT_PRED2(base::bit_equal_to<float>(), value, OpParameter<float>(op)); |
147 EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op)); | 167 EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op)); |
148 EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op)); | 168 EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op)); |
149 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); | 169 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); |
150 EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op)); | 170 EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op)); |
151 EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op)); | 171 EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op)); |
152 } | 172 } |
| 173 TRACED_FOREACH(float, v1, kFloatValues) { |
| 174 TRACED_FOREACH(float, v2, kFloatValues) { |
| 175 const Operator* op1 = common()->Float32Constant(v1); |
| 176 const Operator* op2 = common()->Float32Constant(v2); |
| 177 EXPECT_EQ(bit_cast<uint32_t>(v1) == bit_cast<uint32_t>(v2), |
| 178 op1->Equals(op2)); |
| 179 } |
| 180 } |
153 } | 181 } |
154 | 182 |
155 | 183 |
| 184 TEST_F(CommonOperatorTest, Float64Constant) { |
| 185 TRACED_FOREACH(double, value, kFloatValues) { |
| 186 const Operator* op = common()->Float64Constant(value); |
| 187 EXPECT_PRED2(base::bit_equal_to<double>(), value, OpParameter<double>(op)); |
| 188 EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op)); |
| 189 EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op)); |
| 190 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); |
| 191 EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op)); |
| 192 EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op)); |
| 193 } |
| 194 TRACED_FOREACH(double, v1, kFloatValues) { |
| 195 TRACED_FOREACH(double, v2, kFloatValues) { |
| 196 const Operator* op1 = common()->Float64Constant(v1); |
| 197 const Operator* op2 = common()->Float64Constant(v2); |
| 198 EXPECT_EQ(bit_cast<uint64_t>(v1) == bit_cast<uint64_t>(v2), |
| 199 op1->Equals(op2)); |
| 200 } |
| 201 } |
| 202 } |
| 203 |
| 204 |
| 205 TEST_F(CommonOperatorTest, NumberConstant) { |
| 206 TRACED_FOREACH(double, value, kFloatValues) { |
| 207 const Operator* op = common()->NumberConstant(value); |
| 208 EXPECT_PRED2(base::bit_equal_to<double>(), value, OpParameter<double>(op)); |
| 209 EXPECT_EQ(0, OperatorProperties::GetValueInputCount(op)); |
| 210 EXPECT_EQ(0, OperatorProperties::GetTotalInputCount(op)); |
| 211 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); |
| 212 EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op)); |
| 213 EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op)); |
| 214 } |
| 215 TRACED_FOREACH(double, v1, kFloatValues) { |
| 216 TRACED_FOREACH(double, v2, kFloatValues) { |
| 217 const Operator* op1 = common()->NumberConstant(v1); |
| 218 const Operator* op2 = common()->NumberConstant(v2); |
| 219 EXPECT_EQ(bit_cast<uint64_t>(v1) == bit_cast<uint64_t>(v2), |
| 220 op1->Equals(op2)); |
| 221 } |
| 222 } |
| 223 } |
| 224 |
| 225 |
156 TEST_F(CommonOperatorTest, ValueEffect) { | 226 TEST_F(CommonOperatorTest, ValueEffect) { |
157 TRACED_FOREACH(int, arguments, kArguments) { | 227 TRACED_FOREACH(int, arguments, kArguments) { |
158 const Operator* op = common()->ValueEffect(arguments); | 228 const Operator* op = common()->ValueEffect(arguments); |
159 EXPECT_EQ(arguments, OperatorProperties::GetValueInputCount(op)); | 229 EXPECT_EQ(arguments, OperatorProperties::GetValueInputCount(op)); |
160 EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op)); | 230 EXPECT_EQ(arguments, OperatorProperties::GetTotalInputCount(op)); |
161 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); | 231 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); |
162 EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op)); | 232 EXPECT_EQ(1, OperatorProperties::GetEffectOutputCount(op)); |
163 EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op)); | 233 EXPECT_EQ(0, OperatorProperties::GetValueOutputCount(op)); |
164 } | 234 } |
165 } | 235 } |
166 | 236 |
167 | 237 |
168 TEST_F(CommonOperatorTest, Finish) { | 238 TEST_F(CommonOperatorTest, Finish) { |
169 TRACED_FOREACH(int, arguments, kArguments) { | 239 TRACED_FOREACH(int, arguments, kArguments) { |
170 const Operator* op = common()->Finish(arguments); | 240 const Operator* op = common()->Finish(arguments); |
171 EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op)); | 241 EXPECT_EQ(1, OperatorProperties::GetValueInputCount(op)); |
172 EXPECT_EQ(arguments, OperatorProperties::GetEffectInputCount(op)); | 242 EXPECT_EQ(arguments, OperatorProperties::GetEffectInputCount(op)); |
173 EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op)); | 243 EXPECT_EQ(arguments + 1, OperatorProperties::GetTotalInputCount(op)); |
174 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); | 244 EXPECT_EQ(0, OperatorProperties::GetControlOutputCount(op)); |
175 EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op)); | 245 EXPECT_EQ(0, OperatorProperties::GetEffectOutputCount(op)); |
176 EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op)); | 246 EXPECT_EQ(1, OperatorProperties::GetValueOutputCount(op)); |
177 } | 247 } |
178 } | 248 } |
179 | 249 |
180 } // namespace compiler | 250 } // namespace compiler |
181 } // namespace internal | 251 } // namespace internal |
182 } // namespace v8 | 252 } // namespace v8 |
OLD | NEW |