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 <algorithm> | 5 #include <algorithm> |
6 | 6 |
7 #include "src/base/adapters.h" | 7 #include "src/base/adapters.h" |
8 #include "src/compiler/instruction-selector-impl.h" | 8 #include "src/compiler/instruction-selector-impl.h" |
9 #include "src/compiler/node-matchers.h" | 9 #include "src/compiler/node-matchers.h" |
10 #include "src/compiler/node-properties.h" | 10 #include "src/compiler/node-properties.h" |
(...skipping 812 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
823 | 823 |
824 void InstructionSelector::VisitWord32Ror(Node* node) { | 824 void InstructionSelector::VisitWord32Ror(Node* node) { |
825 VisitWord32Shift(this, node, kX64Ror32); | 825 VisitWord32Shift(this, node, kX64Ror32); |
826 } | 826 } |
827 | 827 |
828 | 828 |
829 void InstructionSelector::VisitWord64Ror(Node* node) { | 829 void InstructionSelector::VisitWord64Ror(Node* node) { |
830 VisitWord64Shift(this, node, kX64Ror); | 830 VisitWord64Shift(this, node, kX64Ror); |
831 } | 831 } |
832 | 832 |
833 | |
834 void InstructionSelector::VisitWord64Clz(Node* node) { | |
835 X64OperandGenerator g(this); | |
836 Emit(kX64Lzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
837 } | |
838 | |
839 | |
840 void InstructionSelector::VisitWord32Clz(Node* node) { | |
841 X64OperandGenerator g(this); | |
842 Emit(kX64Lzcnt32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
843 } | |
844 | |
845 | |
846 void InstructionSelector::VisitWord64Ctz(Node* node) { | |
847 X64OperandGenerator g(this); | |
848 Emit(kX64Tzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
849 } | |
850 | |
851 | |
852 void InstructionSelector::VisitWord32Ctz(Node* node) { | |
853 X64OperandGenerator g(this); | |
854 Emit(kX64Tzcnt32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
855 } | |
856 | |
857 | |
858 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); } | 833 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); } |
859 | 834 |
860 | 835 |
861 void InstructionSelector::VisitWord64ReverseBits(Node* node) { UNREACHABLE(); } | 836 void InstructionSelector::VisitWord64ReverseBits(Node* node) { UNREACHABLE(); } |
862 | 837 |
863 void InstructionSelector::VisitWord64ReverseBytes(Node* node) { UNREACHABLE(); } | 838 void InstructionSelector::VisitWord64ReverseBytes(Node* node) { UNREACHABLE(); } |
864 | 839 |
865 void InstructionSelector::VisitWord32ReverseBytes(Node* node) { UNREACHABLE(); } | 840 void InstructionSelector::VisitWord32ReverseBytes(Node* node) { UNREACHABLE(); } |
866 | 841 |
867 void InstructionSelector::VisitWord32Popcnt(Node* node) { | |
868 X64OperandGenerator g(this); | |
869 Emit(kX64Popcnt32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
870 } | |
871 | |
872 | |
873 void InstructionSelector::VisitWord64Popcnt(Node* node) { | |
874 X64OperandGenerator g(this); | |
875 Emit(kX64Popcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
876 } | |
877 | |
878 | |
879 void InstructionSelector::VisitInt32Add(Node* node) { | 842 void InstructionSelector::VisitInt32Add(Node* node) { |
880 X64OperandGenerator g(this); | 843 X64OperandGenerator g(this); |
881 | 844 |
882 // Try to match the Add to a leal pattern | 845 // Try to match the Add to a leal pattern |
883 BaseWithIndexAndDisplacement32Matcher m(node); | 846 BaseWithIndexAndDisplacement32Matcher m(node); |
884 if (m.matches() && | 847 if (m.matches() && |
885 (m.displacement() == nullptr || g.CanBeImmediate(m.displacement()))) { | 848 (m.displacement() == nullptr || g.CanBeImmediate(m.displacement()))) { |
886 EmitLea(this, kX64Lea32, node, m.index(), m.scale(), m.base(), | 849 EmitLea(this, kX64Lea32, node, m.index(), m.scale(), m.base(), |
887 m.displacement(), m.displacement_mode()); | 850 m.displacement(), m.displacement_mode()); |
888 return; | 851 return; |
(...skipping 202 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1091 | 1054 |
1092 void InstructionSelector::VisitUint64Mod(Node* node) { | 1055 void InstructionSelector::VisitUint64Mod(Node* node) { |
1093 VisitMod(this, node, kX64Udiv); | 1056 VisitMod(this, node, kX64Udiv); |
1094 } | 1057 } |
1095 | 1058 |
1096 | 1059 |
1097 void InstructionSelector::VisitUint32MulHigh(Node* node) { | 1060 void InstructionSelector::VisitUint32MulHigh(Node* node) { |
1098 VisitMulHigh(this, node, kX64UmulHigh32); | 1061 VisitMulHigh(this, node, kX64UmulHigh32); |
1099 } | 1062 } |
1100 | 1063 |
1101 | |
1102 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) { | |
1103 X64OperandGenerator g(this); | |
1104 Emit(kSSEFloat32ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1105 } | |
1106 | |
1107 | |
1108 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) { | |
1109 X64OperandGenerator g(this); | |
1110 Emit(kSSEInt32ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1111 } | |
1112 | |
1113 | |
1114 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) { | |
1115 X64OperandGenerator g(this); | |
1116 Emit(kSSEUint32ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1117 } | |
1118 | |
1119 | |
1120 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) { | |
1121 X64OperandGenerator g(this); | |
1122 Emit(kSSEFloat64ToInt32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1123 } | |
1124 | |
1125 | |
1126 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) { | |
1127 X64OperandGenerator g(this); | |
1128 Emit(kSSEFloat64ToUint32 | MiscField::encode(1), g.DefineAsRegister(node), | |
1129 g.Use(node->InputAt(0))); | |
1130 } | |
1131 | |
1132 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) { | |
1133 X64OperandGenerator g(this); | |
1134 Emit(kSSEFloat64ToUint32 | MiscField::encode(0), g.DefineAsRegister(node), | |
1135 g.Use(node->InputAt(0))); | |
1136 } | |
1137 | |
1138 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) { | |
1139 X64OperandGenerator g(this); | |
1140 Emit(kSSEFloat32ToInt32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1141 } | |
1142 | |
1143 | |
1144 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) { | |
1145 X64OperandGenerator g(this); | |
1146 Emit(kSSEFloat32ToUint32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1147 } | |
1148 | |
1149 | |
1150 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) { | 1064 void InstructionSelector::VisitTryTruncateFloat32ToInt64(Node* node) { |
1151 X64OperandGenerator g(this); | 1065 X64OperandGenerator g(this); |
1152 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))}; | 1066 InstructionOperand inputs[] = {g.UseRegister(node->InputAt(0))}; |
1153 InstructionOperand outputs[2]; | 1067 InstructionOperand outputs[2]; |
1154 size_t output_count = 0; | 1068 size_t output_count = 0; |
1155 outputs[output_count++] = g.DefineAsRegister(node); | 1069 outputs[output_count++] = g.DefineAsRegister(node); |
1156 | 1070 |
1157 Node* success_output = NodeProperties::FindProjection(node, 1); | 1071 Node* success_output = NodeProperties::FindProjection(node, 1); |
1158 if (success_output) { | 1072 if (success_output) { |
1159 outputs[output_count++] = g.DefineAsRegister(success_output); | 1073 outputs[output_count++] = g.DefineAsRegister(success_output); |
(...skipping 197 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1357 X64OperandGenerator g(selector); | 1271 X64OperandGenerator g(selector); |
1358 if (selector->IsSupported(AVX)) { | 1272 if (selector->IsSupported(AVX)) { |
1359 selector->Emit(avx_opcode, g.DefineAsRegister(node), g.Use(input)); | 1273 selector->Emit(avx_opcode, g.DefineAsRegister(node), g.Use(input)); |
1360 } else { | 1274 } else { |
1361 selector->Emit(sse_opcode, g.DefineSameAsFirst(node), g.UseRegister(input)); | 1275 selector->Emit(sse_opcode, g.DefineSameAsFirst(node), g.UseRegister(input)); |
1362 } | 1276 } |
1363 } | 1277 } |
1364 | 1278 |
1365 } // namespace | 1279 } // namespace |
1366 | 1280 |
| 1281 #define RO_OP_LIST(V) \ |
| 1282 V(Word64Clz, kX64Lzcnt) \ |
| 1283 V(Word32Clz, kX64Lzcnt32) \ |
| 1284 V(Word64Ctz, kX64Tzcnt) \ |
| 1285 V(Word32Ctz, kX64Tzcnt32) \ |
| 1286 V(Word64Popcnt, kX64Popcnt) \ |
| 1287 V(Word32Popcnt, kX64Popcnt32) \ |
| 1288 V(Float64Sqrt, kSSEFloat64Sqrt) \ |
| 1289 V(Float32Sqrt, kSSEFloat32Sqrt) \ |
| 1290 V(ChangeFloat64ToInt32, kSSEFloat64ToInt32) \ |
| 1291 V(ChangeFloat64ToUint32, kSSEFloat64ToUint32 | MiscField::encode(1)) \ |
| 1292 V(TruncateFloat64ToUint32, kSSEFloat64ToUint32 | MiscField::encode(0)) \ |
| 1293 V(TruncateFloat64ToFloat32, kSSEFloat64ToFloat32) \ |
| 1294 V(ChangeFloat32ToFloat64, kSSEFloat32ToFloat64) \ |
| 1295 V(TruncateFloat32ToInt32, kSSEFloat32ToInt32) \ |
| 1296 V(TruncateFloat32ToUint32, kSSEFloat32ToUint32) \ |
| 1297 V(ChangeInt32ToFloat64, kSSEInt32ToFloat64) \ |
| 1298 V(ChangeUint32ToFloat64, kSSEUint32ToFloat64) \ |
| 1299 V(RoundFloat64ToInt32, kSSEFloat64ToInt32) \ |
| 1300 V(RoundInt32ToFloat32, kSSEInt32ToFloat32) \ |
| 1301 V(RoundInt64ToFloat32, kSSEInt64ToFloat32) \ |
| 1302 V(RoundInt64ToFloat64, kSSEInt64ToFloat64) \ |
| 1303 V(RoundUint32ToFloat32, kSSEUint32ToFloat32) \ |
| 1304 V(BitcastFloat32ToInt32, kX64BitcastFI) \ |
| 1305 V(BitcastFloat64ToInt64, kX64BitcastDL) \ |
| 1306 V(BitcastInt32ToFloat32, kX64BitcastIF) \ |
| 1307 V(BitcastInt64ToFloat64, kX64BitcastLD) \ |
| 1308 V(Float64ExtractLowWord32, kSSEFloat64ExtractLowWord32) \ |
| 1309 V(Float64ExtractHighWord32, kSSEFloat64ExtractHighWord32) |
1367 | 1310 |
1368 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) { | 1311 #define RR_OP_LIST(V) \ |
1369 VisitRO(this, node, kSSEFloat64ToFloat32); | 1312 V(Float32RoundDown, kSSEFloat32Round | MiscField::encode(kRoundDown)) \ |
1370 } | 1313 V(Float64RoundDown, kSSEFloat64Round | MiscField::encode(kRoundDown)) \ |
| 1314 V(Float32RoundUp, kSSEFloat32Round | MiscField::encode(kRoundUp)) \ |
| 1315 V(Float64RoundUp, kSSEFloat64Round | MiscField::encode(kRoundUp)) \ |
| 1316 V(Float32RoundTruncate, kSSEFloat32Round | MiscField::encode(kRoundToZero)) \ |
| 1317 V(Float64RoundTruncate, kSSEFloat64Round | MiscField::encode(kRoundToZero)) \ |
| 1318 V(Float32RoundTiesEven, \ |
| 1319 kSSEFloat32Round | MiscField::encode(kRoundToNearest)) \ |
| 1320 V(Float64RoundTiesEven, kSSEFloat64Round | MiscField::encode(kRoundToNearest)) |
| 1321 |
| 1322 #define RO_VISITOR(Name, opcode) \ |
| 1323 void InstructionSelector::Visit##Name(Node* node) { \ |
| 1324 VisitRO(this, node, opcode); \ |
| 1325 } |
| 1326 RO_OP_LIST(RO_VISITOR) |
| 1327 #undef RO_VISITOR |
| 1328 |
| 1329 #define RR_VISITOR(Name, opcode) \ |
| 1330 void InstructionSelector::Visit##Name(Node* node) { \ |
| 1331 VisitRR(this, node, opcode); \ |
| 1332 } |
| 1333 RR_OP_LIST(RR_VISITOR) |
| 1334 #undef RR_VISITOR |
1371 | 1335 |
1372 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) { | 1336 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) { |
1373 VisitRR(this, node, kArchTruncateDoubleToI); | 1337 VisitRR(this, node, kArchTruncateDoubleToI); |
1374 } | 1338 } |
1375 | 1339 |
1376 | |
1377 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) { | 1340 void InstructionSelector::VisitTruncateInt64ToInt32(Node* node) { |
1378 X64OperandGenerator g(this); | 1341 X64OperandGenerator g(this); |
1379 Node* value = node->InputAt(0); | 1342 Node* value = node->InputAt(0); |
1380 if (CanCover(node, value)) { | 1343 if (CanCover(node, value)) { |
1381 switch (value->opcode()) { | 1344 switch (value->opcode()) { |
1382 case IrOpcode::kWord64Sar: | 1345 case IrOpcode::kWord64Sar: |
1383 case IrOpcode::kWord64Shr: { | 1346 case IrOpcode::kWord64Shr: { |
1384 Int64BinopMatcher m(value); | 1347 Int64BinopMatcher m(value); |
1385 if (m.right().Is(32)) { | 1348 if (m.right().Is(32)) { |
1386 if (TryMatchLoadWord64AndShiftRight(this, value, kX64Movl)) { | 1349 if (TryMatchLoadWord64AndShiftRight(this, value, kX64Movl)) { |
1387 return EmitIdentity(node); | 1350 return EmitIdentity(node); |
1388 } | 1351 } |
1389 Emit(kX64Shr, g.DefineSameAsFirst(node), | 1352 Emit(kX64Shr, g.DefineSameAsFirst(node), |
1390 g.UseRegister(m.left().node()), g.TempImmediate(32)); | 1353 g.UseRegister(m.left().node()), g.TempImmediate(32)); |
1391 return; | 1354 return; |
1392 } | 1355 } |
1393 break; | 1356 break; |
1394 } | 1357 } |
1395 default: | 1358 default: |
1396 break; | 1359 break; |
1397 } | 1360 } |
1398 } | 1361 } |
1399 Emit(kX64Movl, g.DefineAsRegister(node), g.Use(value)); | 1362 Emit(kX64Movl, g.DefineAsRegister(node), g.Use(value)); |
1400 } | 1363 } |
1401 | 1364 |
1402 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) { | |
1403 VisitRO(this, node, kSSEFloat64ToInt32); | |
1404 } | |
1405 | |
1406 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) { | |
1407 X64OperandGenerator g(this); | |
1408 Emit(kSSEInt32ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1409 } | |
1410 | |
1411 | |
1412 void InstructionSelector::VisitRoundInt64ToFloat32(Node* node) { | |
1413 X64OperandGenerator g(this); | |
1414 Emit(kSSEInt64ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1415 } | |
1416 | |
1417 | |
1418 void InstructionSelector::VisitRoundInt64ToFloat64(Node* node) { | |
1419 X64OperandGenerator g(this); | |
1420 Emit(kSSEInt64ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1421 } | |
1422 | |
1423 | |
1424 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) { | |
1425 X64OperandGenerator g(this); | |
1426 Emit(kSSEUint32ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1427 } | |
1428 | |
1429 | |
1430 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) { | 1365 void InstructionSelector::VisitRoundUint64ToFloat32(Node* node) { |
1431 X64OperandGenerator g(this); | 1366 X64OperandGenerator g(this); |
1432 InstructionOperand temps[] = {g.TempRegister()}; | 1367 InstructionOperand temps[] = {g.TempRegister()}; |
1433 Emit(kSSEUint64ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0)), | 1368 Emit(kSSEUint64ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0)), |
1434 arraysize(temps), temps); | 1369 arraysize(temps), temps); |
1435 } | 1370 } |
1436 | 1371 |
1437 | 1372 |
1438 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) { | 1373 void InstructionSelector::VisitRoundUint64ToFloat64(Node* node) { |
1439 X64OperandGenerator g(this); | 1374 X64OperandGenerator g(this); |
1440 InstructionOperand temps[] = {g.TempRegister()}; | 1375 InstructionOperand temps[] = {g.TempRegister()}; |
1441 Emit(kSSEUint64ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0)), | 1376 Emit(kSSEUint64ToFloat64, g.DefineAsRegister(node), g.Use(node->InputAt(0)), |
1442 arraysize(temps), temps); | 1377 arraysize(temps), temps); |
1443 } | 1378 } |
1444 | 1379 |
1445 | |
1446 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) { | |
1447 X64OperandGenerator g(this); | |
1448 Emit(kX64BitcastFI, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1449 } | |
1450 | |
1451 | |
1452 void InstructionSelector::VisitBitcastFloat64ToInt64(Node* node) { | |
1453 X64OperandGenerator g(this); | |
1454 Emit(kX64BitcastDL, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1455 } | |
1456 | |
1457 | |
1458 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) { | |
1459 X64OperandGenerator g(this); | |
1460 Emit(kX64BitcastIF, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1461 } | |
1462 | |
1463 | |
1464 void InstructionSelector::VisitBitcastInt64ToFloat64(Node* node) { | |
1465 X64OperandGenerator g(this); | |
1466 Emit(kX64BitcastLD, g.DefineAsRegister(node), g.Use(node->InputAt(0))); | |
1467 } | |
1468 | |
1469 | |
1470 void InstructionSelector::VisitFloat32Add(Node* node) { | 1380 void InstructionSelector::VisitFloat32Add(Node* node) { |
1471 VisitFloatBinop(this, node, kAVXFloat32Add, kSSEFloat32Add); | 1381 VisitFloatBinop(this, node, kAVXFloat32Add, kSSEFloat32Add); |
1472 } | 1382 } |
1473 | 1383 |
1474 | 1384 |
1475 void InstructionSelector::VisitFloat32Sub(Node* node) { | 1385 void InstructionSelector::VisitFloat32Sub(Node* node) { |
1476 VisitFloatBinop(this, node, kAVXFloat32Sub, kSSEFloat32Sub); | 1386 VisitFloatBinop(this, node, kAVXFloat32Sub, kSSEFloat32Sub); |
1477 } | 1387 } |
1478 | 1388 |
1479 void InstructionSelector::VisitFloat32Mul(Node* node) { | 1389 void InstructionSelector::VisitFloat32Mul(Node* node) { |
1480 VisitFloatBinop(this, node, kAVXFloat32Mul, kSSEFloat32Mul); | 1390 VisitFloatBinop(this, node, kAVXFloat32Mul, kSSEFloat32Mul); |
1481 } | 1391 } |
1482 | 1392 |
1483 | 1393 |
1484 void InstructionSelector::VisitFloat32Div(Node* node) { | 1394 void InstructionSelector::VisitFloat32Div(Node* node) { |
1485 VisitFloatBinop(this, node, kAVXFloat32Div, kSSEFloat32Div); | 1395 VisitFloatBinop(this, node, kAVXFloat32Div, kSSEFloat32Div); |
1486 } | 1396 } |
1487 | 1397 |
1488 | 1398 |
1489 void InstructionSelector::VisitFloat32Abs(Node* node) { | 1399 void InstructionSelector::VisitFloat32Abs(Node* node) { |
1490 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Abs, kSSEFloat32Abs); | 1400 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Abs, kSSEFloat32Abs); |
1491 } | 1401 } |
1492 | 1402 |
1493 | 1403 |
1494 void InstructionSelector::VisitFloat32Sqrt(Node* node) { | |
1495 VisitRO(this, node, kSSEFloat32Sqrt); | |
1496 } | |
1497 | |
1498 void InstructionSelector::VisitFloat32Max(Node* node) { | 1404 void InstructionSelector::VisitFloat32Max(Node* node) { |
1499 VisitRRO(this, node, kSSEFloat32Max); | 1405 VisitRRO(this, node, kSSEFloat32Max); |
1500 } | 1406 } |
1501 | 1407 |
1502 void InstructionSelector::VisitFloat32Min(Node* node) { | 1408 void InstructionSelector::VisitFloat32Min(Node* node) { |
1503 VisitRRO(this, node, kSSEFloat32Min); | 1409 VisitRRO(this, node, kSSEFloat32Min); |
1504 } | 1410 } |
1505 | 1411 |
1506 void InstructionSelector::VisitFloat64Add(Node* node) { | 1412 void InstructionSelector::VisitFloat64Add(Node* node) { |
1507 VisitFloatBinop(this, node, kAVXFloat64Add, kSSEFloat64Add); | 1413 VisitFloatBinop(this, node, kAVXFloat64Add, kSSEFloat64Add); |
(...skipping 30 matching lines...) Expand all Loading... |
1538 | 1444 |
1539 void InstructionSelector::VisitFloat64Min(Node* node) { | 1445 void InstructionSelector::VisitFloat64Min(Node* node) { |
1540 VisitRRO(this, node, kSSEFloat64Min); | 1446 VisitRRO(this, node, kSSEFloat64Min); |
1541 } | 1447 } |
1542 | 1448 |
1543 | 1449 |
1544 void InstructionSelector::VisitFloat64Abs(Node* node) { | 1450 void InstructionSelector::VisitFloat64Abs(Node* node) { |
1545 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Abs, kSSEFloat64Abs); | 1451 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Abs, kSSEFloat64Abs); |
1546 } | 1452 } |
1547 | 1453 |
1548 void InstructionSelector::VisitFloat64Sqrt(Node* node) { | |
1549 VisitRO(this, node, kSSEFloat64Sqrt); | |
1550 } | |
1551 | |
1552 | |
1553 void InstructionSelector::VisitFloat32RoundDown(Node* node) { | |
1554 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundDown)); | |
1555 } | |
1556 | |
1557 | |
1558 void InstructionSelector::VisitFloat64RoundDown(Node* node) { | |
1559 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundDown)); | |
1560 } | |
1561 | |
1562 | |
1563 void InstructionSelector::VisitFloat32RoundUp(Node* node) { | |
1564 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundUp)); | |
1565 } | |
1566 | |
1567 | |
1568 void InstructionSelector::VisitFloat64RoundUp(Node* node) { | |
1569 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundUp)); | |
1570 } | |
1571 | |
1572 | |
1573 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) { | |
1574 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToZero)); | |
1575 } | |
1576 | |
1577 | |
1578 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) { | |
1579 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToZero)); | |
1580 } | |
1581 | |
1582 | 1454 |
1583 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) { | 1455 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) { |
1584 UNREACHABLE(); | 1456 UNREACHABLE(); |
1585 } | 1457 } |
1586 | 1458 |
1587 | 1459 |
1588 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) { | |
1589 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToNearest)); | |
1590 } | |
1591 | |
1592 | |
1593 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) { | |
1594 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToNearest)); | |
1595 } | |
1596 | |
1597 void InstructionSelector::VisitFloat32Neg(Node* node) { | 1460 void InstructionSelector::VisitFloat32Neg(Node* node) { |
1598 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Neg, kSSEFloat32Neg); | 1461 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Neg, kSSEFloat32Neg); |
1599 } | 1462 } |
1600 | 1463 |
1601 void InstructionSelector::VisitFloat64Neg(Node* node) { | 1464 void InstructionSelector::VisitFloat64Neg(Node* node) { |
1602 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Neg, kSSEFloat64Neg); | 1465 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Neg, kSSEFloat64Neg); |
1603 } | 1466 } |
1604 | 1467 |
1605 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node, | 1468 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node, |
1606 InstructionCode opcode) { | 1469 InstructionCode opcode) { |
(...skipping 719 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2326 FlagsContinuation::ForSet(kUnsignedGreaterThan, node); | 2189 FlagsContinuation::ForSet(kUnsignedGreaterThan, node); |
2327 VisitFloat64Compare(this, node, &cont); | 2190 VisitFloat64Compare(this, node, &cont); |
2328 } | 2191 } |
2329 | 2192 |
2330 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) { | 2193 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) { |
2331 FlagsContinuation cont = | 2194 FlagsContinuation cont = |
2332 FlagsContinuation::ForSet(kUnsignedGreaterThanOrEqual, node); | 2195 FlagsContinuation::ForSet(kUnsignedGreaterThanOrEqual, node); |
2333 VisitFloat64Compare(this, node, &cont); | 2196 VisitFloat64Compare(this, node, &cont); |
2334 } | 2197 } |
2335 | 2198 |
2336 | |
2337 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) { | |
2338 X64OperandGenerator g(this); | |
2339 Emit(kSSEFloat64ExtractLowWord32, g.DefineAsRegister(node), | |
2340 g.Use(node->InputAt(0))); | |
2341 } | |
2342 | |
2343 | |
2344 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) { | |
2345 X64OperandGenerator g(this); | |
2346 Emit(kSSEFloat64ExtractHighWord32, g.DefineAsRegister(node), | |
2347 g.Use(node->InputAt(0))); | |
2348 } | |
2349 | |
2350 | |
2351 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) { | 2199 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) { |
2352 X64OperandGenerator g(this); | 2200 X64OperandGenerator g(this); |
2353 Node* left = node->InputAt(0); | 2201 Node* left = node->InputAt(0); |
2354 Node* right = node->InputAt(1); | 2202 Node* right = node->InputAt(1); |
2355 Float64Matcher mleft(left); | 2203 Float64Matcher mleft(left); |
2356 if (mleft.HasValue() && (bit_cast<uint64_t>(mleft.Value()) >> 32) == 0u) { | 2204 if (mleft.HasValue() && (bit_cast<uint64_t>(mleft.Value()) >> 32) == 0u) { |
2357 Emit(kSSEFloat64LoadLowWord32, g.DefineAsRegister(node), g.Use(right)); | 2205 Emit(kSSEFloat64LoadLowWord32, g.DefineAsRegister(node), g.Use(right)); |
2358 return; | 2206 return; |
2359 } | 2207 } |
2360 Emit(kSSEFloat64InsertLowWord32, g.DefineSameAsFirst(node), | 2208 Emit(kSSEFloat64InsertLowWord32, g.DefineSameAsFirst(node), |
(...skipping 120 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2481 // static | 2329 // static |
2482 MachineOperatorBuilder::AlignmentRequirements | 2330 MachineOperatorBuilder::AlignmentRequirements |
2483 InstructionSelector::AlignmentRequirements() { | 2331 InstructionSelector::AlignmentRequirements() { |
2484 return MachineOperatorBuilder::AlignmentRequirements:: | 2332 return MachineOperatorBuilder::AlignmentRequirements:: |
2485 FullUnalignedAccessSupport(); | 2333 FullUnalignedAccessSupport(); |
2486 } | 2334 } |
2487 | 2335 |
2488 } // namespace compiler | 2336 } // namespace compiler |
2489 } // namespace internal | 2337 } // namespace internal |
2490 } // namespace v8 | 2338 } // namespace v8 |
OLD | NEW |