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 #include "src/compiler/common-operator.h"
6 #include "src/compiler/common-operator-reducer.h"
7 #include "src/compiler/machine-operator.h"
8 #include "src/compiler/operator.h"
9 #include "src/compiler/simplified-operator.h"
10 #include "src/machine-type.h"
11 #include "test/unittests/compiler/graph-reducer-unittest.h"
12 #include "test/unittests/compiler/graph-unittest.h"
13 #include "test/unittests/compiler/node-test-utils.h"
14
15 using testing::StrictMock;
16
17 namespace v8 {
18 namespace internal {
19 namespace compiler {
20
21 class CommonOperatorReducerTest : public GraphTest {
22 public:
CommonOperatorReducerTest(int num_parameters=1)23 explicit CommonOperatorReducerTest(int num_parameters = 1)
24 : GraphTest(num_parameters), machine_(zone()), simplified_(zone()) {}
~CommonOperatorReducerTest()25 ~CommonOperatorReducerTest() override {}
26
27 protected:
Reduce(AdvancedReducer::Editor * editor,Node * node,MachineOperatorBuilder::Flags flags=MachineOperatorBuilder::kNoFlags)28 Reduction Reduce(
29 AdvancedReducer::Editor* editor, Node* node,
30 MachineOperatorBuilder::Flags flags = MachineOperatorBuilder::kNoFlags) {
31 MachineOperatorBuilder machine(zone(), MachineType::PointerRepresentation(),
32 flags);
33 CommonOperatorReducer reducer(editor, graph(), common(), &machine);
34 return reducer.Reduce(node);
35 }
36
Reduce(Node * node,MachineOperatorBuilder::Flags flags=MachineOperatorBuilder::kNoFlags)37 Reduction Reduce(Node* node, MachineOperatorBuilder::Flags flags =
38 MachineOperatorBuilder::kNoFlags) {
39 StrictMock<MockAdvancedReducerEditor> editor;
40 return Reduce(&editor, node, flags);
41 }
42
machine()43 MachineOperatorBuilder* machine() { return &machine_; }
simplified()44 SimplifiedOperatorBuilder* simplified() { return &simplified_; }
45
46 private:
47 MachineOperatorBuilder machine_;
48 SimplifiedOperatorBuilder simplified_;
49 };
50
51
52 namespace {
53
54 const BranchHint kBranchHints[] = {BranchHint::kNone, BranchHint::kFalse,
55 BranchHint::kTrue};
56
57
58 const MachineRepresentation kMachineRepresentations[] = {
59 MachineRepresentation::kBit, MachineRepresentation::kWord8,
60 MachineRepresentation::kWord16, MachineRepresentation::kWord32,
61 MachineRepresentation::kWord64, MachineRepresentation::kFloat32,
62 MachineRepresentation::kFloat64, MachineRepresentation::kTagged};
63
64
65 const Operator kOp0(0, Operator::kNoProperties, "Op0", 0, 0, 0, 1, 1, 0);
66
67 } // namespace
68
69
70 // -----------------------------------------------------------------------------
71 // Branch
72
73
TEST_F(CommonOperatorReducerTest,BranchWithInt32ZeroConstant)74 TEST_F(CommonOperatorReducerTest, BranchWithInt32ZeroConstant) {
75 TRACED_FOREACH(BranchHint, hint, kBranchHints) {
76 Node* const control = graph()->start();
77 Node* const branch =
78 graph()->NewNode(common()->Branch(hint), Int32Constant(0), control);
79 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
80 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
81 StrictMock<MockAdvancedReducerEditor> editor;
82 EXPECT_CALL(editor, Replace(if_true, IsDead()));
83 EXPECT_CALL(editor, Replace(if_false, control));
84 Reduction const r = Reduce(&editor, branch);
85 ASSERT_TRUE(r.Changed());
86 EXPECT_THAT(r.replacement(), IsDead());
87 }
88 }
89
90
TEST_F(CommonOperatorReducerTest,BranchWithInt32OneConstant)91 TEST_F(CommonOperatorReducerTest, BranchWithInt32OneConstant) {
92 TRACED_FOREACH(BranchHint, hint, kBranchHints) {
93 Node* const control = graph()->start();
94 Node* const branch =
95 graph()->NewNode(common()->Branch(hint), Int32Constant(1), control);
96 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
97 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
98 StrictMock<MockAdvancedReducerEditor> editor;
99 EXPECT_CALL(editor, Replace(if_true, control));
100 EXPECT_CALL(editor, Replace(if_false, IsDead()));
101 Reduction const r = Reduce(&editor, branch);
102 ASSERT_TRUE(r.Changed());
103 EXPECT_THAT(r.replacement(), IsDead());
104 }
105 }
106
107
TEST_F(CommonOperatorReducerTest,BranchWithFalseConstant)108 TEST_F(CommonOperatorReducerTest, BranchWithFalseConstant) {
109 TRACED_FOREACH(BranchHint, hint, kBranchHints) {
110 Node* const control = graph()->start();
111 Node* const branch =
112 graph()->NewNode(common()->Branch(hint), FalseConstant(), control);
113 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
114 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
115 StrictMock<MockAdvancedReducerEditor> editor;
116 EXPECT_CALL(editor, Replace(if_true, IsDead()));
117 EXPECT_CALL(editor, Replace(if_false, control));
118 Reduction const r = Reduce(&editor, branch);
119 ASSERT_TRUE(r.Changed());
120 EXPECT_THAT(r.replacement(), IsDead());
121 }
122 }
123
124
TEST_F(CommonOperatorReducerTest,BranchWithTrueConstant)125 TEST_F(CommonOperatorReducerTest, BranchWithTrueConstant) {
126 TRACED_FOREACH(BranchHint, hint, kBranchHints) {
127 Node* const control = graph()->start();
128 Node* const branch =
129 graph()->NewNode(common()->Branch(hint), TrueConstant(), control);
130 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
131 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
132 StrictMock<MockAdvancedReducerEditor> editor;
133 EXPECT_CALL(editor, Replace(if_true, control));
134 EXPECT_CALL(editor, Replace(if_false, IsDead()));
135 Reduction const r = Reduce(&editor, branch);
136 ASSERT_TRUE(r.Changed());
137 EXPECT_THAT(r.replacement(), IsDead());
138 }
139 }
140
141
TEST_F(CommonOperatorReducerTest,BranchWithBooleanNot)142 TEST_F(CommonOperatorReducerTest, BranchWithBooleanNot) {
143 Node* const value = Parameter(0);
144 TRACED_FOREACH(BranchHint, hint, kBranchHints) {
145 Node* const control = graph()->start();
146 Node* const branch = graph()->NewNode(
147 common()->Branch(hint),
148 graph()->NewNode(simplified()->BooleanNot(), value), control);
149 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
150 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
151 Reduction const r = Reduce(branch);
152 ASSERT_TRUE(r.Changed());
153 EXPECT_EQ(branch, r.replacement());
154 EXPECT_THAT(branch, IsBranch(value, control));
155 EXPECT_THAT(if_false, IsIfTrue(branch));
156 EXPECT_THAT(if_true, IsIfFalse(branch));
157 EXPECT_EQ(NegateBranchHint(hint), BranchHintOf(branch->op()));
158 }
159 }
160
161
162 // -----------------------------------------------------------------------------
163 // Merge
164
165
TEST_F(CommonOperatorReducerTest,MergeOfUnusedDiamond0)166 TEST_F(CommonOperatorReducerTest, MergeOfUnusedDiamond0) {
167 Node* const value = Parameter(0);
168 Node* const control = graph()->start();
169 Node* const branch = graph()->NewNode(common()->Branch(), value, control);
170 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
171 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
172 Reduction const r =
173 Reduce(graph()->NewNode(common()->Merge(2), if_true, if_false));
174 ASSERT_TRUE(r.Changed());
175 EXPECT_EQ(control, r.replacement());
176 EXPECT_THAT(branch, IsDead());
177 }
178
179
TEST_F(CommonOperatorReducerTest,MergeOfUnusedDiamond1)180 TEST_F(CommonOperatorReducerTest, MergeOfUnusedDiamond1) {
181 Node* const value = Parameter(0);
182 Node* const control = graph()->start();
183 Node* const branch = graph()->NewNode(common()->Branch(), value, control);
184 Node* const if_true = graph()->NewNode(common()->IfTrue(), branch);
185 Node* const if_false = graph()->NewNode(common()->IfFalse(), branch);
186 Reduction const r =
187 Reduce(graph()->NewNode(common()->Merge(2), if_false, if_true));
188 ASSERT_TRUE(r.Changed());
189 EXPECT_EQ(control, r.replacement());
190 EXPECT_THAT(branch, IsDead());
191 }
192
193
194 // -----------------------------------------------------------------------------
195 // EffectPhi
196
197
TEST_F(CommonOperatorReducerTest,EffectPhiWithMerge)198 TEST_F(CommonOperatorReducerTest, EffectPhiWithMerge) {
199 const int kMaxInputs = 64;
200 Node* inputs[kMaxInputs];
201 Node* const input = graph()->NewNode(&kOp0);
202 TRACED_FORRANGE(int, input_count, 2, kMaxInputs - 1) {
203 int const value_input_count = input_count - 1;
204 for (int i = 0; i < value_input_count; ++i) {
205 inputs[i] = graph()->start();
206 }
207 Node* const merge = graph()->NewNode(common()->Merge(value_input_count),
208 value_input_count, inputs);
209 for (int i = 0; i < value_input_count; ++i) {
210 inputs[i] = input;
211 }
212 inputs[value_input_count] = merge;
213 StrictMock<MockAdvancedReducerEditor> editor;
214 EXPECT_CALL(editor, Revisit(merge));
215 Reduction r =
216 Reduce(&editor, graph()->NewNode(common()->EffectPhi(value_input_count),
217 input_count, inputs));
218 ASSERT_TRUE(r.Changed());
219 EXPECT_EQ(input, r.replacement());
220 }
221 }
222
223
TEST_F(CommonOperatorReducerTest,EffectPhiWithLoop)224 TEST_F(CommonOperatorReducerTest, EffectPhiWithLoop) {
225 Node* const e0 = graph()->NewNode(&kOp0);
226 Node* const loop =
227 graph()->NewNode(common()->Loop(2), graph()->start(), graph()->start());
228 loop->ReplaceInput(1, loop);
229 Node* const ephi = graph()->NewNode(common()->EffectPhi(2), e0, e0, loop);
230 ephi->ReplaceInput(1, ephi);
231 StrictMock<MockAdvancedReducerEditor> editor;
232 EXPECT_CALL(editor, Revisit(loop));
233 Reduction const r = Reduce(&editor, ephi);
234 ASSERT_TRUE(r.Changed());
235 EXPECT_EQ(e0, r.replacement());
236 }
237
238
239 // -----------------------------------------------------------------------------
240 // Phi
241
242
TEST_F(CommonOperatorReducerTest,PhiWithMerge)243 TEST_F(CommonOperatorReducerTest, PhiWithMerge) {
244 const int kMaxInputs = 64;
245 Node* inputs[kMaxInputs];
246 Node* const input = graph()->NewNode(&kOp0);
247 TRACED_FORRANGE(int, input_count, 2, kMaxInputs - 1) {
248 int const value_input_count = input_count - 1;
249 TRACED_FOREACH(MachineRepresentation, rep, kMachineRepresentations) {
250 for (int i = 0; i < value_input_count; ++i) {
251 inputs[i] = graph()->start();
252 }
253 Node* const merge = graph()->NewNode(common()->Merge(value_input_count),
254 value_input_count, inputs);
255 for (int i = 0; i < value_input_count; ++i) {
256 inputs[i] = input;
257 }
258 inputs[value_input_count] = merge;
259 StrictMock<MockAdvancedReducerEditor> editor;
260 EXPECT_CALL(editor, Revisit(merge));
261 Reduction r = Reduce(
262 &editor, graph()->NewNode(common()->Phi(rep, value_input_count),
263 input_count, inputs));
264 ASSERT_TRUE(r.Changed());
265 EXPECT_EQ(input, r.replacement());
266 }
267 }
268 }
269
270
TEST_F(CommonOperatorReducerTest,PhiWithLoop)271 TEST_F(CommonOperatorReducerTest, PhiWithLoop) {
272 Node* const p0 = Parameter(0);
273 Node* const loop =
274 graph()->NewNode(common()->Loop(2), graph()->start(), graph()->start());
275 loop->ReplaceInput(1, loop);
276 Node* const phi = graph()->NewNode(
277 common()->Phi(MachineRepresentation::kTagged, 2), p0, p0, loop);
278 phi->ReplaceInput(1, phi);
279 StrictMock<MockAdvancedReducerEditor> editor;
280 EXPECT_CALL(editor, Revisit(loop));
281 Reduction const r = Reduce(&editor, phi);
282 ASSERT_TRUE(r.Changed());
283 EXPECT_EQ(p0, r.replacement());
284 }
285
286
TEST_F(CommonOperatorReducerTest,PhiToFloat32Abs)287 TEST_F(CommonOperatorReducerTest, PhiToFloat32Abs) {
288 Node* p0 = Parameter(0);
289 Node* c0 = Float32Constant(0.0);
290 Node* check = graph()->NewNode(machine()->Float32LessThan(), c0, p0);
291 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
292 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
293 Node* vtrue = p0;
294 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
295 Node* vfalse = graph()->NewNode(machine()->Float32Sub(), c0, p0);
296 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
297 Node* phi = graph()->NewNode(
298 common()->Phi(MachineRepresentation::kFloat32, 2), vtrue, vfalse, merge);
299 StrictMock<MockAdvancedReducerEditor> editor;
300 EXPECT_CALL(editor, Revisit(merge));
301 Reduction r = Reduce(&editor, phi);
302 ASSERT_TRUE(r.Changed());
303 EXPECT_THAT(r.replacement(), IsFloat32Abs(p0));
304 }
305
306
TEST_F(CommonOperatorReducerTest,PhiToFloat64Abs)307 TEST_F(CommonOperatorReducerTest, PhiToFloat64Abs) {
308 Node* p0 = Parameter(0);
309 Node* c0 = Float64Constant(0.0);
310 Node* check = graph()->NewNode(machine()->Float64LessThan(), c0, p0);
311 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
312 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
313 Node* vtrue = p0;
314 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
315 Node* vfalse = graph()->NewNode(machine()->Float64Sub(), c0, p0);
316 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
317 Node* phi = graph()->NewNode(
318 common()->Phi(MachineRepresentation::kFloat64, 2), vtrue, vfalse, merge);
319 StrictMock<MockAdvancedReducerEditor> editor;
320 EXPECT_CALL(editor, Revisit(merge));
321 Reduction r = Reduce(&editor, phi);
322 ASSERT_TRUE(r.Changed());
323 EXPECT_THAT(r.replacement(), IsFloat64Abs(p0));
324 }
325
326
TEST_F(CommonOperatorReducerTest,PhiToFloat32Max)327 TEST_F(CommonOperatorReducerTest, PhiToFloat32Max) {
328 Node* p0 = Parameter(0);
329 Node* p1 = Parameter(1);
330 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1);
331 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
332 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
333 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
334 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
335 Node* phi = graph()->NewNode(
336 common()->Phi(MachineRepresentation::kFloat32, 2), p1, p0, merge);
337 StrictMock<MockAdvancedReducerEditor> editor;
338 EXPECT_CALL(editor, Revisit(merge));
339 Reduction r = Reduce(&editor, phi, MachineOperatorBuilder::kFloat32Max);
340 ASSERT_TRUE(r.Changed());
341 EXPECT_THAT(r.replacement(), IsFloat32Max(p1, p0));
342 }
343
344
TEST_F(CommonOperatorReducerTest,PhiToFloat64Max)345 TEST_F(CommonOperatorReducerTest, PhiToFloat64Max) {
346 Node* p0 = Parameter(0);
347 Node* p1 = Parameter(1);
348 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1);
349 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
350 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
351 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
352 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
353 Node* phi = graph()->NewNode(
354 common()->Phi(MachineRepresentation::kFloat64, 2), p1, p0, merge);
355 StrictMock<MockAdvancedReducerEditor> editor;
356 EXPECT_CALL(editor, Revisit(merge));
357 Reduction r = Reduce(&editor, phi, MachineOperatorBuilder::kFloat64Max);
358 ASSERT_TRUE(r.Changed());
359 EXPECT_THAT(r.replacement(), IsFloat64Max(p1, p0));
360 }
361
362
TEST_F(CommonOperatorReducerTest,PhiToFloat32Min)363 TEST_F(CommonOperatorReducerTest, PhiToFloat32Min) {
364 Node* p0 = Parameter(0);
365 Node* p1 = Parameter(1);
366 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1);
367 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
368 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
369 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
370 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
371 Node* phi = graph()->NewNode(
372 common()->Phi(MachineRepresentation::kFloat32, 2), p0, p1, merge);
373 StrictMock<MockAdvancedReducerEditor> editor;
374 EXPECT_CALL(editor, Revisit(merge));
375 Reduction r = Reduce(&editor, phi, MachineOperatorBuilder::kFloat32Min);
376 ASSERT_TRUE(r.Changed());
377 EXPECT_THAT(r.replacement(), IsFloat32Min(p0, p1));
378 }
379
380
TEST_F(CommonOperatorReducerTest,PhiToFloat64Min)381 TEST_F(CommonOperatorReducerTest, PhiToFloat64Min) {
382 Node* p0 = Parameter(0);
383 Node* p1 = Parameter(1);
384 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1);
385 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start());
386 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
387 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
388 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
389 Node* phi = graph()->NewNode(
390 common()->Phi(MachineRepresentation::kFloat64, 2), p0, p1, merge);
391 StrictMock<MockAdvancedReducerEditor> editor;
392 EXPECT_CALL(editor, Revisit(merge));
393 Reduction r = Reduce(&editor, phi, MachineOperatorBuilder::kFloat64Min);
394 ASSERT_TRUE(r.Changed());
395 EXPECT_THAT(r.replacement(), IsFloat64Min(p0, p1));
396 }
397
398
399 // -----------------------------------------------------------------------------
400 // Return
401
402
TEST_F(CommonOperatorReducerTest,ReturnWithPhiAndEffectPhiAndMerge)403 TEST_F(CommonOperatorReducerTest, ReturnWithPhiAndEffectPhiAndMerge) {
404 Node* cond = Parameter(2);
405 Node* branch = graph()->NewNode(common()->Branch(), cond, graph()->start());
406 Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
407 Node* etrue = graph()->start();
408 Node* vtrue = Parameter(0);
409 Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
410 Node* efalse = graph()->start();
411 Node* vfalse = Parameter(1);
412 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
413 Node* ephi = graph()->NewNode(common()->EffectPhi(2), etrue, efalse, merge);
414 Node* phi = graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 2),
415 vtrue, vfalse, merge);
416 Node* ret = graph()->NewNode(common()->Return(), phi, ephi, merge);
417 graph()->SetEnd(graph()->NewNode(common()->End(1), ret));
418 StrictMock<MockAdvancedReducerEditor> editor;
419 EXPECT_CALL(editor, Replace(merge, IsDead()));
420 Reduction const r = Reduce(&editor, ret);
421 ASSERT_TRUE(r.Changed());
422 EXPECT_THAT(r.replacement(), IsDead());
423 EXPECT_THAT(graph()->end(), IsEnd(ret, IsReturn(vtrue, etrue, if_true),
424 IsReturn(vfalse, efalse, if_false)));
425 }
426
427
428 // -----------------------------------------------------------------------------
429 // Select
430
431
TEST_F(CommonOperatorReducerTest,SelectWithSameThenAndElse)432 TEST_F(CommonOperatorReducerTest, SelectWithSameThenAndElse) {
433 Node* const input = graph()->NewNode(&kOp0);
434 TRACED_FOREACH(BranchHint, hint, kBranchHints) {
435 TRACED_FOREACH(MachineRepresentation, rep, kMachineRepresentations) {
436 Reduction r = Reduce(
437 graph()->NewNode(common()->Select(rep, hint), input, input, input));
438 ASSERT_TRUE(r.Changed());
439 EXPECT_EQ(input, r.replacement());
440 }
441 }
442 }
443
444
TEST_F(CommonOperatorReducerTest,SelectWithInt32ZeroConstant)445 TEST_F(CommonOperatorReducerTest, SelectWithInt32ZeroConstant) {
446 Node* p0 = Parameter(0);
447 Node* p1 = Parameter(1);
448 Node* select =
449 graph()->NewNode(common()->Select(MachineRepresentation::kTagged),
450 Int32Constant(0), p0, p1);
451 Reduction r = Reduce(select);
452 ASSERT_TRUE(r.Changed());
453 EXPECT_EQ(p1, r.replacement());
454 }
455
456
TEST_F(CommonOperatorReducerTest,SelectWithInt32OneConstant)457 TEST_F(CommonOperatorReducerTest, SelectWithInt32OneConstant) {
458 Node* p0 = Parameter(0);
459 Node* p1 = Parameter(1);
460 Node* select =
461 graph()->NewNode(common()->Select(MachineRepresentation::kTagged),
462 Int32Constant(1), p0, p1);
463 Reduction r = Reduce(select);
464 ASSERT_TRUE(r.Changed());
465 EXPECT_EQ(p0, r.replacement());
466 }
467
468
TEST_F(CommonOperatorReducerTest,SelectWithFalseConstant)469 TEST_F(CommonOperatorReducerTest, SelectWithFalseConstant) {
470 Node* p0 = Parameter(0);
471 Node* p1 = Parameter(1);
472 Node* select =
473 graph()->NewNode(common()->Select(MachineRepresentation::kTagged),
474 FalseConstant(), p0, p1);
475 Reduction r = Reduce(select);
476 ASSERT_TRUE(r.Changed());
477 EXPECT_EQ(p1, r.replacement());
478 }
479
480
TEST_F(CommonOperatorReducerTest,SelectWithTrueConstant)481 TEST_F(CommonOperatorReducerTest, SelectWithTrueConstant) {
482 Node* p0 = Parameter(0);
483 Node* p1 = Parameter(1);
484 Node* select = graph()->NewNode(
485 common()->Select(MachineRepresentation::kTagged), TrueConstant(), p0, p1);
486 Reduction r = Reduce(select);
487 ASSERT_TRUE(r.Changed());
488 EXPECT_EQ(p0, r.replacement());
489 }
490
491
TEST_F(CommonOperatorReducerTest,SelectToFloat32Abs)492 TEST_F(CommonOperatorReducerTest, SelectToFloat32Abs) {
493 Node* p0 = Parameter(0);
494 Node* c0 = Float32Constant(0.0);
495 Node* check = graph()->NewNode(machine()->Float32LessThan(), c0, p0);
496 Node* select =
497 graph()->NewNode(common()->Select(MachineRepresentation::kFloat32), check,
498 p0, graph()->NewNode(machine()->Float32Sub(), c0, p0));
499 Reduction r = Reduce(select);
500 ASSERT_TRUE(r.Changed());
501 EXPECT_THAT(r.replacement(), IsFloat32Abs(p0));
502 }
503
504
TEST_F(CommonOperatorReducerTest,SelectToFloat64Abs)505 TEST_F(CommonOperatorReducerTest, SelectToFloat64Abs) {
506 Node* p0 = Parameter(0);
507 Node* c0 = Float64Constant(0.0);
508 Node* check = graph()->NewNode(machine()->Float64LessThan(), c0, p0);
509 Node* select =
510 graph()->NewNode(common()->Select(MachineRepresentation::kFloat64), check,
511 p0, graph()->NewNode(machine()->Float64Sub(), c0, p0));
512 Reduction r = Reduce(select);
513 ASSERT_TRUE(r.Changed());
514 EXPECT_THAT(r.replacement(), IsFloat64Abs(p0));
515 }
516
517
TEST_F(CommonOperatorReducerTest,SelectToFloat32Max)518 TEST_F(CommonOperatorReducerTest, SelectToFloat32Max) {
519 Node* p0 = Parameter(0);
520 Node* p1 = Parameter(1);
521 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1);
522 Node* select = graph()->NewNode(
523 common()->Select(MachineRepresentation::kFloat32), check, p1, p0);
524 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat32Max);
525 ASSERT_TRUE(r.Changed());
526 EXPECT_THAT(r.replacement(), IsFloat32Max(p1, p0));
527 }
528
529
TEST_F(CommonOperatorReducerTest,SelectToFloat64Max)530 TEST_F(CommonOperatorReducerTest, SelectToFloat64Max) {
531 Node* p0 = Parameter(0);
532 Node* p1 = Parameter(1);
533 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1);
534 Node* select = graph()->NewNode(
535 common()->Select(MachineRepresentation::kFloat64), check, p1, p0);
536 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat64Max);
537 ASSERT_TRUE(r.Changed());
538 EXPECT_THAT(r.replacement(), IsFloat64Max(p1, p0));
539 }
540
541
TEST_F(CommonOperatorReducerTest,SelectToFloat32Min)542 TEST_F(CommonOperatorReducerTest, SelectToFloat32Min) {
543 Node* p0 = Parameter(0);
544 Node* p1 = Parameter(1);
545 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1);
546 Node* select = graph()->NewNode(
547 common()->Select(MachineRepresentation::kFloat32), check, p0, p1);
548 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat32Min);
549 ASSERT_TRUE(r.Changed());
550 EXPECT_THAT(r.replacement(), IsFloat32Min(p0, p1));
551 }
552
553
TEST_F(CommonOperatorReducerTest,SelectToFloat64Min)554 TEST_F(CommonOperatorReducerTest, SelectToFloat64Min) {
555 Node* p0 = Parameter(0);
556 Node* p1 = Parameter(1);
557 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1);
558 Node* select = graph()->NewNode(
559 common()->Select(MachineRepresentation::kFloat64), check, p0, p1);
560 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat64Min);
561 ASSERT_TRUE(r.Changed());
562 EXPECT_THAT(r.replacement(), IsFloat64Min(p0, p1));
563 }
564
565 } // namespace compiler
566 } // namespace internal
567 } // namespace v8
568