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/base/adapters.h" | 5 #include "src/base/adapters.h" |
6 #include "src/compiler/instruction-selector-impl.h" | 6 #include "src/compiler/instruction-selector-impl.h" |
7 #include "src/compiler/node-matchers.h" | 7 #include "src/compiler/node-matchers.h" |
8 #include "src/compiler/node-properties.h" | 8 #include "src/compiler/node-properties.h" |
9 | 9 |
10 namespace v8 { | 10 namespace v8 { |
(...skipping 753 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
764 } | 764 } |
765 | 765 |
766 void InstructionSelector::VisitWord32PairSar(Node* node) { | 766 void InstructionSelector::VisitWord32PairSar(Node* node) { |
767 VisitWord32PairShift(this, kIA32SarPair, node); | 767 VisitWord32PairShift(this, kIA32SarPair, node); |
768 } | 768 } |
769 | 769 |
770 void InstructionSelector::VisitWord32Ror(Node* node) { | 770 void InstructionSelector::VisitWord32Ror(Node* node) { |
771 VisitShift(this, node, kIA32Ror); | 771 VisitShift(this, node, kIA32Ror); |
772 } | 772 } |
773 | 773 |
774 #define RO_OP_LIST(V) \ | |
775 V(Word32Clz, kIA32Lzcnt) \ | |
776 V(Word32Ctz, kIA32Tzcnt) \ | |
777 V(Word32Popcnt, kIA32Popcnt) \ | |
778 V(ChangeFloat32ToFloat64, kSSEFloat32ToFloat64) \ | |
779 V(RoundInt32ToFloat32, kSSEInt32ToFloat32) \ | |
780 V(ChangeInt32ToFloat64, kSSEInt32ToFloat64) \ | |
781 V(ChangeUint32ToFloat64, kSSEUint32ToFloat64) \ | |
782 V(TruncateFloat32ToInt32, kSSEFloat32ToInt32) \ | |
783 V(TruncateFloat32ToUint32, kSSEFloat32ToUint32) \ | |
784 V(ChangeFloat64ToInt32, kSSEFloat64ToInt32) \ | |
785 V(ChangeFloat64ToUint32, kSSEFloat64ToUint32) \ | |
786 V(TruncateFloat64ToUint32, kSSEFloat64ToUint32) \ | |
787 V(TruncateFloat64ToFloat32, kSSEFloat64ToFloat32) \ | |
788 V(RoundFloat64ToInt32, kSSEFloat64ToInt32) \ | |
789 V(BitcastFloat32ToInt32, kIA32BitcastFI) \ | |
790 V(BitcastInt32ToFloat32, kIA32BitcastIF) \ | |
791 V(Float32Sqrt, kSSEFloat32Sqrt) \ | |
792 V(Float64Sqrt, kSSEFloat64Sqrt) \ | |
793 V(Float64ExtractLowWord32, kSSEFloat64ExtractLowWord32) \ | |
794 V(Float64ExtractHighWord32, kSSEFloat64ExtractHighWord32) | |
795 | 774 |
796 #define RR_OP_LIST(V) \ | 775 void InstructionSelector::VisitWord32Clz(Node* node) { |
797 V(TruncateFloat64ToWord32, kArchTruncateDoubleToI) \ | 776 IA32OperandGenerator g(this); |
798 V(Float32RoundDown, kSSEFloat32Round | MiscField::encode(kRoundDown)) \ | 777 Emit(kIA32Lzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0))); |
799 V(Float64RoundDown, kSSEFloat64Round | MiscField::encode(kRoundDown)) \ | 778 } |
800 V(Float32RoundUp, kSSEFloat32Round | MiscField::encode(kRoundUp)) \ | |
801 V(Float64RoundUp, kSSEFloat64Round | MiscField::encode(kRoundUp)) \ | |
802 V(Float32RoundTruncate, kSSEFloat32Round | MiscField::encode(kRoundToZero)) \ | |
803 V(Float64RoundTruncate, kSSEFloat64Round | MiscField::encode(kRoundToZero)) \ | |
804 V(Float32RoundTiesEven, \ | |
805 kSSEFloat32Round | MiscField::encode(kRoundToNearest)) \ | |
806 V(Float64RoundTiesEven, kSSEFloat64Round | MiscField::encode(kRoundToNearest)) | |
807 | 779 |
808 #define RRO_FLOAT_OP_LIST(V) \ | |
809 V(Float32Add, kAVXFloat32Add, kSSEFloat32Add) \ | |
810 V(Float64Add, kAVXFloat64Add, kSSEFloat64Add) \ | |
811 V(Float32Sub, kAVXFloat32Sub, kSSEFloat32Sub) \ | |
812 V(Float64Sub, kAVXFloat64Sub, kSSEFloat64Sub) \ | |
813 V(Float32Mul, kAVXFloat32Mul, kSSEFloat32Mul) \ | |
814 V(Float64Mul, kAVXFloat64Mul, kSSEFloat64Mul) \ | |
815 V(Float32Div, kAVXFloat32Div, kSSEFloat32Div) \ | |
816 V(Float64Div, kAVXFloat64Div, kSSEFloat64Div) | |
817 | 780 |
818 #define FLOAT_UNOP_LIST(V) \ | 781 void InstructionSelector::VisitWord32Ctz(Node* node) { |
819 V(Float32Abs, kAVXFloat32Abs, kSSEFloat32Abs) \ | 782 IA32OperandGenerator g(this); |
820 V(Float64Abs, kAVXFloat64Abs, kSSEFloat64Abs) \ | 783 Emit(kIA32Tzcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0))); |
821 V(Float32Neg, kAVXFloat32Neg, kSSEFloat32Neg) \ | 784 } |
822 V(Float64Neg, kAVXFloat64Neg, kSSEFloat64Neg) | |
823 | 785 |
824 #define RO_VISITOR(Name, opcode) \ | |
825 void InstructionSelector::Visit##Name(Node* node) { \ | |
826 VisitRO(this, node, opcode); \ | |
827 } | |
828 RO_OP_LIST(RO_VISITOR) | |
829 #undef RO_VISITOR | |
830 | |
831 #define RR_VISITOR(Name, opcode) \ | |
832 void InstructionSelector::Visit##Name(Node* node) { \ | |
833 VisitRR(this, node, opcode); \ | |
834 } | |
835 RR_OP_LIST(RR_VISITOR) | |
836 #undef RR_VISITOR | |
837 | |
838 #define RRO_FLOAT_VISITOR(Name, avx, sse) \ | |
839 void InstructionSelector::Visit##Name(Node* node) { \ | |
840 VisitRROFloat(this, node, avx, sse); \ | |
841 } | |
842 RRO_FLOAT_OP_LIST(RRO_FLOAT_VISITOR) | |
843 #undef RRO_FLOAT_VISITOR | |
844 | |
845 #define FLOAT_UNOP_VISITOR(Name, avx, sse) \ | |
846 void InstructionSelector::Visit##Name(Node* node) { \ | |
847 VisitFloatUnop(this, node, node->InputAt(0), avx, sse); \ | |
848 } | |
849 FLOAT_UNOP_LIST(FLOAT_UNOP_VISITOR) | |
850 #undef FLOAT_UNOP_VISITOR | |
851 | 786 |
852 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); } | 787 void InstructionSelector::VisitWord32ReverseBits(Node* node) { UNREACHABLE(); } |
853 | 788 |
854 void InstructionSelector::VisitWord64ReverseBytes(Node* node) { UNREACHABLE(); } | 789 void InstructionSelector::VisitWord64ReverseBytes(Node* node) { UNREACHABLE(); } |
855 | 790 |
856 void InstructionSelector::VisitWord32ReverseBytes(Node* node) { UNREACHABLE(); } | 791 void InstructionSelector::VisitWord32ReverseBytes(Node* node) { UNREACHABLE(); } |
857 | 792 |
| 793 void InstructionSelector::VisitWord32Popcnt(Node* node) { |
| 794 IA32OperandGenerator g(this); |
| 795 Emit(kIA32Popcnt, g.DefineAsRegister(node), g.Use(node->InputAt(0))); |
| 796 } |
| 797 |
| 798 |
858 void InstructionSelector::VisitInt32Add(Node* node) { | 799 void InstructionSelector::VisitInt32Add(Node* node) { |
859 IA32OperandGenerator g(this); | 800 IA32OperandGenerator g(this); |
860 | 801 |
861 // Try to match the Add to a lea pattern | 802 // Try to match the Add to a lea pattern |
862 BaseWithIndexAndDisplacement32Matcher m(node); | 803 BaseWithIndexAndDisplacement32Matcher m(node); |
863 if (m.matches() && | 804 if (m.matches() && |
864 (m.displacement() == nullptr || g.CanBeImmediate(m.displacement()))) { | 805 (m.displacement() == nullptr || g.CanBeImmediate(m.displacement()))) { |
865 InstructionOperand inputs[4]; | 806 InstructionOperand inputs[4]; |
866 size_t input_count = 0; | 807 size_t input_count = 0; |
867 AddressingMode mode = g.GenerateMemoryOperandInputs( | 808 AddressingMode mode = g.GenerateMemoryOperandInputs( |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
942 void InstructionSelector::VisitInt32Mod(Node* node) { | 883 void InstructionSelector::VisitInt32Mod(Node* node) { |
943 VisitMod(this, node, kIA32Idiv); | 884 VisitMod(this, node, kIA32Idiv); |
944 } | 885 } |
945 | 886 |
946 | 887 |
947 void InstructionSelector::VisitUint32Mod(Node* node) { | 888 void InstructionSelector::VisitUint32Mod(Node* node) { |
948 VisitMod(this, node, kIA32Udiv); | 889 VisitMod(this, node, kIA32Udiv); |
949 } | 890 } |
950 | 891 |
951 | 892 |
| 893 void InstructionSelector::VisitChangeFloat32ToFloat64(Node* node) { |
| 894 VisitRO(this, node, kSSEFloat32ToFloat64); |
| 895 } |
| 896 |
| 897 |
| 898 void InstructionSelector::VisitRoundInt32ToFloat32(Node* node) { |
| 899 VisitRO(this, node, kSSEInt32ToFloat32); |
| 900 } |
| 901 |
| 902 |
952 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) { | 903 void InstructionSelector::VisitRoundUint32ToFloat32(Node* node) { |
953 IA32OperandGenerator g(this); | 904 IA32OperandGenerator g(this); |
954 InstructionOperand temps[] = {g.TempRegister(), g.TempRegister()}; | 905 InstructionOperand temps[] = {g.TempRegister(), g.TempRegister()}; |
955 Emit(kSSEUint32ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0)), | 906 Emit(kSSEUint32ToFloat32, g.DefineAsRegister(node), g.Use(node->InputAt(0)), |
956 arraysize(temps), temps); | 907 arraysize(temps), temps); |
957 } | 908 } |
958 | 909 |
| 910 |
| 911 void InstructionSelector::VisitChangeInt32ToFloat64(Node* node) { |
| 912 VisitRO(this, node, kSSEInt32ToFloat64); |
| 913 } |
| 914 |
| 915 |
| 916 void InstructionSelector::VisitChangeUint32ToFloat64(Node* node) { |
| 917 VisitRO(this, node, kSSEUint32ToFloat64); |
| 918 } |
| 919 |
| 920 |
| 921 void InstructionSelector::VisitTruncateFloat32ToInt32(Node* node) { |
| 922 VisitRO(this, node, kSSEFloat32ToInt32); |
| 923 } |
| 924 |
| 925 |
| 926 void InstructionSelector::VisitTruncateFloat32ToUint32(Node* node) { |
| 927 VisitRO(this, node, kSSEFloat32ToUint32); |
| 928 } |
| 929 |
| 930 |
| 931 void InstructionSelector::VisitChangeFloat64ToInt32(Node* node) { |
| 932 VisitRO(this, node, kSSEFloat64ToInt32); |
| 933 } |
| 934 |
| 935 |
| 936 void InstructionSelector::VisitChangeFloat64ToUint32(Node* node) { |
| 937 VisitRO(this, node, kSSEFloat64ToUint32); |
| 938 } |
| 939 |
| 940 void InstructionSelector::VisitTruncateFloat64ToUint32(Node* node) { |
| 941 VisitRO(this, node, kSSEFloat64ToUint32); |
| 942 } |
| 943 |
| 944 void InstructionSelector::VisitTruncateFloat64ToFloat32(Node* node) { |
| 945 VisitRO(this, node, kSSEFloat64ToFloat32); |
| 946 } |
| 947 |
| 948 void InstructionSelector::VisitTruncateFloat64ToWord32(Node* node) { |
| 949 VisitRR(this, node, kArchTruncateDoubleToI); |
| 950 } |
| 951 |
| 952 void InstructionSelector::VisitRoundFloat64ToInt32(Node* node) { |
| 953 VisitRO(this, node, kSSEFloat64ToInt32); |
| 954 } |
| 955 |
| 956 |
| 957 void InstructionSelector::VisitBitcastFloat32ToInt32(Node* node) { |
| 958 IA32OperandGenerator g(this); |
| 959 Emit(kIA32BitcastFI, g.DefineAsRegister(node), g.Use(node->InputAt(0))); |
| 960 } |
| 961 |
| 962 |
| 963 void InstructionSelector::VisitBitcastInt32ToFloat32(Node* node) { |
| 964 IA32OperandGenerator g(this); |
| 965 Emit(kIA32BitcastIF, g.DefineAsRegister(node), g.Use(node->InputAt(0))); |
| 966 } |
| 967 |
| 968 |
| 969 void InstructionSelector::VisitFloat32Add(Node* node) { |
| 970 VisitRROFloat(this, node, kAVXFloat32Add, kSSEFloat32Add); |
| 971 } |
| 972 |
| 973 |
| 974 void InstructionSelector::VisitFloat64Add(Node* node) { |
| 975 VisitRROFloat(this, node, kAVXFloat64Add, kSSEFloat64Add); |
| 976 } |
| 977 |
| 978 |
| 979 void InstructionSelector::VisitFloat32Sub(Node* node) { |
| 980 VisitRROFloat(this, node, kAVXFloat32Sub, kSSEFloat32Sub); |
| 981 } |
| 982 |
| 983 void InstructionSelector::VisitFloat64Sub(Node* node) { |
| 984 VisitRROFloat(this, node, kAVXFloat64Sub, kSSEFloat64Sub); |
| 985 } |
| 986 |
| 987 void InstructionSelector::VisitFloat32Mul(Node* node) { |
| 988 VisitRROFloat(this, node, kAVXFloat32Mul, kSSEFloat32Mul); |
| 989 } |
| 990 |
| 991 |
| 992 void InstructionSelector::VisitFloat64Mul(Node* node) { |
| 993 VisitRROFloat(this, node, kAVXFloat64Mul, kSSEFloat64Mul); |
| 994 } |
| 995 |
| 996 |
| 997 void InstructionSelector::VisitFloat32Div(Node* node) { |
| 998 VisitRROFloat(this, node, kAVXFloat32Div, kSSEFloat32Div); |
| 999 } |
| 1000 |
| 1001 |
| 1002 void InstructionSelector::VisitFloat64Div(Node* node) { |
| 1003 VisitRROFloat(this, node, kAVXFloat64Div, kSSEFloat64Div); |
| 1004 } |
| 1005 |
| 1006 |
959 void InstructionSelector::VisitFloat64Mod(Node* node) { | 1007 void InstructionSelector::VisitFloat64Mod(Node* node) { |
960 IA32OperandGenerator g(this); | 1008 IA32OperandGenerator g(this); |
961 InstructionOperand temps[] = {g.TempRegister(eax)}; | 1009 InstructionOperand temps[] = {g.TempRegister(eax)}; |
962 Emit(kSSEFloat64Mod, g.DefineSameAsFirst(node), | 1010 Emit(kSSEFloat64Mod, g.DefineSameAsFirst(node), |
963 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)), 1, | 1011 g.UseRegister(node->InputAt(0)), g.UseRegister(node->InputAt(1)), 1, |
964 temps); | 1012 temps); |
965 } | 1013 } |
966 | 1014 |
967 void InstructionSelector::VisitFloat32Max(Node* node) { | 1015 void InstructionSelector::VisitFloat32Max(Node* node) { |
968 IA32OperandGenerator g(this); | 1016 IA32OperandGenerator g(this); |
(...skipping 20 matching lines...) Expand all Loading... |
989 } | 1037 } |
990 | 1038 |
991 void InstructionSelector::VisitFloat64Min(Node* node) { | 1039 void InstructionSelector::VisitFloat64Min(Node* node) { |
992 IA32OperandGenerator g(this); | 1040 IA32OperandGenerator g(this); |
993 InstructionOperand temps[] = {g.TempRegister()}; | 1041 InstructionOperand temps[] = {g.TempRegister()}; |
994 Emit(kSSEFloat64Min, g.DefineSameAsFirst(node), | 1042 Emit(kSSEFloat64Min, g.DefineSameAsFirst(node), |
995 g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)), | 1043 g.UseRegister(node->InputAt(0)), g.Use(node->InputAt(1)), |
996 arraysize(temps), temps); | 1044 arraysize(temps), temps); |
997 } | 1045 } |
998 | 1046 |
| 1047 |
| 1048 void InstructionSelector::VisitFloat32Abs(Node* node) { |
| 1049 IA32OperandGenerator g(this); |
| 1050 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Abs, kSSEFloat32Abs); |
| 1051 } |
| 1052 |
| 1053 |
| 1054 void InstructionSelector::VisitFloat64Abs(Node* node) { |
| 1055 IA32OperandGenerator g(this); |
| 1056 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Abs, kSSEFloat64Abs); |
| 1057 } |
| 1058 |
| 1059 void InstructionSelector::VisitFloat32Sqrt(Node* node) { |
| 1060 VisitRO(this, node, kSSEFloat32Sqrt); |
| 1061 } |
| 1062 |
| 1063 |
| 1064 void InstructionSelector::VisitFloat64Sqrt(Node* node) { |
| 1065 VisitRO(this, node, kSSEFloat64Sqrt); |
| 1066 } |
| 1067 |
| 1068 |
| 1069 void InstructionSelector::VisitFloat32RoundDown(Node* node) { |
| 1070 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundDown)); |
| 1071 } |
| 1072 |
| 1073 |
| 1074 void InstructionSelector::VisitFloat64RoundDown(Node* node) { |
| 1075 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundDown)); |
| 1076 } |
| 1077 |
| 1078 |
| 1079 void InstructionSelector::VisitFloat32RoundUp(Node* node) { |
| 1080 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundUp)); |
| 1081 } |
| 1082 |
| 1083 |
| 1084 void InstructionSelector::VisitFloat64RoundUp(Node* node) { |
| 1085 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundUp)); |
| 1086 } |
| 1087 |
| 1088 |
| 1089 void InstructionSelector::VisitFloat32RoundTruncate(Node* node) { |
| 1090 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToZero)); |
| 1091 } |
| 1092 |
| 1093 |
| 1094 void InstructionSelector::VisitFloat64RoundTruncate(Node* node) { |
| 1095 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToZero)); |
| 1096 } |
| 1097 |
| 1098 |
999 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) { | 1099 void InstructionSelector::VisitFloat64RoundTiesAway(Node* node) { |
1000 UNREACHABLE(); | 1100 UNREACHABLE(); |
1001 } | 1101 } |
1002 | 1102 |
| 1103 |
| 1104 void InstructionSelector::VisitFloat32RoundTiesEven(Node* node) { |
| 1105 VisitRR(this, node, kSSEFloat32Round | MiscField::encode(kRoundToNearest)); |
| 1106 } |
| 1107 |
| 1108 |
| 1109 void InstructionSelector::VisitFloat64RoundTiesEven(Node* node) { |
| 1110 VisitRR(this, node, kSSEFloat64Round | MiscField::encode(kRoundToNearest)); |
| 1111 } |
| 1112 |
| 1113 void InstructionSelector::VisitFloat32Neg(Node* node) { |
| 1114 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat32Neg, kSSEFloat32Neg); |
| 1115 } |
| 1116 |
| 1117 void InstructionSelector::VisitFloat64Neg(Node* node) { |
| 1118 VisitFloatUnop(this, node, node->InputAt(0), kAVXFloat64Neg, kSSEFloat64Neg); |
| 1119 } |
| 1120 |
1003 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node, | 1121 void InstructionSelector::VisitFloat64Ieee754Binop(Node* node, |
1004 InstructionCode opcode) { | 1122 InstructionCode opcode) { |
1005 IA32OperandGenerator g(this); | 1123 IA32OperandGenerator g(this); |
1006 Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(node->InputAt(0)), | 1124 Emit(opcode, g.DefineSameAsFirst(node), g.UseRegister(node->InputAt(0)), |
1007 g.UseRegister(node->InputAt(1))) | 1125 g.UseRegister(node->InputAt(1))) |
1008 ->MarkAsCall(); | 1126 ->MarkAsCall(); |
1009 } | 1127 } |
1010 | 1128 |
1011 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node, | 1129 void InstructionSelector::VisitFloat64Ieee754Unop(Node* node, |
1012 InstructionCode opcode) { | 1130 InstructionCode opcode) { |
(...skipping 545 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1558 } | 1676 } |
1559 | 1677 |
1560 | 1678 |
1561 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) { | 1679 void InstructionSelector::VisitFloat64LessThanOrEqual(Node* node) { |
1562 FlagsContinuation cont = | 1680 FlagsContinuation cont = |
1563 FlagsContinuation::ForSet(kUnsignedGreaterThanOrEqual, node); | 1681 FlagsContinuation::ForSet(kUnsignedGreaterThanOrEqual, node); |
1564 VisitFloat64Compare(this, node, &cont); | 1682 VisitFloat64Compare(this, node, &cont); |
1565 } | 1683 } |
1566 | 1684 |
1567 | 1685 |
| 1686 void InstructionSelector::VisitFloat64ExtractLowWord32(Node* node) { |
| 1687 IA32OperandGenerator g(this); |
| 1688 Emit(kSSEFloat64ExtractLowWord32, g.DefineAsRegister(node), |
| 1689 g.Use(node->InputAt(0))); |
| 1690 } |
| 1691 |
| 1692 |
| 1693 void InstructionSelector::VisitFloat64ExtractHighWord32(Node* node) { |
| 1694 IA32OperandGenerator g(this); |
| 1695 Emit(kSSEFloat64ExtractHighWord32, g.DefineAsRegister(node), |
| 1696 g.Use(node->InputAt(0))); |
| 1697 } |
| 1698 |
1568 | 1699 |
1569 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) { | 1700 void InstructionSelector::VisitFloat64InsertLowWord32(Node* node) { |
1570 IA32OperandGenerator g(this); | 1701 IA32OperandGenerator g(this); |
1571 Node* left = node->InputAt(0); | 1702 Node* left = node->InputAt(0); |
1572 Node* right = node->InputAt(1); | 1703 Node* right = node->InputAt(1); |
1573 Float64Matcher mleft(left); | 1704 Float64Matcher mleft(left); |
1574 if (mleft.HasValue() && (bit_cast<uint64_t>(mleft.Value()) >> 32) == 0u) { | 1705 if (mleft.HasValue() && (bit_cast<uint64_t>(mleft.Value()) >> 32) == 0u) { |
1575 Emit(kSSEFloat64LoadLowWord32, g.DefineAsRegister(node), g.Use(right)); | 1706 Emit(kSSEFloat64LoadLowWord32, g.DefineAsRegister(node), g.Use(right)); |
1576 return; | 1707 return; |
1577 } | 1708 } |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1666 // static | 1797 // static |
1667 MachineOperatorBuilder::AlignmentRequirements | 1798 MachineOperatorBuilder::AlignmentRequirements |
1668 InstructionSelector::AlignmentRequirements() { | 1799 InstructionSelector::AlignmentRequirements() { |
1669 return MachineOperatorBuilder::AlignmentRequirements:: | 1800 return MachineOperatorBuilder::AlignmentRequirements:: |
1670 FullUnalignedAccessSupport(); | 1801 FullUnalignedAccessSupport(); |
1671 } | 1802 } |
1672 | 1803 |
1673 } // namespace compiler | 1804 } // namespace compiler |
1674 } // namespace internal | 1805 } // namespace internal |
1675 } // namespace v8 | 1806 } // namespace v8 |
OLD | NEW |