Line data Source code
1 : // Copyright 2018 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/redundancy-elimination.h"
6 : #include "src/compiler/common-operator.h"
7 : #include "test/unittests/compiler/graph-reducer-unittest.h"
8 : #include "test/unittests/compiler/graph-unittest.h"
9 : #include "test/unittests/compiler/node-test-utils.h"
10 : #include "testing/gmock-support.h"
11 :
12 : using testing::_;
13 : using testing::NiceMock;
14 :
15 : namespace v8 {
16 : namespace internal {
17 : namespace compiler {
18 : namespace redundancy_elimination_unittest {
19 :
20 : class RedundancyEliminationTest : public GraphTest {
21 : public:
22 53 : explicit RedundancyEliminationTest(int num_parameters = 4)
23 : : GraphTest(num_parameters),
24 : reducer_(&editor_, zone()),
25 159 : simplified_(zone()) {
26 : // Initialize the {reducer_} state for the Start node.
27 53 : reducer_.Reduce(graph()->start());
28 :
29 : // Create a feedback vector with two CALL_IC slots.
30 : FeedbackVectorSpec spec(zone());
31 : FeedbackSlot slot1 = spec.AddCallICSlot();
32 : FeedbackSlot slot2 = spec.AddCallICSlot();
33 53 : Handle<FeedbackMetadata> metadata = FeedbackMetadata::New(isolate(), &spec);
34 : Handle<SharedFunctionInfo> shared =
35 : isolate()->factory()->NewSharedFunctionInfoForBuiltin(
36 53 : isolate()->factory()->empty_string(), Builtins::kIllegal);
37 106 : shared->set_raw_outer_scope_info_or_feedback_metadata(*metadata);
38 : Handle<ClosureFeedbackCellArray> closure_feedback_cell_array =
39 53 : ClosureFeedbackCellArray::New(isolate(), shared);
40 : Handle<FeedbackVector> feedback_vector =
41 53 : FeedbackVector::New(isolate(), shared, closure_feedback_cell_array);
42 106 : vector_slot_pairs_.push_back(VectorSlotPair());
43 53 : vector_slot_pairs_.push_back(
44 : VectorSlotPair(feedback_vector, slot1, UNINITIALIZED));
45 53 : vector_slot_pairs_.push_back(
46 : VectorSlotPair(feedback_vector, slot2, UNINITIALIZED));
47 53 : }
48 106 : ~RedundancyEliminationTest() override = default;
49 :
50 : protected:
51 1230 : Reduction Reduce(Node* node) { return reducer_.Reduce(node); }
52 :
53 : std::vector<VectorSlotPair> const& vector_slot_pairs() const {
54 : return vector_slot_pairs_;
55 : }
56 588 : SimplifiedOperatorBuilder* simplified() { return &simplified_; }
57 :
58 : private:
59 : NiceMock<MockAdvancedReducerEditor> editor_;
60 : std::vector<VectorSlotPair> vector_slot_pairs_;
61 : VectorSlotPair feedback2_;
62 : RedundancyElimination reducer_;
63 : SimplifiedOperatorBuilder simplified_;
64 : };
65 :
66 : namespace {
67 :
68 : const CheckForMinusZeroMode kCheckForMinusZeroModes[] = {
69 : CheckForMinusZeroMode::kCheckForMinusZero,
70 : CheckForMinusZeroMode::kDontCheckForMinusZero,
71 : };
72 :
73 : const CheckTaggedInputMode kCheckTaggedInputModes[] = {
74 : CheckTaggedInputMode::kNumber, CheckTaggedInputMode::kNumberOrOddball};
75 :
76 : const NumberOperationHint kNumberOperationHints[] = {
77 : NumberOperationHint::kSignedSmall,
78 : NumberOperationHint::kSignedSmallInputs,
79 : NumberOperationHint::kSigned32,
80 : NumberOperationHint::kNumber,
81 : NumberOperationHint::kNumberOrOddball,
82 : };
83 :
84 : } // namespace
85 :
86 : // -----------------------------------------------------------------------------
87 : // CheckBounds
88 :
89 15443 : TEST_F(RedundancyEliminationTest, CheckBounds) {
90 10 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
91 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
92 9 : Node* index = Parameter(0);
93 9 : Node* length = Parameter(1);
94 : Node* effect = graph()->start();
95 : Node* control = graph()->start();
96 :
97 9 : Node* check1 = effect = graph()->NewNode(
98 9 : simplified()->CheckBounds(feedback1), index, length, effect, control);
99 : Reduction r1 = Reduce(check1);
100 9 : ASSERT_TRUE(r1.Changed());
101 18 : EXPECT_EQ(r1.replacement(), check1);
102 :
103 9 : Node* check2 = effect = graph()->NewNode(
104 : simplified()->CheckBounds(feedback2), index, length, effect, control);
105 : Reduction r2 = Reduce(check2);
106 9 : ASSERT_TRUE(r2.Changed());
107 18 : EXPECT_EQ(r2.replacement(), check1);
108 : }
109 : }
110 : }
111 :
112 : // -----------------------------------------------------------------------------
113 : // CheckNumber
114 :
115 15443 : TEST_F(RedundancyEliminationTest, CheckNumberSubsumedByCheckSmi) {
116 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
117 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
118 9 : Node* value = Parameter(0);
119 : Node* effect = graph()->start();
120 : Node* control = graph()->start();
121 :
122 9 : Node* check1 = effect = graph()->NewNode(
123 9 : simplified()->CheckSmi(feedback1), value, effect, control);
124 : Reduction r1 = Reduce(check1);
125 9 : ASSERT_TRUE(r1.Changed());
126 18 : EXPECT_EQ(r1.replacement(), check1);
127 :
128 9 : Node* check2 = effect = graph()->NewNode(
129 : simplified()->CheckNumber(feedback2), value, effect, control);
130 : Reduction r2 = Reduce(check2);
131 9 : ASSERT_TRUE(r2.Changed());
132 18 : EXPECT_EQ(r2.replacement(), check1);
133 : }
134 : }
135 : }
136 :
137 : // -----------------------------------------------------------------------------
138 : // CheckReceiver
139 :
140 15443 : TEST_F(RedundancyEliminationTest, CheckReceiver) {
141 1 : Node* value = Parameter(0);
142 : Node* effect = graph()->start();
143 : Node* control = graph()->start();
144 :
145 : Node* check1 = effect =
146 2 : graph()->NewNode(simplified()->CheckReceiver(), value, effect, control);
147 : Reduction r1 = Reduce(check1);
148 1 : ASSERT_TRUE(r1.Changed());
149 2 : EXPECT_EQ(r1.replacement(), check1);
150 :
151 : Node* check2 = effect =
152 1 : graph()->NewNode(simplified()->CheckReceiver(), value, effect, control);
153 : Reduction r2 = Reduce(check2);
154 1 : ASSERT_TRUE(r2.Changed());
155 2 : EXPECT_EQ(r2.replacement(), check1);
156 : }
157 :
158 : // -----------------------------------------------------------------------------
159 : // CheckReceiverOrNullOrUndefined
160 :
161 15443 : TEST_F(RedundancyEliminationTest, CheckReceiverOrNullOrUndefined) {
162 1 : Node* value = Parameter(0);
163 : Node* effect = graph()->start();
164 : Node* control = graph()->start();
165 :
166 1 : Node* check1 = effect = graph()->NewNode(
167 1 : simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control);
168 : Reduction r1 = Reduce(check1);
169 1 : ASSERT_TRUE(r1.Changed());
170 2 : EXPECT_EQ(r1.replacement(), check1);
171 :
172 1 : Node* check2 = effect = graph()->NewNode(
173 : simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control);
174 : Reduction r2 = Reduce(check2);
175 1 : ASSERT_TRUE(r2.Changed());
176 2 : EXPECT_EQ(r2.replacement(), check1);
177 : }
178 :
179 15443 : TEST_F(RedundancyEliminationTest,
180 : CheckReceiverOrNullOrUndefinedSubsumedByCheckReceiver) {
181 1 : Node* value = Parameter(0);
182 : Node* effect = graph()->start();
183 : Node* control = graph()->start();
184 :
185 : Node* check1 = effect =
186 2 : graph()->NewNode(simplified()->CheckReceiver(), value, effect, control);
187 : Reduction r1 = Reduce(check1);
188 1 : ASSERT_TRUE(r1.Changed());
189 2 : EXPECT_EQ(r1.replacement(), check1);
190 :
191 1 : Node* check2 = effect = graph()->NewNode(
192 : simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control);
193 : Reduction r2 = Reduce(check2);
194 1 : ASSERT_TRUE(r2.Changed());
195 2 : EXPECT_EQ(r2.replacement(), check1);
196 : }
197 :
198 : // -----------------------------------------------------------------------------
199 : // CheckNonEmptyString
200 :
201 15443 : TEST_F(RedundancyEliminationTest,
202 : CheckNonEmptyStringSubsumedByCheckNonEmptyOneByteString) {
203 1 : Node* value = Parameter(0);
204 : Node* effect = graph()->start();
205 : Node* control = graph()->start();
206 :
207 1 : Node* check1 = effect = graph()->NewNode(
208 1 : simplified()->CheckNonEmptyOneByteString(), value, effect, control);
209 : Reduction r1 = Reduce(check1);
210 1 : ASSERT_TRUE(r1.Changed());
211 2 : EXPECT_EQ(r1.replacement(), check1);
212 :
213 1 : Node* check2 = effect = graph()->NewNode(simplified()->CheckNonEmptyString(),
214 : value, effect, control);
215 : Reduction r2 = Reduce(check2);
216 1 : ASSERT_TRUE(r2.Changed());
217 2 : EXPECT_EQ(r2.replacement(), check1);
218 : }
219 :
220 15443 : TEST_F(RedundancyEliminationTest,
221 : CheckNonEmptyStringSubsumedByCheckNonEmptyTwoByteString) {
222 1 : Node* value = Parameter(0);
223 : Node* effect = graph()->start();
224 : Node* control = graph()->start();
225 :
226 1 : Node* check1 = effect = graph()->NewNode(
227 1 : simplified()->CheckNonEmptyTwoByteString(), value, effect, control);
228 : Reduction r1 = Reduce(check1);
229 1 : ASSERT_TRUE(r1.Changed());
230 2 : EXPECT_EQ(r1.replacement(), check1);
231 :
232 1 : Node* check2 = effect = graph()->NewNode(simplified()->CheckNonEmptyString(),
233 : value, effect, control);
234 : Reduction r2 = Reduce(check2);
235 1 : ASSERT_TRUE(r2.Changed());
236 2 : EXPECT_EQ(r2.replacement(), check1);
237 : }
238 :
239 : // -----------------------------------------------------------------------------
240 : // CheckString
241 :
242 15443 : TEST_F(RedundancyEliminationTest,
243 : CheckStringSubsumedByCheckInternalizedString) {
244 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
245 3 : Node* value = Parameter(0);
246 : Node* effect = graph()->start();
247 : Node* control = graph()->start();
248 :
249 3 : Node* check1 = effect = graph()->NewNode(
250 3 : simplified()->CheckInternalizedString(), value, effect, control);
251 : Reduction r1 = Reduce(check1);
252 3 : ASSERT_TRUE(r1.Changed());
253 6 : EXPECT_EQ(r1.replacement(), check1);
254 :
255 3 : Node* check2 = effect = graph()->NewNode(
256 : simplified()->CheckString(feedback), value, effect, control);
257 : Reduction r2 = Reduce(check2);
258 3 : ASSERT_TRUE(r2.Changed());
259 6 : EXPECT_EQ(r2.replacement(), check1);
260 : }
261 : }
262 :
263 15443 : TEST_F(RedundancyEliminationTest, CheckStringSubsumedByCheckNonEmptyString) {
264 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
265 3 : Node* value = Parameter(0);
266 : Node* effect = graph()->start();
267 : Node* control = graph()->start();
268 :
269 3 : Node* check1 = effect = graph()->NewNode(
270 3 : simplified()->CheckNonEmptyString(), value, effect, control);
271 : Reduction r1 = Reduce(check1);
272 3 : ASSERT_TRUE(r1.Changed());
273 6 : EXPECT_EQ(r1.replacement(), check1);
274 :
275 : Node* check2 = effect = graph()->NewNode(
276 : simplified()->CheckString(feedback), value, effect, control);
277 : Reduction r2 = Reduce(check2);
278 3 : ASSERT_TRUE(r2.Changed());
279 6 : EXPECT_EQ(r2.replacement(), check1);
280 : }
281 : }
282 :
283 15443 : TEST_F(RedundancyEliminationTest,
284 : CheckStringSubsumedByCheckNonEmptyOneByteString) {
285 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
286 3 : Node* value = Parameter(0);
287 : Node* effect = graph()->start();
288 : Node* control = graph()->start();
289 :
290 3 : Node* check1 = effect = graph()->NewNode(
291 3 : simplified()->CheckNonEmptyOneByteString(), value, effect, control);
292 : Reduction r1 = Reduce(check1);
293 3 : ASSERT_TRUE(r1.Changed());
294 6 : EXPECT_EQ(r1.replacement(), check1);
295 :
296 3 : Node* check2 = effect = graph()->NewNode(
297 : simplified()->CheckString(feedback), value, effect, control);
298 : Reduction r2 = Reduce(check2);
299 3 : ASSERT_TRUE(r2.Changed());
300 6 : EXPECT_EQ(r2.replacement(), check1);
301 : }
302 : }
303 :
304 15443 : TEST_F(RedundancyEliminationTest,
305 : CheckStringSubsumedByCheckNonEmptyTwoByteString) {
306 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
307 3 : Node* value = Parameter(0);
308 : Node* effect = graph()->start();
309 : Node* control = graph()->start();
310 :
311 3 : Node* check1 = effect = graph()->NewNode(
312 3 : simplified()->CheckNonEmptyTwoByteString(), value, effect, control);
313 : Reduction r1 = Reduce(check1);
314 3 : ASSERT_TRUE(r1.Changed());
315 6 : EXPECT_EQ(r1.replacement(), check1);
316 :
317 3 : Node* check2 = effect = graph()->NewNode(
318 : simplified()->CheckString(feedback), value, effect, control);
319 : Reduction r2 = Reduce(check2);
320 3 : ASSERT_TRUE(r2.Changed());
321 6 : EXPECT_EQ(r2.replacement(), check1);
322 : }
323 : }
324 :
325 : // -----------------------------------------------------------------------------
326 : // CheckSymbol
327 :
328 15443 : TEST_F(RedundancyEliminationTest, CheckSymbol) {
329 1 : Node* value = Parameter(0);
330 : Node* effect = graph()->start();
331 : Node* control = graph()->start();
332 :
333 : Node* check1 = effect =
334 2 : graph()->NewNode(simplified()->CheckSymbol(), value, effect, control);
335 : Reduction r1 = Reduce(check1);
336 1 : ASSERT_TRUE(r1.Changed());
337 2 : EXPECT_EQ(r1.replacement(), check1);
338 :
339 : Node* check2 = effect =
340 1 : graph()->NewNode(simplified()->CheckSymbol(), value, effect, control);
341 : Reduction r2 = Reduce(check2);
342 1 : ASSERT_TRUE(r2.Changed());
343 2 : EXPECT_EQ(r2.replacement(), check1);
344 : }
345 :
346 : // -----------------------------------------------------------------------------
347 : // CheckedFloat64ToInt32
348 :
349 15443 : TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt32) {
350 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
351 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
352 81 : TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
353 18 : Node* value = Parameter(0);
354 : Node* effect = graph()->start();
355 : Node* control = graph()->start();
356 :
357 18 : Node* check1 = effect = graph()->NewNode(
358 : simplified()->CheckedFloat64ToInt32(mode, feedback1), value, effect,
359 18 : control);
360 : Reduction r1 = Reduce(check1);
361 18 : ASSERT_TRUE(r1.Changed());
362 36 : EXPECT_EQ(r1.replacement(), check1);
363 :
364 18 : Node* check2 = effect = graph()->NewNode(
365 : simplified()->CheckedFloat64ToInt32(mode, feedback2), value, effect,
366 : control);
367 : Reduction r2 = Reduce(check2);
368 18 : ASSERT_TRUE(r2.Changed());
369 36 : EXPECT_EQ(r2.replacement(), check1);
370 : }
371 : }
372 : }
373 : }
374 :
375 : // -----------------------------------------------------------------------------
376 : // CheckedFloat64ToInt64
377 :
378 15443 : TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt64) {
379 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
380 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
381 81 : TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
382 18 : Node* value = Parameter(0);
383 : Node* effect = graph()->start();
384 : Node* control = graph()->start();
385 :
386 18 : Node* check1 = effect = graph()->NewNode(
387 : simplified()->CheckedFloat64ToInt64(mode, feedback1), value, effect,
388 18 : control);
389 : Reduction r1 = Reduce(check1);
390 18 : ASSERT_TRUE(r1.Changed());
391 36 : EXPECT_EQ(r1.replacement(), check1);
392 :
393 18 : Node* check2 = effect = graph()->NewNode(
394 : simplified()->CheckedFloat64ToInt64(mode, feedback2), value, effect,
395 : control);
396 : Reduction r2 = Reduce(check2);
397 18 : ASSERT_TRUE(r2.Changed());
398 36 : EXPECT_EQ(r2.replacement(), check1);
399 : }
400 : }
401 : }
402 : }
403 :
404 : // -----------------------------------------------------------------------------
405 : // CheckedInt32ToTaggedSigned
406 :
407 15443 : TEST_F(RedundancyEliminationTest, CheckedInt32ToTaggedSigned) {
408 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
409 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
410 9 : Node* value = Parameter(0);
411 : Node* effect = graph()->start();
412 : Node* control = graph()->start();
413 :
414 : Node* check1 = effect =
415 9 : graph()->NewNode(simplified()->CheckedInt32ToTaggedSigned(feedback1),
416 9 : value, effect, control);
417 : Reduction r1 = Reduce(check1);
418 9 : ASSERT_TRUE(r1.Changed());
419 18 : EXPECT_EQ(r1.replacement(), check1);
420 :
421 : Node* check2 = effect =
422 9 : graph()->NewNode(simplified()->CheckedInt32ToTaggedSigned(feedback2),
423 : value, effect, control);
424 : Reduction r2 = Reduce(check2);
425 9 : ASSERT_TRUE(r2.Changed());
426 18 : EXPECT_EQ(r2.replacement(), check1);
427 : }
428 : }
429 : }
430 :
431 : // -----------------------------------------------------------------------------
432 : // CheckedInt64ToInt32
433 :
434 15443 : TEST_F(RedundancyEliminationTest, CheckedInt64ToInt32) {
435 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
436 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
437 9 : Node* value = Parameter(0);
438 : Node* effect = graph()->start();
439 : Node* control = graph()->start();
440 :
441 9 : Node* check1 = effect = graph()->NewNode(
442 9 : simplified()->CheckedInt64ToInt32(feedback1), value, effect, control);
443 : Reduction r1 = Reduce(check1);
444 9 : ASSERT_TRUE(r1.Changed());
445 18 : EXPECT_EQ(r1.replacement(), check1);
446 :
447 9 : Node* check2 = effect = graph()->NewNode(
448 : simplified()->CheckedInt64ToInt32(feedback2), value, effect, control);
449 : Reduction r2 = Reduce(check2);
450 9 : ASSERT_TRUE(r2.Changed());
451 18 : EXPECT_EQ(r2.replacement(), check1);
452 : }
453 : }
454 : }
455 :
456 : // -----------------------------------------------------------------------------
457 : // CheckedInt64ToTaggedSigned
458 :
459 15443 : TEST_F(RedundancyEliminationTest, CheckedInt64ToTaggedSigned) {
460 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
461 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
462 9 : Node* value = Parameter(0);
463 : Node* effect = graph()->start();
464 : Node* control = graph()->start();
465 :
466 : Node* check1 = effect =
467 9 : graph()->NewNode(simplified()->CheckedInt64ToTaggedSigned(feedback1),
468 9 : value, effect, control);
469 : Reduction r1 = Reduce(check1);
470 9 : ASSERT_TRUE(r1.Changed());
471 18 : EXPECT_EQ(r1.replacement(), check1);
472 :
473 : Node* check2 = effect =
474 9 : graph()->NewNode(simplified()->CheckedInt64ToTaggedSigned(feedback2),
475 : value, effect, control);
476 : Reduction r2 = Reduce(check2);
477 9 : ASSERT_TRUE(r2.Changed());
478 18 : EXPECT_EQ(r2.replacement(), check1);
479 : }
480 : }
481 : }
482 :
483 : // -----------------------------------------------------------------------------
484 : // CheckedTaggedSignedToInt32
485 :
486 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedSignedToInt32) {
487 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
488 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
489 9 : Node* value = Parameter(0);
490 : Node* effect = graph()->start();
491 : Node* control = graph()->start();
492 :
493 : Node* check1 = effect =
494 9 : graph()->NewNode(simplified()->CheckedTaggedSignedToInt32(feedback1),
495 9 : value, effect, control);
496 : Reduction r1 = Reduce(check1);
497 9 : ASSERT_TRUE(r1.Changed());
498 18 : EXPECT_EQ(r1.replacement(), check1);
499 :
500 : Node* check2 = effect =
501 9 : graph()->NewNode(simplified()->CheckedTaggedSignedToInt32(feedback2),
502 : value, effect, control);
503 : Reduction r2 = Reduce(check2);
504 9 : ASSERT_TRUE(r2.Changed());
505 18 : EXPECT_EQ(r2.replacement(), check1);
506 : }
507 : }
508 : }
509 :
510 : // -----------------------------------------------------------------------------
511 : // CheckedTaggedToFloat64
512 :
513 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToFloat64) {
514 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
515 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
516 81 : TRACED_FOREACH(CheckTaggedInputMode, mode, kCheckTaggedInputModes) {
517 18 : Node* value = Parameter(0);
518 : Node* effect = graph()->start();
519 : Node* control = graph()->start();
520 :
521 18 : Node* check1 = effect = graph()->NewNode(
522 : simplified()->CheckedTaggedToFloat64(mode, feedback1), value,
523 18 : effect, control);
524 : Reduction r1 = Reduce(check1);
525 18 : ASSERT_TRUE(r1.Changed());
526 36 : EXPECT_EQ(r1.replacement(), check1);
527 :
528 18 : Node* check2 = effect = graph()->NewNode(
529 : simplified()->CheckedTaggedToFloat64(mode, feedback2), value,
530 : effect, control);
531 : Reduction r2 = Reduce(check2);
532 18 : ASSERT_TRUE(r2.Changed());
533 36 : EXPECT_EQ(r2.replacement(), check1);
534 : }
535 : }
536 : }
537 : }
538 :
539 15443 : TEST_F(RedundancyEliminationTest,
540 : CheckedTaggedToFloat64SubsubmedByCheckedTaggedToFloat64) {
541 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
542 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
543 9 : Node* value = Parameter(0);
544 : Node* effect = graph()->start();
545 : Node* control = graph()->start();
546 :
547 : // If the check passed for CheckTaggedInputMode::kNumber, it'll
548 : // also pass later for CheckTaggedInputMode::kNumberOrOddball.
549 : Node* check1 = effect =
550 9 : graph()->NewNode(simplified()->CheckedTaggedToFloat64(
551 : CheckTaggedInputMode::kNumber, feedback1),
552 9 : value, effect, control);
553 : Reduction r1 = Reduce(check1);
554 9 : ASSERT_TRUE(r1.Changed());
555 18 : EXPECT_EQ(r1.replacement(), check1);
556 :
557 9 : Node* check2 = effect = graph()->NewNode(
558 : simplified()->CheckedTaggedToFloat64(
559 : CheckTaggedInputMode::kNumberOrOddball, feedback2),
560 : value, effect, control);
561 : Reduction r2 = Reduce(check2);
562 9 : ASSERT_TRUE(r2.Changed());
563 18 : EXPECT_EQ(r2.replacement(), check1);
564 : }
565 : }
566 : }
567 :
568 : // -----------------------------------------------------------------------------
569 : // CheckedTaggedToInt32
570 :
571 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToInt32) {
572 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
573 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
574 81 : TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
575 18 : Node* value = Parameter(0);
576 : Node* effect = graph()->start();
577 : Node* control = graph()->start();
578 :
579 18 : Node* check1 = effect = graph()->NewNode(
580 : simplified()->CheckedTaggedToInt32(mode, feedback1), value, effect,
581 18 : control);
582 : Reduction r1 = Reduce(check1);
583 18 : ASSERT_TRUE(r1.Changed());
584 36 : EXPECT_EQ(r1.replacement(), check1);
585 :
586 18 : Node* check2 = effect = graph()->NewNode(
587 : simplified()->CheckedTaggedToInt32(mode, feedback2), value, effect,
588 : control);
589 : Reduction r2 = Reduce(check2);
590 18 : ASSERT_TRUE(r2.Changed());
591 36 : EXPECT_EQ(r2.replacement(), check1);
592 : }
593 : }
594 : }
595 : }
596 :
597 15443 : TEST_F(RedundancyEliminationTest,
598 : CheckedTaggedToInt32SubsumedByCheckedTaggedSignedToInt32) {
599 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
600 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
601 81 : TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
602 18 : Node* value = Parameter(0);
603 : Node* effect = graph()->start();
604 : Node* control = graph()->start();
605 :
606 18 : Node* check1 = effect = graph()->NewNode(
607 : simplified()->CheckedTaggedSignedToInt32(feedback1), value, effect,
608 18 : control);
609 : Reduction r1 = Reduce(check1);
610 18 : ASSERT_TRUE(r1.Changed());
611 36 : EXPECT_EQ(r1.replacement(), check1);
612 :
613 18 : Node* check2 = effect = graph()->NewNode(
614 : simplified()->CheckedTaggedToInt32(mode, feedback2), value, effect,
615 : control);
616 : Reduction r2 = Reduce(check2);
617 18 : ASSERT_TRUE(r2.Changed());
618 36 : EXPECT_EQ(r2.replacement(), check1);
619 : }
620 : }
621 : }
622 : }
623 :
624 : // -----------------------------------------------------------------------------
625 : // CheckedTaggedToInt64
626 :
627 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToInt64) {
628 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
629 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
630 81 : TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
631 18 : Node* value = Parameter(0);
632 : Node* effect = graph()->start();
633 : Node* control = graph()->start();
634 :
635 18 : Node* check1 = effect = graph()->NewNode(
636 : simplified()->CheckedTaggedToInt64(mode, feedback1), value, effect,
637 18 : control);
638 : Reduction r1 = Reduce(check1);
639 18 : ASSERT_TRUE(r1.Changed());
640 36 : EXPECT_EQ(r1.replacement(), check1);
641 :
642 18 : Node* check2 = effect = graph()->NewNode(
643 : simplified()->CheckedTaggedToInt64(mode, feedback2), value, effect,
644 : control);
645 : Reduction r2 = Reduce(check2);
646 18 : ASSERT_TRUE(r2.Changed());
647 36 : EXPECT_EQ(r2.replacement(), check1);
648 : }
649 : }
650 : }
651 : }
652 :
653 : // -----------------------------------------------------------------------------
654 : // CheckedTaggedToTaggedPointer
655 :
656 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedPointer) {
657 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
658 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
659 9 : Node* value = Parameter(0);
660 : Node* effect = graph()->start();
661 : Node* control = graph()->start();
662 :
663 9 : Node* check1 = effect = graph()->NewNode(
664 : simplified()->CheckedTaggedToTaggedPointer(feedback1), value, effect,
665 9 : control);
666 : Reduction r1 = Reduce(check1);
667 9 : ASSERT_TRUE(r1.Changed());
668 18 : EXPECT_EQ(r1.replacement(), check1);
669 :
670 9 : Node* check2 = effect = graph()->NewNode(
671 : simplified()->CheckedTaggedToTaggedPointer(feedback2), value, effect,
672 : control);
673 : Reduction r2 = Reduce(check2);
674 9 : ASSERT_TRUE(r2.Changed());
675 18 : EXPECT_EQ(r2.replacement(), check1);
676 : }
677 : }
678 : }
679 :
680 : // -----------------------------------------------------------------------------
681 : // CheckedTaggedToTaggedSigned
682 :
683 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedSigned) {
684 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
685 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
686 9 : Node* value = Parameter(0);
687 : Node* effect = graph()->start();
688 : Node* control = graph()->start();
689 :
690 : Node* check1 = effect =
691 9 : graph()->NewNode(simplified()->CheckedTaggedToTaggedSigned(feedback1),
692 9 : value, effect, control);
693 : Reduction r1 = Reduce(check1);
694 9 : ASSERT_TRUE(r1.Changed());
695 18 : EXPECT_EQ(r1.replacement(), check1);
696 :
697 : Node* check2 = effect =
698 9 : graph()->NewNode(simplified()->CheckedTaggedToTaggedSigned(feedback2),
699 : value, effect, control);
700 : Reduction r2 = Reduce(check2);
701 9 : ASSERT_TRUE(r2.Changed());
702 18 : EXPECT_EQ(r2.replacement(), check1);
703 : }
704 : }
705 : }
706 :
707 : // -----------------------------------------------------------------------------
708 : // CheckedCompressedToTaggedPointer
709 :
710 15443 : TEST_F(RedundancyEliminationTest, CheckedCompressedToTaggedPointer) {
711 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
712 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
713 9 : Node* value = Parameter(0);
714 : Node* effect = graph()->start();
715 : Node* control = graph()->start();
716 :
717 9 : Node* check1 = effect = graph()->NewNode(
718 : simplified()->CheckedCompressedToTaggedPointer(feedback1), value,
719 9 : effect, control);
720 : Reduction r1 = Reduce(check1);
721 9 : ASSERT_TRUE(r1.Changed());
722 18 : EXPECT_EQ(r1.replacement(), check1);
723 :
724 9 : Node* check2 = effect = graph()->NewNode(
725 : simplified()->CheckedCompressedToTaggedPointer(feedback2), value,
726 : effect, control);
727 : Reduction r2 = Reduce(check2);
728 9 : ASSERT_TRUE(r2.Changed());
729 18 : EXPECT_EQ(r2.replacement(), check1);
730 : }
731 : }
732 : }
733 :
734 : // -----------------------------------------------------------------------------
735 : // CheckedCompressedToTaggedSigned
736 :
737 15443 : TEST_F(RedundancyEliminationTest, CheckedCompressedToTaggedSigned) {
738 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
739 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
740 9 : Node* value = Parameter(0);
741 : Node* effect = graph()->start();
742 : Node* control = graph()->start();
743 :
744 9 : Node* check1 = effect = graph()->NewNode(
745 : simplified()->CheckedCompressedToTaggedSigned(feedback1), value,
746 9 : effect, control);
747 : Reduction r1 = Reduce(check1);
748 9 : ASSERT_TRUE(r1.Changed());
749 18 : EXPECT_EQ(r1.replacement(), check1);
750 :
751 9 : Node* check2 = effect = graph()->NewNode(
752 : simplified()->CheckedCompressedToTaggedSigned(feedback2), value,
753 : effect, control);
754 : Reduction r2 = Reduce(check2);
755 9 : ASSERT_TRUE(r2.Changed());
756 18 : EXPECT_EQ(r2.replacement(), check1);
757 : }
758 : }
759 : }
760 :
761 : // -----------------------------------------------------------------------------
762 : // CheckedTaggedToCompressedPointer
763 :
764 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToCompressedPointer) {
765 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
766 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
767 9 : Node* value = Parameter(0);
768 : Node* effect = graph()->start();
769 : Node* control = graph()->start();
770 :
771 9 : Node* check1 = effect = graph()->NewNode(
772 : simplified()->CheckedTaggedToCompressedPointer(feedback1), value,
773 9 : effect, control);
774 : Reduction r1 = Reduce(check1);
775 9 : ASSERT_TRUE(r1.Changed());
776 18 : EXPECT_EQ(r1.replacement(), check1);
777 :
778 9 : Node* check2 = effect = graph()->NewNode(
779 : simplified()->CheckedTaggedToCompressedPointer(feedback2), value,
780 : effect, control);
781 : Reduction r2 = Reduce(check2);
782 9 : ASSERT_TRUE(r2.Changed());
783 18 : EXPECT_EQ(r2.replacement(), check1);
784 : }
785 : }
786 : }
787 :
788 : // -----------------------------------------------------------------------------
789 : // CheckedTaggedToCompressedSigned
790 :
791 15443 : TEST_F(RedundancyEliminationTest, CheckedTaggedToCompressedSigned) {
792 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
793 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
794 9 : Node* value = Parameter(0);
795 : Node* effect = graph()->start();
796 : Node* control = graph()->start();
797 :
798 9 : Node* check1 = effect = graph()->NewNode(
799 : simplified()->CheckedTaggedToCompressedSigned(feedback1), value,
800 9 : effect, control);
801 : Reduction r1 = Reduce(check1);
802 9 : ASSERT_TRUE(r1.Changed());
803 18 : EXPECT_EQ(r1.replacement(), check1);
804 :
805 9 : Node* check2 = effect = graph()->NewNode(
806 : simplified()->CheckedTaggedToCompressedSigned(feedback2), value,
807 : effect, control);
808 : Reduction r2 = Reduce(check2);
809 9 : ASSERT_TRUE(r2.Changed());
810 18 : EXPECT_EQ(r2.replacement(), check1);
811 : }
812 : }
813 : }
814 :
815 : // -----------------------------------------------------------------------------
816 : // CheckedTruncateTaggedToWord32
817 :
818 15443 : TEST_F(RedundancyEliminationTest, CheckedTruncateTaggedToWord32) {
819 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
820 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
821 81 : TRACED_FOREACH(CheckTaggedInputMode, mode, kCheckTaggedInputModes) {
822 18 : Node* value = Parameter(0);
823 : Node* effect = graph()->start();
824 : Node* control = graph()->start();
825 :
826 18 : Node* check1 = effect = graph()->NewNode(
827 : simplified()->CheckedTruncateTaggedToWord32(mode, feedback1), value,
828 18 : effect, control);
829 : Reduction r1 = Reduce(check1);
830 18 : ASSERT_TRUE(r1.Changed());
831 36 : EXPECT_EQ(r1.replacement(), check1);
832 :
833 18 : Node* check2 = effect = graph()->NewNode(
834 : simplified()->CheckedTruncateTaggedToWord32(mode, feedback2), value,
835 : effect, control);
836 : Reduction r2 = Reduce(check2);
837 18 : ASSERT_TRUE(r2.Changed());
838 36 : EXPECT_EQ(r2.replacement(), check1);
839 : }
840 : }
841 : }
842 : }
843 :
844 15443 : TEST_F(RedundancyEliminationTest,
845 : CheckedTruncateTaggedToWord32SubsumedByCheckedTruncateTaggedToWord32) {
846 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
847 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
848 9 : Node* value = Parameter(0);
849 : Node* effect = graph()->start();
850 : Node* control = graph()->start();
851 :
852 : // If the check passed for CheckTaggedInputMode::kNumber, it'll
853 : // also pass later for CheckTaggedInputMode::kNumberOrOddball.
854 : Node* check1 = effect =
855 9 : graph()->NewNode(simplified()->CheckedTruncateTaggedToWord32(
856 : CheckTaggedInputMode::kNumber, feedback1),
857 9 : value, effect, control);
858 : Reduction r1 = Reduce(check1);
859 9 : ASSERT_TRUE(r1.Changed());
860 18 : EXPECT_EQ(r1.replacement(), check1);
861 :
862 9 : Node* check2 = effect = graph()->NewNode(
863 : simplified()->CheckedTruncateTaggedToWord32(
864 : CheckTaggedInputMode::kNumberOrOddball, feedback2),
865 : value, effect, control);
866 : Reduction r2 = Reduce(check2);
867 9 : ASSERT_TRUE(r2.Changed());
868 18 : EXPECT_EQ(r2.replacement(), check1);
869 : }
870 : }
871 : }
872 :
873 : // -----------------------------------------------------------------------------
874 : // CheckedUint32Bounds
875 :
876 15443 : TEST_F(RedundancyEliminationTest, CheckedUint32Bounds) {
877 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
878 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
879 9 : Node* index = Parameter(0);
880 9 : Node* length = Parameter(1);
881 : Node* effect = graph()->start();
882 : Node* control = graph()->start();
883 :
884 9 : Node* check1 = effect = graph()->NewNode(
885 : simplified()->CheckedUint32Bounds(
886 : feedback1, CheckBoundsParameters::kDeoptOnOutOfBounds),
887 9 : index, length, effect, control);
888 : Reduction r1 = Reduce(check1);
889 9 : ASSERT_TRUE(r1.Changed());
890 18 : EXPECT_EQ(r1.replacement(), check1);
891 :
892 9 : Node* check2 = effect = graph()->NewNode(
893 : simplified()->CheckedUint32Bounds(
894 : feedback2, CheckBoundsParameters::kDeoptOnOutOfBounds),
895 : index, length, effect, control);
896 : Reduction r2 = Reduce(check2);
897 9 : ASSERT_TRUE(r2.Changed());
898 18 : EXPECT_EQ(r2.replacement(), check1);
899 : }
900 : }
901 : }
902 :
903 : // -----------------------------------------------------------------------------
904 : // CheckedUint32ToInt32
905 :
906 15443 : TEST_F(RedundancyEliminationTest, CheckedUint32ToInt32) {
907 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
908 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
909 9 : Node* value = Parameter(0);
910 : Node* effect = graph()->start();
911 : Node* control = graph()->start();
912 :
913 : Node* check1 = effect =
914 9 : graph()->NewNode(simplified()->CheckedUint32ToInt32(feedback1), value,
915 9 : effect, control);
916 : Reduction r1 = Reduce(check1);
917 9 : ASSERT_TRUE(r1.Changed());
918 18 : EXPECT_EQ(r1.replacement(), check1);
919 :
920 : Node* check2 = effect =
921 9 : graph()->NewNode(simplified()->CheckedUint32ToInt32(feedback2), value,
922 : effect, control);
923 : Reduction r2 = Reduce(check2);
924 9 : ASSERT_TRUE(r2.Changed());
925 18 : EXPECT_EQ(r2.replacement(), check1);
926 : }
927 : }
928 : }
929 :
930 : // -----------------------------------------------------------------------------
931 : // CheckedUint32ToTaggedSigned
932 :
933 15443 : TEST_F(RedundancyEliminationTest, CheckedUint32ToTaggedSigned) {
934 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
935 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
936 9 : Node* value = Parameter(0);
937 : Node* effect = graph()->start();
938 : Node* control = graph()->start();
939 :
940 : Node* check1 = effect =
941 9 : graph()->NewNode(simplified()->CheckedUint32ToTaggedSigned(feedback1),
942 9 : value, effect, control);
943 : Reduction r1 = Reduce(check1);
944 9 : ASSERT_TRUE(r1.Changed());
945 18 : EXPECT_EQ(r1.replacement(), check1);
946 :
947 : Node* check2 = effect =
948 9 : graph()->NewNode(simplified()->CheckedUint32ToTaggedSigned(feedback2),
949 : value, effect, control);
950 : Reduction r2 = Reduce(check2);
951 9 : ASSERT_TRUE(r2.Changed());
952 18 : EXPECT_EQ(r2.replacement(), check1);
953 : }
954 : }
955 : }
956 :
957 : // -----------------------------------------------------------------------------
958 : // CheckedUint64Bounds
959 :
960 15443 : TEST_F(RedundancyEliminationTest, CheckedUint64Bounds) {
961 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
962 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
963 9 : Node* index = Parameter(0);
964 9 : Node* length = Parameter(1);
965 : Node* effect = graph()->start();
966 : Node* control = graph()->start();
967 :
968 : Node* check1 = effect =
969 9 : graph()->NewNode(simplified()->CheckedUint64Bounds(feedback1), index,
970 9 : length, effect, control);
971 : Reduction r1 = Reduce(check1);
972 9 : ASSERT_TRUE(r1.Changed());
973 18 : EXPECT_EQ(r1.replacement(), check1);
974 :
975 : Node* check2 = effect =
976 9 : graph()->NewNode(simplified()->CheckedUint64Bounds(feedback2), index,
977 : length, effect, control);
978 : Reduction r2 = Reduce(check2);
979 9 : ASSERT_TRUE(r2.Changed());
980 18 : EXPECT_EQ(r2.replacement(), check1);
981 : }
982 : }
983 : }
984 :
985 : // -----------------------------------------------------------------------------
986 : // CheckedUint64ToInt32
987 :
988 15443 : TEST_F(RedundancyEliminationTest, CheckedUint64ToInt32) {
989 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
990 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
991 9 : Node* value = Parameter(0);
992 : Node* effect = graph()->start();
993 : Node* control = graph()->start();
994 :
995 : Node* check1 = effect =
996 9 : graph()->NewNode(simplified()->CheckedUint64ToInt32(feedback1), value,
997 9 : effect, control);
998 : Reduction r1 = Reduce(check1);
999 9 : ASSERT_TRUE(r1.Changed());
1000 18 : EXPECT_EQ(r1.replacement(), check1);
1001 :
1002 : Node* check2 = effect =
1003 9 : graph()->NewNode(simplified()->CheckedUint64ToInt32(feedback2), value,
1004 : effect, control);
1005 : Reduction r2 = Reduce(check2);
1006 9 : ASSERT_TRUE(r2.Changed());
1007 18 : EXPECT_EQ(r2.replacement(), check1);
1008 : }
1009 : }
1010 : }
1011 :
1012 : // -----------------------------------------------------------------------------
1013 : // CheckedUint64ToTaggedSigned
1014 :
1015 15443 : TEST_F(RedundancyEliminationTest, CheckedUint64ToTaggedSigned) {
1016 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1017 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1018 9 : Node* value = Parameter(0);
1019 : Node* effect = graph()->start();
1020 : Node* control = graph()->start();
1021 :
1022 : Node* check1 = effect =
1023 9 : graph()->NewNode(simplified()->CheckedUint64ToTaggedSigned(feedback1),
1024 9 : value, effect, control);
1025 : Reduction r1 = Reduce(check1);
1026 9 : ASSERT_TRUE(r1.Changed());
1027 18 : EXPECT_EQ(r1.replacement(), check1);
1028 :
1029 : Node* check2 = effect =
1030 9 : graph()->NewNode(simplified()->CheckedUint64ToTaggedSigned(feedback2),
1031 : value, effect, control);
1032 : Reduction r2 = Reduce(check2);
1033 9 : ASSERT_TRUE(r2.Changed());
1034 18 : EXPECT_EQ(r2.replacement(), check1);
1035 : }
1036 : }
1037 : }
1038 :
1039 : // -----------------------------------------------------------------------------
1040 : // SpeculativeNumberEqual
1041 :
1042 15443 : TEST_F(RedundancyEliminationTest,
1043 : SpeculativeNumberEqualWithCheckBoundsBetterType) {
1044 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1045 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1046 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1047 9 : Node* lhs = Parameter(Type::Any(), 0);
1048 9 : Node* rhs = Parameter(Type::Any(), 1);
1049 9 : Node* length = Parameter(Type::Unsigned31(), 2);
1050 : Node* effect = graph()->start();
1051 : Node* control = graph()->start();
1052 :
1053 9 : Node* check1 = effect = graph()->NewNode(
1054 9 : simplified()->CheckBounds(feedback1), lhs, length, effect, control);
1055 : Reduction r1 = Reduce(check1);
1056 9 : ASSERT_TRUE(r1.Changed());
1057 18 : EXPECT_EQ(r1.replacement(), check1);
1058 :
1059 9 : Node* check2 = effect = graph()->NewNode(
1060 9 : simplified()->CheckBounds(feedback2), rhs, length, effect, control);
1061 : Reduction r2 = Reduce(check2);
1062 9 : ASSERT_TRUE(r2.Changed());
1063 18 : EXPECT_EQ(r2.replacement(), check2);
1064 :
1065 : Node* cmp3 = effect =
1066 9 : graph()->NewNode(simplified()->SpeculativeNumberEqual(
1067 : NumberOperationHint::kSignedSmall),
1068 : lhs, rhs, effect, control);
1069 : Reduction r3 = Reduce(cmp3);
1070 9 : ASSERT_TRUE(r3.Changed());
1071 90 : EXPECT_THAT(r3.replacement(),
1072 : IsSpeculativeNumberEqual(NumberOperationHint::kSignedSmall,
1073 0 : check1, check2, _, _));
1074 : }
1075 : }
1076 : }
1077 :
1078 15443 : TEST_F(RedundancyEliminationTest,
1079 : SpeculativeNumberEqualWithCheckBoundsSameType) {
1080 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1081 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1082 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1083 9 : Node* lhs = Parameter(Type::UnsignedSmall(), 0);
1084 9 : Node* rhs = Parameter(Type::UnsignedSmall(), 1);
1085 9 : Node* length = Parameter(Type::Unsigned31(), 2);
1086 : Node* effect = graph()->start();
1087 : Node* control = graph()->start();
1088 :
1089 9 : Node* check1 = effect = graph()->NewNode(
1090 9 : simplified()->CheckBounds(feedback1), lhs, length, effect, control);
1091 : Reduction r1 = Reduce(check1);
1092 9 : ASSERT_TRUE(r1.Changed());
1093 18 : EXPECT_EQ(r1.replacement(), check1);
1094 :
1095 9 : Node* check2 = effect = graph()->NewNode(
1096 9 : simplified()->CheckBounds(feedback2), rhs, length, effect, control);
1097 : Reduction r2 = Reduce(check2);
1098 9 : ASSERT_TRUE(r2.Changed());
1099 18 : EXPECT_EQ(r2.replacement(), check2);
1100 :
1101 : Node* cmp3 = effect =
1102 9 : graph()->NewNode(simplified()->SpeculativeNumberEqual(
1103 : NumberOperationHint::kSignedSmall),
1104 : lhs, rhs, effect, control);
1105 : Reduction r3 = Reduce(cmp3);
1106 9 : ASSERT_TRUE(r3.Changed());
1107 90 : EXPECT_THAT(r3.replacement(),
1108 : IsSpeculativeNumberEqual(NumberOperationHint::kSignedSmall,
1109 0 : lhs, rhs, _, _));
1110 : }
1111 : }
1112 : }
1113 :
1114 : // -----------------------------------------------------------------------------
1115 : // SpeculativeNumberLessThan
1116 :
1117 15443 : TEST_F(RedundancyEliminationTest,
1118 : SpeculativeNumberLessThanWithCheckBoundsBetterType) {
1119 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1120 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1121 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1122 9 : Node* lhs = Parameter(Type::Any(), 0);
1123 9 : Node* rhs = Parameter(Type::Any(), 1);
1124 9 : Node* length = Parameter(Type::Unsigned31(), 2);
1125 : Node* effect = graph()->start();
1126 : Node* control = graph()->start();
1127 :
1128 9 : Node* check1 = effect = graph()->NewNode(
1129 9 : simplified()->CheckBounds(feedback1), lhs, length, effect, control);
1130 : Reduction r1 = Reduce(check1);
1131 9 : ASSERT_TRUE(r1.Changed());
1132 18 : EXPECT_EQ(r1.replacement(), check1);
1133 :
1134 9 : Node* check2 = effect = graph()->NewNode(
1135 9 : simplified()->CheckBounds(feedback2), rhs, length, effect, control);
1136 : Reduction r2 = Reduce(check2);
1137 9 : ASSERT_TRUE(r2.Changed());
1138 18 : EXPECT_EQ(r2.replacement(), check2);
1139 :
1140 : Node* cmp3 = effect =
1141 9 : graph()->NewNode(simplified()->SpeculativeNumberLessThan(
1142 : NumberOperationHint::kSignedSmall),
1143 : lhs, rhs, effect, control);
1144 : Reduction r3 = Reduce(cmp3);
1145 9 : ASSERT_TRUE(r3.Changed());
1146 90 : EXPECT_THAT(r3.replacement(),
1147 : IsSpeculativeNumberLessThan(NumberOperationHint::kSignedSmall,
1148 0 : check1, check2, _, _));
1149 : }
1150 : }
1151 : }
1152 :
1153 15443 : TEST_F(RedundancyEliminationTest,
1154 : SpeculativeNumberLessThanWithCheckBoundsSameType) {
1155 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1156 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1157 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1158 9 : Node* lhs = Parameter(Type::UnsignedSmall(), 0);
1159 9 : Node* rhs = Parameter(Type::UnsignedSmall(), 1);
1160 9 : Node* length = Parameter(Type::Unsigned31(), 2);
1161 : Node* effect = graph()->start();
1162 : Node* control = graph()->start();
1163 :
1164 9 : Node* check1 = effect = graph()->NewNode(
1165 9 : simplified()->CheckBounds(feedback1), lhs, length, effect, control);
1166 : Reduction r1 = Reduce(check1);
1167 9 : ASSERT_TRUE(r1.Changed());
1168 18 : EXPECT_EQ(r1.replacement(), check1);
1169 :
1170 9 : Node* check2 = effect = graph()->NewNode(
1171 9 : simplified()->CheckBounds(feedback2), rhs, length, effect, control);
1172 : Reduction r2 = Reduce(check2);
1173 9 : ASSERT_TRUE(r2.Changed());
1174 18 : EXPECT_EQ(r2.replacement(), check2);
1175 :
1176 : Node* cmp3 = effect =
1177 9 : graph()->NewNode(simplified()->SpeculativeNumberLessThan(
1178 : NumberOperationHint::kSignedSmall),
1179 : lhs, rhs, effect, control);
1180 : Reduction r3 = Reduce(cmp3);
1181 9 : ASSERT_TRUE(r3.Changed());
1182 90 : EXPECT_THAT(r3.replacement(),
1183 : IsSpeculativeNumberLessThan(NumberOperationHint::kSignedSmall,
1184 0 : lhs, rhs, _, _));
1185 : }
1186 : }
1187 : }
1188 :
1189 : // -----------------------------------------------------------------------------
1190 : // SpeculativeNumberLessThanOrEqual
1191 :
1192 15443 : TEST_F(RedundancyEliminationTest,
1193 : SpeculativeNumberLessThanOrEqualWithCheckBoundsBetterType) {
1194 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1195 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1196 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1197 9 : Node* lhs = Parameter(Type::Any(), 0);
1198 9 : Node* rhs = Parameter(Type::Any(), 1);
1199 9 : Node* length = Parameter(Type::Unsigned31(), 2);
1200 : Node* effect = graph()->start();
1201 : Node* control = graph()->start();
1202 :
1203 9 : Node* check1 = effect = graph()->NewNode(
1204 9 : simplified()->CheckBounds(feedback1), lhs, length, effect, control);
1205 : Reduction r1 = Reduce(check1);
1206 9 : ASSERT_TRUE(r1.Changed());
1207 18 : EXPECT_EQ(r1.replacement(), check1);
1208 :
1209 9 : Node* check2 = effect = graph()->NewNode(
1210 9 : simplified()->CheckBounds(feedback2), rhs, length, effect, control);
1211 : Reduction r2 = Reduce(check2);
1212 9 : ASSERT_TRUE(r2.Changed());
1213 18 : EXPECT_EQ(r2.replacement(), check2);
1214 :
1215 : Node* cmp3 = effect =
1216 9 : graph()->NewNode(simplified()->SpeculativeNumberLessThanOrEqual(
1217 : NumberOperationHint::kSignedSmall),
1218 : lhs, rhs, effect, control);
1219 : Reduction r3 = Reduce(cmp3);
1220 9 : ASSERT_TRUE(r3.Changed());
1221 90 : EXPECT_THAT(r3.replacement(),
1222 : IsSpeculativeNumberLessThanOrEqual(
1223 0 : NumberOperationHint::kSignedSmall, check1, check2, _, _));
1224 : }
1225 : }
1226 : }
1227 :
1228 15443 : TEST_F(RedundancyEliminationTest,
1229 : SpeculativeNumberLessThanOrEqualWithCheckBoundsSameType) {
1230 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1231 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1232 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1233 9 : Node* lhs = Parameter(Type::UnsignedSmall(), 0);
1234 9 : Node* rhs = Parameter(Type::UnsignedSmall(), 1);
1235 9 : Node* length = Parameter(Type::Unsigned31(), 2);
1236 : Node* effect = graph()->start();
1237 : Node* control = graph()->start();
1238 :
1239 9 : Node* check1 = effect = graph()->NewNode(
1240 9 : simplified()->CheckBounds(feedback1), lhs, length, effect, control);
1241 : Reduction r1 = Reduce(check1);
1242 9 : ASSERT_TRUE(r1.Changed());
1243 18 : EXPECT_EQ(r1.replacement(), check1);
1244 :
1245 9 : Node* check2 = effect = graph()->NewNode(
1246 9 : simplified()->CheckBounds(feedback2), rhs, length, effect, control);
1247 : Reduction r2 = Reduce(check2);
1248 9 : ASSERT_TRUE(r2.Changed());
1249 18 : EXPECT_EQ(r2.replacement(), check2);
1250 :
1251 : Node* cmp3 = effect =
1252 9 : graph()->NewNode(simplified()->SpeculativeNumberLessThanOrEqual(
1253 : NumberOperationHint::kSignedSmall),
1254 : lhs, rhs, effect, control);
1255 : Reduction r3 = Reduce(cmp3);
1256 9 : ASSERT_TRUE(r3.Changed());
1257 90 : EXPECT_THAT(r3.replacement(),
1258 : IsSpeculativeNumberLessThanOrEqual(
1259 0 : NumberOperationHint::kSignedSmall, lhs, rhs, _, _));
1260 : }
1261 : }
1262 : }
1263 :
1264 : // -----------------------------------------------------------------------------
1265 : // SpeculativeNumberAdd
1266 :
1267 15443 : TEST_F(RedundancyEliminationTest,
1268 : SpeculativeNumberAddWithCheckBoundsBetterType) {
1269 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1270 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1271 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1272 15 : Node* lhs = Parameter(Type::Any(), 0);
1273 15 : Node* rhs = Parameter(Type::Any(), 1);
1274 15 : Node* length = Parameter(Type::Unsigned31(), 2);
1275 : Node* effect = graph()->start();
1276 : Node* control = graph()->start();
1277 :
1278 15 : Node* check1 = effect = graph()->NewNode(
1279 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1280 : Reduction r1 = Reduce(check1);
1281 15 : ASSERT_TRUE(r1.Changed());
1282 30 : EXPECT_EQ(r1.replacement(), check1);
1283 :
1284 15 : Node* add2 = effect = graph()->NewNode(
1285 : simplified()->SpeculativeNumberAdd(hint), lhs, rhs, effect, control);
1286 : Reduction r2 = Reduce(add2);
1287 15 : ASSERT_TRUE(r2.Changed());
1288 150 : EXPECT_THAT(r2.replacement(),
1289 0 : IsSpeculativeNumberAdd(hint, check1, rhs, _, _));
1290 : }
1291 : }
1292 : }
1293 :
1294 15443 : TEST_F(RedundancyEliminationTest, SpeculativeNumberAddWithCheckBoundsSameType) {
1295 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1296 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1297 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1298 15 : Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
1299 15 : Node* rhs = Parameter(Type::Any(), 0);
1300 15 : Node* length = Parameter(Type::Unsigned31(), 1);
1301 : Node* effect = graph()->start();
1302 : Node* control = graph()->start();
1303 :
1304 15 : Node* check1 = effect = graph()->NewNode(
1305 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1306 : Reduction r1 = Reduce(check1);
1307 15 : ASSERT_TRUE(r1.Changed());
1308 30 : EXPECT_EQ(r1.replacement(), check1);
1309 :
1310 15 : Node* add2 = effect = graph()->NewNode(
1311 : simplified()->SpeculativeNumberAdd(hint), lhs, rhs, effect, control);
1312 : Reduction r2 = Reduce(add2);
1313 15 : ASSERT_TRUE(r2.Changed());
1314 150 : EXPECT_THAT(r2.replacement(),
1315 0 : IsSpeculativeNumberAdd(hint, lhs, rhs, _, _));
1316 : }
1317 : }
1318 : }
1319 :
1320 : // -----------------------------------------------------------------------------
1321 : // SpeculativeNumberSubtract
1322 :
1323 15443 : TEST_F(RedundancyEliminationTest,
1324 : SpeculativeNumberSubtractWithCheckBoundsBetterType) {
1325 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1326 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1327 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1328 15 : Node* lhs = Parameter(Type::Any(), 0);
1329 15 : Node* rhs = Parameter(Type::Any(), 1);
1330 15 : Node* length = Parameter(Type::Unsigned31(), 2);
1331 : Node* effect = graph()->start();
1332 : Node* control = graph()->start();
1333 :
1334 15 : Node* check1 = effect = graph()->NewNode(
1335 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1336 : Reduction r1 = Reduce(check1);
1337 15 : ASSERT_TRUE(r1.Changed());
1338 30 : EXPECT_EQ(r1.replacement(), check1);
1339 :
1340 : Node* subtract2 = effect =
1341 15 : graph()->NewNode(simplified()->SpeculativeNumberSubtract(hint), lhs,
1342 : rhs, effect, control);
1343 : Reduction r2 = Reduce(subtract2);
1344 15 : ASSERT_TRUE(r2.Changed());
1345 150 : EXPECT_THAT(r2.replacement(),
1346 0 : IsSpeculativeNumberSubtract(hint, check1, rhs, _, _));
1347 : }
1348 : }
1349 : }
1350 :
1351 15443 : TEST_F(RedundancyEliminationTest,
1352 : SpeculativeNumberSubtractWithCheckBoundsSameType) {
1353 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1354 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1355 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1356 15 : Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
1357 15 : Node* rhs = Parameter(Type::Any(), 0);
1358 15 : Node* length = Parameter(Type::Unsigned31(), 1);
1359 : Node* effect = graph()->start();
1360 : Node* control = graph()->start();
1361 :
1362 15 : Node* check1 = effect = graph()->NewNode(
1363 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1364 : Reduction r1 = Reduce(check1);
1365 15 : ASSERT_TRUE(r1.Changed());
1366 30 : EXPECT_EQ(r1.replacement(), check1);
1367 :
1368 : Node* subtract2 = effect =
1369 15 : graph()->NewNode(simplified()->SpeculativeNumberSubtract(hint), lhs,
1370 : rhs, effect, control);
1371 : Reduction r2 = Reduce(subtract2);
1372 15 : ASSERT_TRUE(r2.Changed());
1373 150 : EXPECT_THAT(r2.replacement(),
1374 0 : IsSpeculativeNumberSubtract(hint, lhs, rhs, _, _));
1375 : }
1376 : }
1377 : }
1378 :
1379 : // -----------------------------------------------------------------------------
1380 : // SpeculativeSafeIntegerAdd
1381 :
1382 15443 : TEST_F(RedundancyEliminationTest,
1383 : SpeculativeSafeIntegerAddWithCheckBoundsBetterType) {
1384 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1385 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1386 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1387 15 : Node* lhs = Parameter(Type::Any(), 0);
1388 15 : Node* rhs = Parameter(Type::Any(), 1);
1389 15 : Node* length = Parameter(Type::Unsigned31(), 2);
1390 : Node* effect = graph()->start();
1391 : Node* control = graph()->start();
1392 :
1393 15 : Node* check1 = effect = graph()->NewNode(
1394 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1395 : Reduction r1 = Reduce(check1);
1396 15 : ASSERT_TRUE(r1.Changed());
1397 30 : EXPECT_EQ(r1.replacement(), check1);
1398 :
1399 : Node* add2 = effect =
1400 15 : graph()->NewNode(simplified()->SpeculativeSafeIntegerAdd(hint), lhs,
1401 : rhs, effect, control);
1402 : Reduction r2 = Reduce(add2);
1403 15 : ASSERT_TRUE(r2.Changed());
1404 150 : EXPECT_THAT(r2.replacement(),
1405 0 : IsSpeculativeSafeIntegerAdd(hint, check1, rhs, _, _));
1406 : }
1407 : }
1408 : }
1409 :
1410 15443 : TEST_F(RedundancyEliminationTest,
1411 : SpeculativeSafeIntegerAddWithCheckBoundsSameType) {
1412 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1413 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1414 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1415 15 : Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
1416 15 : Node* rhs = Parameter(Type::Any(), 0);
1417 15 : Node* length = Parameter(Type::Unsigned31(), 1);
1418 : Node* effect = graph()->start();
1419 : Node* control = graph()->start();
1420 :
1421 15 : Node* check1 = effect = graph()->NewNode(
1422 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1423 : Reduction r1 = Reduce(check1);
1424 15 : ASSERT_TRUE(r1.Changed());
1425 30 : EXPECT_EQ(r1.replacement(), check1);
1426 :
1427 : Node* add2 = effect =
1428 15 : graph()->NewNode(simplified()->SpeculativeSafeIntegerAdd(hint), lhs,
1429 : rhs, effect, control);
1430 : Reduction r2 = Reduce(add2);
1431 15 : ASSERT_TRUE(r2.Changed());
1432 150 : EXPECT_THAT(r2.replacement(),
1433 0 : IsSpeculativeSafeIntegerAdd(hint, lhs, rhs, _, _));
1434 : }
1435 : }
1436 : }
1437 :
1438 : // -----------------------------------------------------------------------------
1439 : // SpeculativeSafeIntegerSubtract
1440 :
1441 15443 : TEST_F(RedundancyEliminationTest,
1442 : SpeculativeSafeIntegerSubtractWithCheckBoundsBetterType) {
1443 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1444 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1445 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1446 15 : Node* lhs = Parameter(Type::Any(), 0);
1447 15 : Node* rhs = Parameter(Type::Any(), 1);
1448 15 : Node* length = Parameter(Type::Unsigned31(), 2);
1449 : Node* effect = graph()->start();
1450 : Node* control = graph()->start();
1451 :
1452 15 : Node* check1 = effect = graph()->NewNode(
1453 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1454 : Reduction r1 = Reduce(check1);
1455 15 : ASSERT_TRUE(r1.Changed());
1456 30 : EXPECT_EQ(r1.replacement(), check1);
1457 :
1458 : Node* subtract2 = effect =
1459 15 : graph()->NewNode(simplified()->SpeculativeSafeIntegerSubtract(hint),
1460 : lhs, rhs, effect, control);
1461 : Reduction r2 = Reduce(subtract2);
1462 15 : ASSERT_TRUE(r2.Changed());
1463 150 : EXPECT_THAT(r2.replacement(),
1464 0 : IsSpeculativeSafeIntegerSubtract(hint, check1, rhs, _, _));
1465 : }
1466 : }
1467 : }
1468 :
1469 15443 : TEST_F(RedundancyEliminationTest,
1470 : SpeculativeSafeIntegerSubtractWithCheckBoundsSameType) {
1471 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1472 13 : TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
1473 63 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1474 15 : Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
1475 15 : Node* rhs = Parameter(Type::Any(), 0);
1476 15 : Node* length = Parameter(Type::Unsigned31(), 1);
1477 : Node* effect = graph()->start();
1478 : Node* control = graph()->start();
1479 :
1480 15 : Node* check1 = effect = graph()->NewNode(
1481 15 : simplified()->CheckBounds(feedback), lhs, length, effect, control);
1482 : Reduction r1 = Reduce(check1);
1483 15 : ASSERT_TRUE(r1.Changed());
1484 30 : EXPECT_EQ(r1.replacement(), check1);
1485 :
1486 : Node* subtract2 = effect =
1487 15 : graph()->NewNode(simplified()->SpeculativeSafeIntegerSubtract(hint),
1488 : lhs, rhs, effect, control);
1489 : Reduction r2 = Reduce(subtract2);
1490 15 : ASSERT_TRUE(r2.Changed());
1491 150 : EXPECT_THAT(r2.replacement(),
1492 0 : IsSpeculativeSafeIntegerSubtract(hint, lhs, rhs, _, _));
1493 : }
1494 : }
1495 : }
1496 :
1497 : // -----------------------------------------------------------------------------
1498 : // SpeculativeToNumber
1499 :
1500 15443 : TEST_F(RedundancyEliminationTest,
1501 : SpeculativeToNumberWithCheckBoundsBetterType) {
1502 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1503 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1504 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1505 189 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1506 45 : Node* index = Parameter(Type::Any(), 0);
1507 45 : Node* length = Parameter(Type::Unsigned31(), 1);
1508 : Node* effect = graph()->start();
1509 : Node* control = graph()->start();
1510 :
1511 : Node* check1 = effect =
1512 45 : graph()->NewNode(simplified()->CheckBounds(feedback1), index,
1513 45 : length, effect, control);
1514 : Reduction r1 = Reduce(check1);
1515 45 : ASSERT_TRUE(r1.Changed());
1516 90 : EXPECT_EQ(r1.replacement(), check1);
1517 :
1518 : Node* to_number2 = effect =
1519 45 : graph()->NewNode(simplified()->SpeculativeToNumber(hint, feedback2),
1520 : index, effect, control);
1521 : Reduction r2 = Reduce(to_number2);
1522 45 : ASSERT_TRUE(r2.Changed());
1523 225 : EXPECT_THAT(r2.replacement(), IsSpeculativeToNumber(check1));
1524 : }
1525 : }
1526 : }
1527 : }
1528 :
1529 15443 : TEST_F(RedundancyEliminationTest, SpeculativeToNumberWithCheckBoundsSameType) {
1530 2 : Typer typer(broker(), Typer::kNoFlags, graph());
1531 13 : TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
1532 39 : TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
1533 189 : TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
1534 45 : Node* index = Parameter(Type::Range(42.0, 42.0, zone()), 0);
1535 45 : Node* length = Parameter(Type::Unsigned31(), 1);
1536 : Node* effect = graph()->start();
1537 : Node* control = graph()->start();
1538 :
1539 : Node* check1 = effect =
1540 45 : graph()->NewNode(simplified()->CheckBounds(feedback1), index,
1541 45 : length, effect, control);
1542 : Reduction r1 = Reduce(check1);
1543 45 : ASSERT_TRUE(r1.Changed());
1544 90 : EXPECT_EQ(r1.replacement(), check1);
1545 :
1546 : Node* to_number2 = effect =
1547 45 : graph()->NewNode(simplified()->SpeculativeToNumber(hint, feedback2),
1548 : index, effect, control);
1549 : Reduction r2 = Reduce(to_number2);
1550 45 : ASSERT_TRUE(r2.Changed());
1551 225 : EXPECT_THAT(r2.replacement(), IsSpeculativeToNumber(index));
1552 : }
1553 : }
1554 : }
1555 : }
1556 :
1557 : } // namespace redundancy_elimination_unittest
1558 : } // namespace compiler
1559 : } // namespace internal
1560 9264 : } // namespace v8
|
