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 #include "src/compiler/common-operator-reducer.h" | 6 #include "src/compiler/common-operator-reducer.h" |
7 #include "src/compiler/js-graph.h" | 7 #include "src/compiler/js-graph.h" |
8 #include "src/compiler/js-operator.h" | 8 #include "src/compiler/js-operator.h" |
9 #include "src/compiler/machine-operator.h" | 9 #include "src/compiler/machine-operator.h" |
10 #include "src/compiler/machine-type.h" | 10 #include "src/compiler/machine-type.h" |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
101 inputs[value_input_count] = merge; | 101 inputs[value_input_count] = merge; |
102 Reduction r = Reduce(graph()->NewNode( | 102 Reduction r = Reduce(graph()->NewNode( |
103 common()->Phi(type, value_input_count), input_count, inputs)); | 103 common()->Phi(type, value_input_count), input_count, inputs)); |
104 ASSERT_TRUE(r.Changed()); | 104 ASSERT_TRUE(r.Changed()); |
105 EXPECT_EQ(input, r.replacement()); | 105 EXPECT_EQ(input, r.replacement()); |
106 } | 106 } |
107 } | 107 } |
108 } | 108 } |
109 | 109 |
110 | 110 |
111 TEST_F(CommonOperatorReducerTest, PhiToFloat64MaxOrFloat64Min) { | 111 TEST_F(CommonOperatorReducerTest, PhiToFloat32Abs) { |
| 112 Node* p0 = Parameter(0); |
| 113 Node* c0 = Float32Constant(0.0); |
| 114 Node* check = graph()->NewNode(machine()->Float32LessThan(), c0, p0); |
| 115 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); |
| 116 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); |
| 117 Node* vtrue = p0; |
| 118 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); |
| 119 Node* vfalse = graph()->NewNode(machine()->Float32Sub(), c0, p0); |
| 120 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); |
| 121 Node* phi = |
| 122 graph()->NewNode(common()->Phi(kMachFloat32, 2), vtrue, vfalse, merge); |
| 123 Reduction r = Reduce(phi, MachineOperatorBuilder::kFloat32Abs); |
| 124 ASSERT_TRUE(r.Changed()); |
| 125 EXPECT_THAT(r.replacement(), IsFloat32Abs(p0)); |
| 126 } |
| 127 |
| 128 |
| 129 TEST_F(CommonOperatorReducerTest, PhiToFloat64Abs) { |
| 130 Node* p0 = Parameter(0); |
| 131 Node* c0 = Float64Constant(0.0); |
| 132 Node* check = graph()->NewNode(machine()->Float64LessThan(), c0, p0); |
| 133 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); |
| 134 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); |
| 135 Node* vtrue = p0; |
| 136 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); |
| 137 Node* vfalse = graph()->NewNode(machine()->Float64Sub(), c0, p0); |
| 138 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); |
| 139 Node* phi = |
| 140 graph()->NewNode(common()->Phi(kMachFloat64, 2), vtrue, vfalse, merge); |
| 141 Reduction r = Reduce(phi, MachineOperatorBuilder::kFloat64Abs); |
| 142 ASSERT_TRUE(r.Changed()); |
| 143 EXPECT_THAT(r.replacement(), IsFloat64Abs(p0)); |
| 144 } |
| 145 |
| 146 |
| 147 TEST_F(CommonOperatorReducerTest, PhiToFloat32Max) { |
| 148 Node* p0 = Parameter(0); |
| 149 Node* p1 = Parameter(1); |
| 150 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1); |
| 151 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); |
| 152 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); |
| 153 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); |
| 154 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); |
| 155 Node* phi = graph()->NewNode(common()->Phi(kMachFloat32, 2), p1, p0, merge); |
| 156 Reduction r = Reduce(phi, MachineOperatorBuilder::kFloat32Max); |
| 157 ASSERT_TRUE(r.Changed()); |
| 158 EXPECT_THAT(r.replacement(), IsFloat32Max(p1, p0)); |
| 159 } |
| 160 |
| 161 |
| 162 TEST_F(CommonOperatorReducerTest, PhiToFloat64Max) { |
112 Node* p0 = Parameter(0); | 163 Node* p0 = Parameter(0); |
113 Node* p1 = Parameter(1); | 164 Node* p1 = Parameter(1); |
114 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1); | 165 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1); |
| 166 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); |
| 167 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); |
| 168 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); |
| 169 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); |
| 170 Node* phi = graph()->NewNode(common()->Phi(kMachFloat64, 2), p1, p0, merge); |
| 171 Reduction r = Reduce(phi, MachineOperatorBuilder::kFloat64Max); |
| 172 ASSERT_TRUE(r.Changed()); |
| 173 EXPECT_THAT(r.replacement(), IsFloat64Max(p1, p0)); |
| 174 } |
| 175 |
| 176 |
| 177 TEST_F(CommonOperatorReducerTest, PhiToFloat32Min) { |
| 178 Node* p0 = Parameter(0); |
| 179 Node* p1 = Parameter(1); |
| 180 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1); |
| 181 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); |
| 182 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); |
| 183 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); |
| 184 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); |
| 185 Node* phi = graph()->NewNode(common()->Phi(kMachFloat32, 2), p0, p1, merge); |
| 186 Reduction r = Reduce(phi, MachineOperatorBuilder::kFloat32Min); |
| 187 ASSERT_TRUE(r.Changed()); |
| 188 EXPECT_THAT(r.replacement(), IsFloat32Min(p0, p1)); |
| 189 } |
| 190 |
| 191 |
| 192 TEST_F(CommonOperatorReducerTest, PhiToFloat64Min) { |
| 193 Node* p0 = Parameter(0); |
| 194 Node* p1 = Parameter(1); |
| 195 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1); |
115 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); | 196 Node* branch = graph()->NewNode(common()->Branch(), check, graph()->start()); |
116 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); | 197 Node* if_true = graph()->NewNode(common()->IfTrue(), branch); |
117 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); | 198 Node* if_false = graph()->NewNode(common()->IfFalse(), branch); |
118 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); | 199 Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); |
119 Reduction r1 = | 200 Node* phi = graph()->NewNode(common()->Phi(kMachFloat64, 2), p0, p1, merge); |
120 Reduce(graph()->NewNode(common()->Phi(kMachFloat64, 2), p1, p0, merge), | 201 Reduction r = Reduce(phi, MachineOperatorBuilder::kFloat64Min); |
121 MachineOperatorBuilder::kFloat64Max); | 202 ASSERT_TRUE(r.Changed()); |
122 ASSERT_TRUE(r1.Changed()); | 203 EXPECT_THAT(r.replacement(), IsFloat64Min(p0, p1)); |
123 EXPECT_THAT(r1.replacement(), IsFloat64Max(p1, p0)); | |
124 Reduction r2 = | |
125 Reduce(graph()->NewNode(common()->Phi(kMachFloat64, 2), p0, p1, merge), | |
126 MachineOperatorBuilder::kFloat64Min); | |
127 ASSERT_TRUE(r2.Changed()); | |
128 EXPECT_THAT(r2.replacement(), IsFloat64Min(p0, p1)); | |
129 } | 204 } |
130 | 205 |
131 | 206 |
132 // ----------------------------------------------------------------------------- | 207 // ----------------------------------------------------------------------------- |
133 // Select | 208 // Select |
134 | 209 |
135 | 210 |
136 TEST_F(CommonOperatorReducerTest, RedundantSelect) { | 211 TEST_F(CommonOperatorReducerTest, RedundantSelect) { |
137 Node* const input = graph()->NewNode(&kOp0); | 212 Node* const input = graph()->NewNode(&kOp0); |
138 TRACED_FOREACH(BranchHint, hint, kBranchHints) { | 213 TRACED_FOREACH(BranchHint, hint, kBranchHints) { |
139 TRACED_FOREACH(MachineType, type, kMachineTypes) { | 214 TRACED_FOREACH(MachineType, type, kMachineTypes) { |
140 Reduction r = Reduce( | 215 Reduction r = Reduce( |
141 graph()->NewNode(common()->Select(type, hint), input, input, input)); | 216 graph()->NewNode(common()->Select(type, hint), input, input, input)); |
142 ASSERT_TRUE(r.Changed()); | 217 ASSERT_TRUE(r.Changed()); |
143 EXPECT_EQ(input, r.replacement()); | 218 EXPECT_EQ(input, r.replacement()); |
144 } | 219 } |
145 } | 220 } |
146 } | 221 } |
147 | 222 |
148 | 223 |
149 TEST_F(CommonOperatorReducerTest, SelectToFloat64MaxOrFloat64Min) { | 224 TEST_F(CommonOperatorReducerTest, SelectToFloat32Abs) { |
| 225 Node* p0 = Parameter(0); |
| 226 Node* c0 = Float32Constant(0.0); |
| 227 Node* check = graph()->NewNode(machine()->Float32LessThan(), c0, p0); |
| 228 Node* select = |
| 229 graph()->NewNode(common()->Select(kMachFloat32), check, p0, |
| 230 graph()->NewNode(machine()->Float32Sub(), c0, p0)); |
| 231 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat32Abs); |
| 232 ASSERT_TRUE(r.Changed()); |
| 233 EXPECT_THAT(r.replacement(), IsFloat32Abs(p0)); |
| 234 } |
| 235 |
| 236 |
| 237 TEST_F(CommonOperatorReducerTest, SelectToFloat64Abs) { |
| 238 Node* p0 = Parameter(0); |
| 239 Node* c0 = Float64Constant(0.0); |
| 240 Node* check = graph()->NewNode(machine()->Float64LessThan(), c0, p0); |
| 241 Node* select = |
| 242 graph()->NewNode(common()->Select(kMachFloat64), check, p0, |
| 243 graph()->NewNode(machine()->Float64Sub(), c0, p0)); |
| 244 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat64Abs); |
| 245 ASSERT_TRUE(r.Changed()); |
| 246 EXPECT_THAT(r.replacement(), IsFloat64Abs(p0)); |
| 247 } |
| 248 |
| 249 |
| 250 TEST_F(CommonOperatorReducerTest, SelectToFloat32Max) { |
| 251 Node* p0 = Parameter(0); |
| 252 Node* p1 = Parameter(1); |
| 253 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1); |
| 254 Node* select = |
| 255 graph()->NewNode(common()->Select(kMachFloat32), check, p1, p0); |
| 256 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat32Max); |
| 257 ASSERT_TRUE(r.Changed()); |
| 258 EXPECT_THAT(r.replacement(), IsFloat32Max(p1, p0)); |
| 259 } |
| 260 |
| 261 |
| 262 TEST_F(CommonOperatorReducerTest, SelectToFloat64Max) { |
150 Node* p0 = Parameter(0); | 263 Node* p0 = Parameter(0); |
151 Node* p1 = Parameter(1); | 264 Node* p1 = Parameter(1); |
152 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1); | 265 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1); |
153 Reduction r1 = | 266 Node* select = |
154 Reduce(graph()->NewNode(common()->Select(kMachFloat64), check, p1, p0), | 267 graph()->NewNode(common()->Select(kMachFloat64), check, p1, p0); |
155 MachineOperatorBuilder::kFloat64Max); | 268 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat64Max); |
156 ASSERT_TRUE(r1.Changed()); | 269 ASSERT_TRUE(r.Changed()); |
157 EXPECT_THAT(r1.replacement(), IsFloat64Max(p1, p0)); | 270 EXPECT_THAT(r.replacement(), IsFloat64Max(p1, p0)); |
158 Reduction r2 = | 271 } |
159 Reduce(graph()->NewNode(common()->Select(kMachFloat64), check, p0, p1), | 272 |
160 MachineOperatorBuilder::kFloat64Min); | 273 |
161 ASSERT_TRUE(r2.Changed()); | 274 TEST_F(CommonOperatorReducerTest, SelectToFloat32Min) { |
162 EXPECT_THAT(r2.replacement(), IsFloat64Min(p0, p1)); | 275 Node* p0 = Parameter(0); |
| 276 Node* p1 = Parameter(1); |
| 277 Node* check = graph()->NewNode(machine()->Float32LessThan(), p0, p1); |
| 278 Node* select = |
| 279 graph()->NewNode(common()->Select(kMachFloat32), check, p0, p1); |
| 280 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat32Min); |
| 281 ASSERT_TRUE(r.Changed()); |
| 282 EXPECT_THAT(r.replacement(), IsFloat32Min(p0, p1)); |
| 283 } |
| 284 |
| 285 |
| 286 TEST_F(CommonOperatorReducerTest, SelectToFloat64Min) { |
| 287 Node* p0 = Parameter(0); |
| 288 Node* p1 = Parameter(1); |
| 289 Node* check = graph()->NewNode(machine()->Float64LessThan(), p0, p1); |
| 290 Node* select = |
| 291 graph()->NewNode(common()->Select(kMachFloat64), check, p0, p1); |
| 292 Reduction r = Reduce(select, MachineOperatorBuilder::kFloat64Min); |
| 293 ASSERT_TRUE(r.Changed()); |
| 294 EXPECT_THAT(r.replacement(), IsFloat64Min(p0, p1)); |
163 } | 295 } |
164 | 296 |
165 } // namespace compiler | 297 } // namespace compiler |
166 } // namespace internal | 298 } // namespace internal |
167 } // namespace v8 | 299 } // namespace v8 |
OLD | NEW |