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 <cmath> | 5 #include <cmath> |
6 #include <functional> | 6 #include <functional> |
7 #include <limits> | 7 #include <limits> |
8 | 8 |
9 #include "src/base/bits.h" | 9 #include "src/base/bits.h" |
10 #include "src/codegen.h" | 10 #include "src/codegen.h" |
11 #include "test/cctest/cctest.h" | 11 #include "test/cctest/cctest.h" |
12 #include "test/cctest/compiler/codegen-tester.h" | 12 #include "test/cctest/compiler/codegen-tester.h" |
13 #include "test/cctest/compiler/value-helper.h" | 13 #include "test/cctest/compiler/value-helper.h" |
14 | 14 |
15 #if V8_TURBOFAN_TARGET | 15 #if V8_TURBOFAN_TARGET |
16 | 16 |
17 using namespace v8::base; | 17 using namespace v8::base; |
| 18 |
| 19 #define CHECK_UINT32_EQ(x, y) \ |
| 20 CHECK_EQ(static_cast<int32_t>(x), static_cast<int32_t>(y)) |
| 21 |
18 using namespace v8::internal; | 22 using namespace v8::internal; |
19 using namespace v8::internal::compiler; | 23 using namespace v8::internal::compiler; |
20 | 24 |
21 typedef RawMachineAssembler::Label MLabel; | 25 typedef RawMachineAssembler::Label MLabel; |
22 | 26 |
23 TEST(RunInt32Add) { | 27 TEST(RunInt32Add) { |
24 RawMachineAssemblerTester<int32_t> m; | 28 RawMachineAssemblerTester<int32_t> m; |
25 Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1)); | 29 Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1)); |
26 m.Return(add); | 30 m.Return(add); |
27 CHECK_EQ(1, m.Call()); | 31 CHECK_EQ(1, m.Call()); |
(...skipping 466 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
494 // generate load [#base + #index] | 498 // generate load [#base + #index] |
495 Node* load = | 499 Node* load = |
496 m.Load(kMachFloat64, m.PointerConstant(from), m.Int32Constant(offset)); | 500 m.Load(kMachFloat64, m.PointerConstant(from), m.Int32Constant(offset)); |
497 m.Store(kMachFloat64, m.PointerConstant(to), m.Int32Constant(offset), load); | 501 m.Store(kMachFloat64, m.PointerConstant(to), m.Int32Constant(offset), load); |
498 m.Return(m.Int32Constant(magic)); | 502 m.Return(m.Int32Constant(magic)); |
499 | 503 |
500 FOR_FLOAT64_INPUTS(j) { | 504 FOR_FLOAT64_INPUTS(j) { |
501 p1 = *j; | 505 p1 = *j; |
502 p2 = *j - 5; | 506 p2 = *j - 5; |
503 CHECK_EQ(magic, m.Call()); | 507 CHECK_EQ(magic, m.Call()); |
504 CheckDoubleEq(p1, p2); | 508 CHECK_EQ(p1, p2); |
505 } | 509 } |
506 } | 510 } |
507 } | 511 } |
508 | 512 |
509 | 513 |
510 TEST(RunInt32AddP) { | 514 TEST(RunInt32AddP) { |
511 RawMachineAssemblerTester<int32_t> m; | 515 RawMachineAssemblerTester<int32_t> m; |
512 Int32BinopTester bt(&m); | 516 Int32BinopTester bt(&m); |
513 | 517 |
514 bt.AddReturn(m.Int32Add(bt.param0, bt.param1)); | 518 bt.AddReturn(m.Int32Add(bt.param0, bt.param1)); |
(...skipping 237 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
752 } | 756 } |
753 } | 757 } |
754 } | 758 } |
755 } | 759 } |
756 | 760 |
757 | 761 |
758 TEST(RunInt32AddInBranch) { | 762 TEST(RunInt32AddInBranch) { |
759 static const int32_t constant = 987654321; | 763 static const int32_t constant = 987654321; |
760 { | 764 { |
761 RawMachineAssemblerTester<int32_t> m; | 765 RawMachineAssemblerTester<int32_t> m; |
762 Int32BinopTester bt(&m); | 766 Uint32BinopTester bt(&m); |
763 MLabel blocka, blockb; | 767 MLabel blocka, blockb; |
764 m.Branch( | 768 m.Branch( |
765 m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)), | 769 m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)), |
766 &blocka, &blockb); | 770 &blocka, &blockb); |
767 m.Bind(&blocka); | 771 m.Bind(&blocka); |
768 bt.AddReturn(m.Int32Constant(constant)); | 772 bt.AddReturn(m.Int32Constant(constant)); |
769 m.Bind(&blockb); | 773 m.Bind(&blockb); |
770 bt.AddReturn(m.Int32Constant(0 - constant)); | 774 bt.AddReturn(m.Int32Constant(0 - constant)); |
771 FOR_UINT32_INPUTS(i) { | 775 FOR_UINT32_INPUTS(i) { |
772 FOR_UINT32_INPUTS(j) { | 776 FOR_UINT32_INPUTS(j) { |
773 int32_t expected = (*i + *j) == 0 ? constant : 0 - constant; | 777 int32_t expected = (*i + *j) == 0 ? constant : 0 - constant; |
774 CHECK_EQ(expected, bt.call(*i, *j)); | 778 CHECK_EQ(expected, bt.call(*i, *j)); |
775 } | 779 } |
776 } | 780 } |
777 } | 781 } |
778 { | 782 { |
779 RawMachineAssemblerTester<int32_t> m; | 783 RawMachineAssemblerTester<int32_t> m; |
780 Int32BinopTester bt(&m); | 784 Uint32BinopTester bt(&m); |
781 MLabel blocka, blockb; | 785 MLabel blocka, blockb; |
782 m.Branch( | 786 m.Branch( |
783 m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)), | 787 m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)), |
784 &blocka, &blockb); | 788 &blocka, &blockb); |
785 m.Bind(&blocka); | 789 m.Bind(&blocka); |
786 bt.AddReturn(m.Int32Constant(constant)); | 790 bt.AddReturn(m.Int32Constant(constant)); |
787 m.Bind(&blockb); | 791 m.Bind(&blockb); |
788 bt.AddReturn(m.Int32Constant(0 - constant)); | 792 bt.AddReturn(m.Int32Constant(0 - constant)); |
789 FOR_UINT32_INPUTS(i) { | 793 FOR_UINT32_INPUTS(i) { |
790 FOR_UINT32_INPUTS(j) { | 794 FOR_UINT32_INPUTS(j) { |
791 int32_t expected = (*i + *j) != 0 ? constant : 0 - constant; | 795 int32_t expected = (*i + *j) != 0 ? constant : 0 - constant; |
792 CHECK_EQ(expected, bt.call(*i, *j)); | 796 CHECK_EQ(expected, bt.call(*i, *j)); |
793 } | 797 } |
794 } | 798 } |
795 } | 799 } |
796 { | 800 { |
797 FOR_UINT32_INPUTS(i) { | 801 FOR_UINT32_INPUTS(i) { |
798 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 802 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
799 MLabel blocka, blockb; | 803 MLabel blocka, blockb; |
800 m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), | 804 m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), |
801 m.Int32Constant(0)), | 805 m.Int32Constant(0)), |
802 &blocka, &blockb); | 806 &blocka, &blockb); |
803 m.Bind(&blocka); | 807 m.Bind(&blocka); |
804 m.Return(m.Int32Constant(constant)); | 808 m.Return(m.Int32Constant(constant)); |
805 m.Bind(&blockb); | 809 m.Bind(&blockb); |
806 m.Return(m.Int32Constant(0 - constant)); | 810 m.Return(m.Int32Constant(0 - constant)); |
807 FOR_UINT32_INPUTS(j) { | 811 FOR_UINT32_INPUTS(j) { |
808 uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant; | 812 uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant; |
809 CHECK_EQ(expected, m.Call(*j)); | 813 CHECK_UINT32_EQ(expected, m.Call(*j)); |
810 } | 814 } |
811 } | 815 } |
812 } | 816 } |
813 { | 817 { |
814 FOR_UINT32_INPUTS(i) { | 818 FOR_UINT32_INPUTS(i) { |
815 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 819 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
816 MLabel blocka, blockb; | 820 MLabel blocka, blockb; |
817 m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), | 821 m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), |
818 m.Int32Constant(0)), | 822 m.Int32Constant(0)), |
819 &blocka, &blockb); | 823 &blocka, &blockb); |
820 m.Bind(&blocka); | 824 m.Bind(&blocka); |
821 m.Return(m.Int32Constant(constant)); | 825 m.Return(m.Int32Constant(constant)); |
822 m.Bind(&blockb); | 826 m.Bind(&blockb); |
823 m.Return(m.Int32Constant(0 - constant)); | 827 m.Return(m.Int32Constant(0 - constant)); |
824 FOR_UINT32_INPUTS(j) { | 828 FOR_UINT32_INPUTS(j) { |
825 uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant; | 829 uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant; |
826 CHECK_EQ(expected, m.Call(*j)); | 830 CHECK_UINT32_EQ(expected, m.Call(*j)); |
827 } | 831 } |
828 } | 832 } |
829 } | 833 } |
830 { | 834 { |
831 RawMachineAssemblerTester<void> m; | 835 RawMachineAssemblerTester<void> m; |
832 const Operator* shops[] = {m.machine()->Word32Sar(), | 836 const Operator* shops[] = {m.machine()->Word32Sar(), |
833 m.machine()->Word32Shl(), | 837 m.machine()->Word32Shl(), |
834 m.machine()->Word32Shr()}; | 838 m.machine()->Word32Shr()}; |
835 for (size_t n = 0; n < arraysize(shops); n++) { | 839 for (size_t n = 0; n < arraysize(shops); n++) { |
836 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, | 840 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
874 | 878 |
875 TEST(RunInt32AddInComparison) { | 879 TEST(RunInt32AddInComparison) { |
876 { | 880 { |
877 RawMachineAssemblerTester<int32_t> m; | 881 RawMachineAssemblerTester<int32_t> m; |
878 Uint32BinopTester bt(&m); | 882 Uint32BinopTester bt(&m); |
879 bt.AddReturn( | 883 bt.AddReturn( |
880 m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0))); | 884 m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0))); |
881 FOR_UINT32_INPUTS(i) { | 885 FOR_UINT32_INPUTS(i) { |
882 FOR_UINT32_INPUTS(j) { | 886 FOR_UINT32_INPUTS(j) { |
883 uint32_t expected = (*i + *j) == 0; | 887 uint32_t expected = (*i + *j) == 0; |
884 CHECK_EQ(expected, bt.call(*i, *j)); | 888 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
885 } | 889 } |
886 } | 890 } |
887 } | 891 } |
888 { | 892 { |
889 RawMachineAssemblerTester<int32_t> m; | 893 RawMachineAssemblerTester<int32_t> m; |
890 Uint32BinopTester bt(&m); | 894 Uint32BinopTester bt(&m); |
891 bt.AddReturn( | 895 bt.AddReturn( |
892 m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1))); | 896 m.Word32Equal(m.Int32Constant(0), m.Int32Add(bt.param0, bt.param1))); |
893 FOR_UINT32_INPUTS(i) { | 897 FOR_UINT32_INPUTS(i) { |
894 FOR_UINT32_INPUTS(j) { | 898 FOR_UINT32_INPUTS(j) { |
895 uint32_t expected = (*i + *j) == 0; | 899 uint32_t expected = (*i + *j) == 0; |
896 CHECK_EQ(expected, bt.call(*i, *j)); | 900 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
897 } | 901 } |
898 } | 902 } |
899 } | 903 } |
900 { | 904 { |
901 FOR_UINT32_INPUTS(i) { | 905 FOR_UINT32_INPUTS(i) { |
902 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 906 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
903 m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), | 907 m.Return(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)), |
904 m.Int32Constant(0))); | 908 m.Int32Constant(0))); |
905 FOR_UINT32_INPUTS(j) { | 909 FOR_UINT32_INPUTS(j) { |
906 uint32_t expected = (*i + *j) == 0; | 910 uint32_t expected = (*i + *j) == 0; |
907 CHECK_EQ(expected, m.Call(*j)); | 911 CHECK_UINT32_EQ(expected, m.Call(*j)); |
908 } | 912 } |
909 } | 913 } |
910 } | 914 } |
911 { | 915 { |
912 FOR_UINT32_INPUTS(i) { | 916 FOR_UINT32_INPUTS(i) { |
913 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 917 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
914 m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(*i)), | 918 m.Return(m.Word32Equal(m.Int32Add(m.Parameter(0), m.Int32Constant(*i)), |
915 m.Int32Constant(0))); | 919 m.Int32Constant(0))); |
916 FOR_UINT32_INPUTS(j) { | 920 FOR_UINT32_INPUTS(j) { |
917 uint32_t expected = (*j + *i) == 0; | 921 uint32_t expected = (*j + *i) == 0; |
918 CHECK_EQ(expected, m.Call(*j)); | 922 CHECK_UINT32_EQ(expected, m.Call(*j)); |
919 } | 923 } |
920 } | 924 } |
921 } | 925 } |
922 { | 926 { |
923 RawMachineAssemblerTester<void> m; | 927 RawMachineAssemblerTester<void> m; |
924 const Operator* shops[] = {m.machine()->Word32Sar(), | 928 const Operator* shops[] = {m.machine()->Word32Sar(), |
925 m.machine()->Word32Shl(), | 929 m.machine()->Word32Shl(), |
926 m.machine()->Word32Shr()}; | 930 m.machine()->Word32Shr()}; |
927 for (size_t n = 0; n < arraysize(shops); n++) { | 931 for (size_t n = 0; n < arraysize(shops); n++) { |
928 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, | 932 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
960 | 964 |
961 TEST(RunInt32SubP) { | 965 TEST(RunInt32SubP) { |
962 RawMachineAssemblerTester<int32_t> m; | 966 RawMachineAssemblerTester<int32_t> m; |
963 Uint32BinopTester bt(&m); | 967 Uint32BinopTester bt(&m); |
964 | 968 |
965 m.Return(m.Int32Sub(bt.param0, bt.param1)); | 969 m.Return(m.Int32Sub(bt.param0, bt.param1)); |
966 | 970 |
967 FOR_UINT32_INPUTS(i) { | 971 FOR_UINT32_INPUTS(i) { |
968 FOR_UINT32_INPUTS(j) { | 972 FOR_UINT32_INPUTS(j) { |
969 uint32_t expected = static_cast<int32_t>(*i - *j); | 973 uint32_t expected = static_cast<int32_t>(*i - *j); |
970 CHECK_EQ(expected, bt.call(*i, *j)); | 974 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
971 } | 975 } |
972 } | 976 } |
973 } | 977 } |
974 | 978 |
975 | 979 |
976 TEST(RunInt32SubImm) { | 980 TEST(RunInt32SubImm) { |
977 { | 981 { |
978 FOR_UINT32_INPUTS(i) { | 982 FOR_UINT32_INPUTS(i) { |
979 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 983 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
980 m.Return(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0))); | 984 m.Return(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0))); |
981 FOR_UINT32_INPUTS(j) { | 985 FOR_UINT32_INPUTS(j) { |
982 uint32_t expected = *i - *j; | 986 uint32_t expected = *i - *j; |
983 CHECK_EQ(expected, m.Call(*j)); | 987 CHECK_UINT32_EQ(expected, m.Call(*j)); |
984 } | 988 } |
985 } | 989 } |
986 } | 990 } |
987 { | 991 { |
988 FOR_UINT32_INPUTS(i) { | 992 FOR_UINT32_INPUTS(i) { |
989 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 993 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
990 m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i))); | 994 m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i))); |
991 FOR_UINT32_INPUTS(j) { | 995 FOR_UINT32_INPUTS(j) { |
992 uint32_t expected = *j - *i; | 996 uint32_t expected = *j - *i; |
993 CHECK_EQ(expected, m.Call(*j)); | 997 CHECK_UINT32_EQ(expected, m.Call(*j)); |
994 } | 998 } |
995 } | 999 } |
996 } | 1000 } |
997 } | 1001 } |
998 | 1002 |
999 | 1003 |
1000 TEST(RunInt32SubAndWord32SarP) { | 1004 TEST(RunInt32SubAndWord32SarP) { |
1001 { | 1005 { |
1002 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32); | 1006 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, kMachUint32); |
1003 m.Return(m.Int32Sub(m.Parameter(0), | 1007 m.Return(m.Int32Sub(m.Parameter(0), |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1061 TEST(RunInt32SubAndWord32ShrP) { | 1065 TEST(RunInt32SubAndWord32ShrP) { |
1062 { | 1066 { |
1063 RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32, | 1067 RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32, |
1064 kMachUint32); | 1068 kMachUint32); |
1065 m.Return(m.Int32Sub(m.Parameter(0), | 1069 m.Return(m.Int32Sub(m.Parameter(0), |
1066 m.Word32Shr(m.Parameter(1), m.Parameter(2)))); | 1070 m.Word32Shr(m.Parameter(1), m.Parameter(2)))); |
1067 FOR_UINT32_INPUTS(i) { | 1071 FOR_UINT32_INPUTS(i) { |
1068 FOR_UINT32_INPUTS(j) { | 1072 FOR_UINT32_INPUTS(j) { |
1069 FOR_UINT32_SHIFTS(shift) { | 1073 FOR_UINT32_SHIFTS(shift) { |
1070 // Use uint32_t because signed overflow is UB in C. | 1074 // Use uint32_t because signed overflow is UB in C. |
1071 uint32_t expected = *i - (*j >> shift); | 1075 int32_t expected = *i - (*j >> shift); |
1072 CHECK_EQ(expected, m.Call(*i, *j, shift)); | 1076 CHECK_UINT32_EQ(expected, m.Call(*i, *j, shift)); |
1073 } | 1077 } |
1074 } | 1078 } |
1075 } | 1079 } |
1076 } | 1080 } |
1077 { | 1081 { |
1078 RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32, | 1082 RawMachineAssemblerTester<uint32_t> m(kMachUint32, kMachUint32, |
1079 kMachUint32); | 1083 kMachUint32); |
1080 m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)), | 1084 m.Return(m.Int32Sub(m.Word32Shr(m.Parameter(0), m.Parameter(1)), |
1081 m.Parameter(2))); | 1085 m.Parameter(2))); |
1082 FOR_UINT32_INPUTS(i) { | 1086 FOR_UINT32_INPUTS(i) { |
1083 FOR_UINT32_SHIFTS(shift) { | 1087 FOR_UINT32_SHIFTS(shift) { |
1084 FOR_UINT32_INPUTS(k) { | 1088 FOR_UINT32_INPUTS(k) { |
1085 // Use uint32_t because signed overflow is UB in C. | 1089 // Use uint32_t because signed overflow is UB in C. |
1086 uint32_t expected = (*i >> shift) - *k; | 1090 int32_t expected = (*i >> shift) - *k; |
1087 CHECK_EQ(expected, m.Call(*i, shift, *k)); | 1091 CHECK_EQ(expected, m.Call(*i, shift, *k)); |
1088 } | 1092 } |
1089 } | 1093 } |
1090 } | 1094 } |
1091 } | 1095 } |
1092 } | 1096 } |
1093 | 1097 |
1094 | 1098 |
1095 TEST(RunInt32SubInBranch) { | 1099 TEST(RunInt32SubInBranch) { |
1096 static const int constant = 987654321; | 1100 static const int constant = 987654321; |
1097 { | 1101 { |
1098 RawMachineAssemblerTester<int32_t> m; | 1102 RawMachineAssemblerTester<int32_t> m; |
1099 Int32BinopTester bt(&m); | 1103 Uint32BinopTester bt(&m); |
1100 MLabel blocka, blockb; | 1104 MLabel blocka, blockb; |
1101 m.Branch( | 1105 m.Branch( |
1102 m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)), | 1106 m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)), |
1103 &blocka, &blockb); | 1107 &blocka, &blockb); |
1104 m.Bind(&blocka); | 1108 m.Bind(&blocka); |
1105 bt.AddReturn(m.Int32Constant(constant)); | 1109 bt.AddReturn(m.Int32Constant(constant)); |
1106 m.Bind(&blockb); | 1110 m.Bind(&blockb); |
1107 bt.AddReturn(m.Int32Constant(0 - constant)); | 1111 bt.AddReturn(m.Int32Constant(0 - constant)); |
1108 FOR_UINT32_INPUTS(i) { | 1112 FOR_UINT32_INPUTS(i) { |
1109 FOR_UINT32_INPUTS(j) { | 1113 FOR_UINT32_INPUTS(j) { |
1110 int32_t expected = (*i - *j) == 0 ? constant : 0 - constant; | 1114 int32_t expected = (*i - *j) == 0 ? constant : 0 - constant; |
1111 CHECK_EQ(expected, bt.call(*i, *j)); | 1115 CHECK_EQ(expected, bt.call(*i, *j)); |
1112 } | 1116 } |
1113 } | 1117 } |
1114 } | 1118 } |
1115 { | 1119 { |
1116 RawMachineAssemblerTester<int32_t> m; | 1120 RawMachineAssemblerTester<int32_t> m; |
1117 Int32BinopTester bt(&m); | 1121 Uint32BinopTester bt(&m); |
1118 MLabel blocka, blockb; | 1122 MLabel blocka, blockb; |
1119 m.Branch( | 1123 m.Branch( |
1120 m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)), | 1124 m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)), |
1121 &blocka, &blockb); | 1125 &blocka, &blockb); |
1122 m.Bind(&blocka); | 1126 m.Bind(&blocka); |
1123 bt.AddReturn(m.Int32Constant(constant)); | 1127 bt.AddReturn(m.Int32Constant(constant)); |
1124 m.Bind(&blockb); | 1128 m.Bind(&blockb); |
1125 bt.AddReturn(m.Int32Constant(0 - constant)); | 1129 bt.AddReturn(m.Int32Constant(0 - constant)); |
1126 FOR_UINT32_INPUTS(i) { | 1130 FOR_UINT32_INPUTS(i) { |
1127 FOR_UINT32_INPUTS(j) { | 1131 FOR_UINT32_INPUTS(j) { |
1128 int32_t expected = (*i - *j) != 0 ? constant : 0 - constant; | 1132 int32_t expected = (*i - *j) != 0 ? constant : 0 - constant; |
1129 CHECK_EQ(expected, bt.call(*i, *j)); | 1133 CHECK_EQ(expected, bt.call(*i, *j)); |
1130 } | 1134 } |
1131 } | 1135 } |
1132 } | 1136 } |
1133 { | 1137 { |
1134 FOR_UINT32_INPUTS(i) { | 1138 FOR_UINT32_INPUTS(i) { |
1135 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1139 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1136 MLabel blocka, blockb; | 1140 MLabel blocka, blockb; |
1137 m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), | 1141 m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), |
1138 m.Int32Constant(0)), | 1142 m.Int32Constant(0)), |
1139 &blocka, &blockb); | 1143 &blocka, &blockb); |
1140 m.Bind(&blocka); | 1144 m.Bind(&blocka); |
1141 m.Return(m.Int32Constant(constant)); | 1145 m.Return(m.Int32Constant(constant)); |
1142 m.Bind(&blockb); | 1146 m.Bind(&blockb); |
1143 m.Return(m.Int32Constant(0 - constant)); | 1147 m.Return(m.Int32Constant(0 - constant)); |
1144 FOR_UINT32_INPUTS(j) { | 1148 FOR_UINT32_INPUTS(j) { |
1145 uint32_t expected = (*i - *j) == 0 ? constant : 0 - constant; | 1149 int32_t expected = (*i - *j) == 0 ? constant : 0 - constant; |
1146 CHECK_EQ(expected, m.Call(*j)); | 1150 CHECK_EQ(expected, m.Call(*j)); |
1147 } | 1151 } |
1148 } | 1152 } |
1149 } | 1153 } |
1150 { | 1154 { |
1151 FOR_UINT32_INPUTS(i) { | 1155 FOR_UINT32_INPUTS(i) { |
1152 RawMachineAssemblerTester<int32_t> m(kMachUint32); | 1156 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
1153 MLabel blocka, blockb; | 1157 MLabel blocka, blockb; |
1154 m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), | 1158 m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), |
1155 m.Int32Constant(0)), | 1159 m.Int32Constant(0)), |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1211 | 1215 |
1212 TEST(RunInt32SubInComparison) { | 1216 TEST(RunInt32SubInComparison) { |
1213 { | 1217 { |
1214 RawMachineAssemblerTester<int32_t> m; | 1218 RawMachineAssemblerTester<int32_t> m; |
1215 Uint32BinopTester bt(&m); | 1219 Uint32BinopTester bt(&m); |
1216 bt.AddReturn( | 1220 bt.AddReturn( |
1217 m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0))); | 1221 m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0))); |
1218 FOR_UINT32_INPUTS(i) { | 1222 FOR_UINT32_INPUTS(i) { |
1219 FOR_UINT32_INPUTS(j) { | 1223 FOR_UINT32_INPUTS(j) { |
1220 uint32_t expected = (*i - *j) == 0; | 1224 uint32_t expected = (*i - *j) == 0; |
1221 CHECK_EQ(expected, bt.call(*i, *j)); | 1225 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1222 } | 1226 } |
1223 } | 1227 } |
1224 } | 1228 } |
1225 { | 1229 { |
1226 RawMachineAssemblerTester<int32_t> m; | 1230 RawMachineAssemblerTester<int32_t> m; |
1227 Uint32BinopTester bt(&m); | 1231 Uint32BinopTester bt(&m); |
1228 bt.AddReturn( | 1232 bt.AddReturn( |
1229 m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1))); | 1233 m.Word32Equal(m.Int32Constant(0), m.Int32Sub(bt.param0, bt.param1))); |
1230 FOR_UINT32_INPUTS(i) { | 1234 FOR_UINT32_INPUTS(i) { |
1231 FOR_UINT32_INPUTS(j) { | 1235 FOR_UINT32_INPUTS(j) { |
1232 uint32_t expected = (*i - *j) == 0; | 1236 uint32_t expected = (*i - *j) == 0; |
1233 CHECK_EQ(expected, bt.call(*i, *j)); | 1237 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1234 } | 1238 } |
1235 } | 1239 } |
1236 } | 1240 } |
1237 { | 1241 { |
1238 FOR_UINT32_INPUTS(i) { | 1242 FOR_UINT32_INPUTS(i) { |
1239 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1243 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1240 m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), | 1244 m.Return(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)), |
1241 m.Int32Constant(0))); | 1245 m.Int32Constant(0))); |
1242 FOR_UINT32_INPUTS(j) { | 1246 FOR_UINT32_INPUTS(j) { |
1243 uint32_t expected = (*i - *j) == 0; | 1247 uint32_t expected = (*i - *j) == 0; |
1244 CHECK_EQ(expected, m.Call(*j)); | 1248 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1245 } | 1249 } |
1246 } | 1250 } |
1247 } | 1251 } |
1248 { | 1252 { |
1249 FOR_UINT32_INPUTS(i) { | 1253 FOR_UINT32_INPUTS(i) { |
1250 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1254 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1251 m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)), | 1255 m.Return(m.Word32Equal(m.Int32Sub(m.Parameter(0), m.Int32Constant(*i)), |
1252 m.Int32Constant(0))); | 1256 m.Int32Constant(0))); |
1253 FOR_UINT32_INPUTS(j) { | 1257 FOR_UINT32_INPUTS(j) { |
1254 uint32_t expected = (*j - *i) == 0; | 1258 uint32_t expected = (*j - *i) == 0; |
1255 CHECK_EQ(expected, m.Call(*j)); | 1259 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1256 } | 1260 } |
1257 } | 1261 } |
1258 } | 1262 } |
1259 { | 1263 { |
1260 RawMachineAssemblerTester<void> m; | 1264 RawMachineAssemblerTester<void> m; |
1261 const Operator* shops[] = {m.machine()->Word32Sar(), | 1265 const Operator* shops[] = {m.machine()->Word32Sar(), |
1262 m.machine()->Word32Shl(), | 1266 m.machine()->Word32Shl(), |
1263 m.machine()->Word32Shr()}; | 1267 m.machine()->Word32Shr()}; |
1264 for (size_t n = 0; n < arraysize(shops); n++) { | 1268 for (size_t n = 0; n < arraysize(shops); n++) { |
1265 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, | 1269 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1307 } | 1311 } |
1308 } | 1312 } |
1309 } | 1313 } |
1310 { | 1314 { |
1311 RawMachineAssemblerTester<int32_t> m; | 1315 RawMachineAssemblerTester<int32_t> m; |
1312 Uint32BinopTester bt(&m); | 1316 Uint32BinopTester bt(&m); |
1313 bt.AddReturn(m.Int32Mul(bt.param0, bt.param1)); | 1317 bt.AddReturn(m.Int32Mul(bt.param0, bt.param1)); |
1314 FOR_UINT32_INPUTS(i) { | 1318 FOR_UINT32_INPUTS(i) { |
1315 FOR_UINT32_INPUTS(j) { | 1319 FOR_UINT32_INPUTS(j) { |
1316 uint32_t expected = *i * *j; | 1320 uint32_t expected = *i * *j; |
1317 CHECK_EQ(expected, bt.call(*i, *j)); | 1321 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1318 } | 1322 } |
1319 } | 1323 } |
1320 } | 1324 } |
1321 } | 1325 } |
1322 | 1326 |
1323 | 1327 |
1324 TEST(RunInt32MulHighP) { | 1328 TEST(RunInt32MulHighP) { |
1325 RawMachineAssemblerTester<int32_t> m; | 1329 RawMachineAssemblerTester<int32_t> m; |
1326 Int32BinopTester bt(&m); | 1330 Int32BinopTester bt(&m); |
1327 bt.AddReturn(m.Int32MulHigh(bt.param0, bt.param1)); | 1331 bt.AddReturn(m.Int32MulHigh(bt.param0, bt.param1)); |
1328 FOR_INT32_INPUTS(i) { | 1332 FOR_INT32_INPUTS(i) { |
1329 FOR_INT32_INPUTS(j) { | 1333 FOR_INT32_INPUTS(j) { |
1330 int32_t expected = static_cast<int32_t>( | 1334 int32_t expected = static_cast<int32_t>( |
1331 (static_cast<int64_t>(*i) * static_cast<int64_t>(*j)) >> 32); | 1335 (static_cast<int64_t>(*i) * static_cast<int64_t>(*j)) >> 32); |
1332 CHECK_EQ(expected, bt.call(*i, *j)); | 1336 CHECK_EQ(expected, bt.call(*i, *j)); |
1333 } | 1337 } |
1334 } | 1338 } |
1335 } | 1339 } |
1336 | 1340 |
1337 | 1341 |
1338 TEST(RunInt32MulImm) { | 1342 TEST(RunInt32MulImm) { |
1339 { | 1343 { |
1340 FOR_UINT32_INPUTS(i) { | 1344 FOR_UINT32_INPUTS(i) { |
1341 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1345 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1342 m.Return(m.Int32Mul(m.Int32Constant(*i), m.Parameter(0))); | 1346 m.Return(m.Int32Mul(m.Int32Constant(*i), m.Parameter(0))); |
1343 FOR_UINT32_INPUTS(j) { | 1347 FOR_UINT32_INPUTS(j) { |
1344 uint32_t expected = *i * *j; | 1348 uint32_t expected = *i * *j; |
1345 CHECK_EQ(expected, m.Call(*j)); | 1349 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1346 } | 1350 } |
1347 } | 1351 } |
1348 } | 1352 } |
1349 { | 1353 { |
1350 FOR_UINT32_INPUTS(i) { | 1354 FOR_UINT32_INPUTS(i) { |
1351 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1355 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1352 m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(*i))); | 1356 m.Return(m.Int32Mul(m.Parameter(0), m.Int32Constant(*i))); |
1353 FOR_UINT32_INPUTS(j) { | 1357 FOR_UINT32_INPUTS(j) { |
1354 uint32_t expected = *j * *i; | 1358 uint32_t expected = *j * *i; |
1355 CHECK_EQ(expected, m.Call(*j)); | 1359 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1356 } | 1360 } |
1357 } | 1361 } |
1358 } | 1362 } |
1359 } | 1363 } |
1360 | 1364 |
1361 | 1365 |
1362 TEST(RunInt32MulAndInt32AddP) { | 1366 TEST(RunInt32MulAndInt32AddP) { |
1363 { | 1367 { |
1364 FOR_INT32_INPUTS(i) { | 1368 FOR_INT32_INPUTS(i) { |
1365 FOR_INT32_INPUTS(j) { | 1369 FOR_INT32_INPUTS(j) { |
(...skipping 150 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1516 TEST(RunUint32DivP) { | 1520 TEST(RunUint32DivP) { |
1517 { | 1521 { |
1518 RawMachineAssemblerTester<int32_t> m; | 1522 RawMachineAssemblerTester<int32_t> m; |
1519 Int32BinopTester bt(&m); | 1523 Int32BinopTester bt(&m); |
1520 bt.AddReturn(m.Uint32Div(bt.param0, bt.param1)); | 1524 bt.AddReturn(m.Uint32Div(bt.param0, bt.param1)); |
1521 FOR_UINT32_INPUTS(i) { | 1525 FOR_UINT32_INPUTS(i) { |
1522 FOR_UINT32_INPUTS(j) { | 1526 FOR_UINT32_INPUTS(j) { |
1523 uint32_t p0 = *i; | 1527 uint32_t p0 = *i; |
1524 uint32_t p1 = *j; | 1528 uint32_t p1 = *j; |
1525 if (p1 != 0) { | 1529 if (p1 != 0) { |
1526 int32_t expected = bit_cast<int32_t>(p0 / p1); | 1530 uint32_t expected = static_cast<uint32_t>(p0 / p1); |
1527 CHECK_EQ(expected, bt.call(p0, p1)); | 1531 CHECK_EQ(expected, bt.call(p0, p1)); |
1528 } | 1532 } |
1529 } | 1533 } |
1530 } | 1534 } |
1531 } | 1535 } |
1532 { | 1536 { |
1533 RawMachineAssemblerTester<int32_t> m; | 1537 RawMachineAssemblerTester<int32_t> m; |
1534 Int32BinopTester bt(&m); | 1538 Int32BinopTester bt(&m); |
1535 bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Div(bt.param0, bt.param1))); | 1539 bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Div(bt.param0, bt.param1))); |
1536 FOR_UINT32_INPUTS(i) { | 1540 FOR_UINT32_INPUTS(i) { |
1537 FOR_UINT32_INPUTS(j) { | 1541 FOR_UINT32_INPUTS(j) { |
1538 uint32_t p0 = *i; | 1542 uint32_t p0 = *i; |
1539 uint32_t p1 = *j; | 1543 uint32_t p1 = *j; |
1540 if (p1 != 0) { | 1544 if (p1 != 0) { |
1541 int32_t expected = bit_cast<int32_t>(p0 + (p0 / p1)); | 1545 uint32_t expected = static_cast<uint32_t>(p0 + (p0 / p1)); |
1542 CHECK_EQ(expected, bt.call(p0, p1)); | 1546 CHECK_EQ(expected, bt.call(p0, p1)); |
1543 } | 1547 } |
1544 } | 1548 } |
1545 } | 1549 } |
1546 } | 1550 } |
1547 } | 1551 } |
1548 | 1552 |
1549 | 1553 |
1550 TEST(RunInt32ModP) { | 1554 TEST(RunInt32ModP) { |
1551 { | 1555 { |
(...skipping 25 matching lines...) Expand all Loading... |
1577 } | 1581 } |
1578 } | 1582 } |
1579 } | 1583 } |
1580 } | 1584 } |
1581 } | 1585 } |
1582 | 1586 |
1583 | 1587 |
1584 TEST(RunUint32ModP) { | 1588 TEST(RunUint32ModP) { |
1585 { | 1589 { |
1586 RawMachineAssemblerTester<int32_t> m; | 1590 RawMachineAssemblerTester<int32_t> m; |
1587 Uint32BinopTester bt(&m); | 1591 Int32BinopTester bt(&m); |
1588 bt.AddReturn(m.Uint32Mod(bt.param0, bt.param1)); | 1592 bt.AddReturn(m.Uint32Mod(bt.param0, bt.param1)); |
1589 FOR_UINT32_INPUTS(i) { | 1593 FOR_UINT32_INPUTS(i) { |
1590 FOR_UINT32_INPUTS(j) { | 1594 FOR_UINT32_INPUTS(j) { |
1591 uint32_t p0 = *i; | 1595 uint32_t p0 = *i; |
1592 uint32_t p1 = *j; | 1596 uint32_t p1 = *j; |
1593 if (p1 != 0) { | 1597 if (p1 != 0) { |
1594 uint32_t expected = static_cast<uint32_t>(p0 % p1); | 1598 uint32_t expected = static_cast<uint32_t>(p0 % p1); |
1595 CHECK_EQ(expected, bt.call(p0, p1)); | 1599 CHECK_EQ(expected, bt.call(p0, p1)); |
1596 } | 1600 } |
1597 } | 1601 } |
1598 } | 1602 } |
1599 } | 1603 } |
1600 { | 1604 { |
1601 RawMachineAssemblerTester<int32_t> m; | 1605 RawMachineAssemblerTester<int32_t> m; |
1602 Uint32BinopTester bt(&m); | 1606 Int32BinopTester bt(&m); |
1603 bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Mod(bt.param0, bt.param1))); | 1607 bt.AddReturn(m.Int32Add(bt.param0, m.Uint32Mod(bt.param0, bt.param1))); |
1604 FOR_UINT32_INPUTS(i) { | 1608 FOR_UINT32_INPUTS(i) { |
1605 FOR_UINT32_INPUTS(j) { | 1609 FOR_UINT32_INPUTS(j) { |
1606 uint32_t p0 = *i; | 1610 uint32_t p0 = *i; |
1607 uint32_t p1 = *j; | 1611 uint32_t p1 = *j; |
1608 if (p1 != 0) { | 1612 if (p1 != 0) { |
1609 uint32_t expected = static_cast<uint32_t>(p0 + (p0 % p1)); | 1613 uint32_t expected = static_cast<uint32_t>(p0 + (p0 % p1)); |
1610 CHECK_EQ(expected, bt.call(p0, p1)); | 1614 CHECK_EQ(expected, bt.call(p0, p1)); |
1611 } | 1615 } |
1612 } | 1616 } |
1613 } | 1617 } |
1614 } | 1618 } |
1615 } | 1619 } |
1616 | 1620 |
1617 | 1621 |
1618 TEST(RunWord32AndP) { | 1622 TEST(RunWord32AndP) { |
1619 { | 1623 { |
1620 RawMachineAssemblerTester<int32_t> m; | 1624 RawMachineAssemblerTester<int32_t> m; |
1621 Int32BinopTester bt(&m); | 1625 Int32BinopTester bt(&m); |
1622 bt.AddReturn(m.Word32And(bt.param0, bt.param1)); | 1626 bt.AddReturn(m.Word32And(bt.param0, bt.param1)); |
1623 FOR_UINT32_INPUTS(i) { | 1627 FOR_UINT32_INPUTS(i) { |
1624 FOR_UINT32_INPUTS(j) { | 1628 FOR_UINT32_INPUTS(j) { |
1625 int32_t expected = *i & *j; | 1629 uint32_t expected = *i & *j; |
1626 CHECK_EQ(expected, bt.call(*i, *j)); | 1630 CHECK_EQ(expected, bt.call(*i, *j)); |
1627 } | 1631 } |
1628 } | 1632 } |
1629 } | 1633 } |
1630 { | 1634 { |
1631 RawMachineAssemblerTester<int32_t> m; | 1635 RawMachineAssemblerTester<int32_t> m; |
1632 Int32BinopTester bt(&m); | 1636 Int32BinopTester bt(&m); |
1633 bt.AddReturn(m.Word32And(bt.param0, m.Word32Not(bt.param1))); | 1637 bt.AddReturn(m.Word32And(bt.param0, m.Word32Not(bt.param1))); |
1634 FOR_UINT32_INPUTS(i) { | 1638 FOR_UINT32_INPUTS(i) { |
1635 FOR_UINT32_INPUTS(j) { | 1639 FOR_UINT32_INPUTS(j) { |
1636 int32_t expected = *i & ~(*j); | 1640 uint32_t expected = *i & ~(*j); |
1637 CHECK_EQ(expected, bt.call(*i, *j)); | 1641 CHECK_EQ(expected, bt.call(*i, *j)); |
1638 } | 1642 } |
1639 } | 1643 } |
1640 } | 1644 } |
1641 { | 1645 { |
1642 RawMachineAssemblerTester<int32_t> m; | 1646 RawMachineAssemblerTester<int32_t> m; |
1643 Int32BinopTester bt(&m); | 1647 Int32BinopTester bt(&m); |
1644 bt.AddReturn(m.Word32And(m.Word32Not(bt.param0), bt.param1)); | 1648 bt.AddReturn(m.Word32And(m.Word32Not(bt.param0), bt.param1)); |
1645 FOR_UINT32_INPUTS(i) { | 1649 FOR_UINT32_INPUTS(i) { |
1646 FOR_UINT32_INPUTS(j) { | 1650 FOR_UINT32_INPUTS(j) { |
1647 int32_t expected = ~(*i) & *j; | 1651 uint32_t expected = ~(*i) & *j; |
1648 CHECK_EQ(expected, bt.call(*i, *j)); | 1652 CHECK_EQ(expected, bt.call(*i, *j)); |
1649 } | 1653 } |
1650 } | 1654 } |
1651 } | 1655 } |
1652 } | 1656 } |
1653 | 1657 |
1654 | 1658 |
1655 TEST(RunWord32AndAndWord32ShlP) { | 1659 TEST(RunWord32AndAndWord32ShlP) { |
1656 { | 1660 { |
1657 RawMachineAssemblerTester<int32_t> m; | 1661 RawMachineAssemblerTester<int32_t> m; |
1658 Uint32BinopTester bt(&m); | 1662 Uint32BinopTester bt(&m); |
1659 bt.AddReturn( | 1663 bt.AddReturn( |
1660 m.Word32Shl(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); | 1664 m.Word32Shl(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); |
1661 FOR_UINT32_INPUTS(i) { | 1665 FOR_UINT32_INPUTS(i) { |
1662 FOR_UINT32_INPUTS(j) { | 1666 FOR_UINT32_INPUTS(j) { |
1663 uint32_t expected = *i << (*j & 0x1f); | 1667 uint32_t expected = *i << (*j & 0x1f); |
1664 CHECK_EQ(expected, bt.call(*i, *j)); | 1668 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1665 } | 1669 } |
1666 } | 1670 } |
1667 } | 1671 } |
1668 { | 1672 { |
1669 RawMachineAssemblerTester<int32_t> m; | 1673 RawMachineAssemblerTester<int32_t> m; |
1670 Uint32BinopTester bt(&m); | 1674 Uint32BinopTester bt(&m); |
1671 bt.AddReturn( | 1675 bt.AddReturn( |
1672 m.Word32Shl(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); | 1676 m.Word32Shl(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); |
1673 FOR_UINT32_INPUTS(i) { | 1677 FOR_UINT32_INPUTS(i) { |
1674 FOR_UINT32_INPUTS(j) { | 1678 FOR_UINT32_INPUTS(j) { |
1675 uint32_t expected = *i << (0x1f & *j); | 1679 uint32_t expected = *i << (0x1f & *j); |
1676 CHECK_EQ(expected, bt.call(*i, *j)); | 1680 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1677 } | 1681 } |
1678 } | 1682 } |
1679 } | 1683 } |
1680 } | 1684 } |
1681 | 1685 |
1682 | 1686 |
1683 TEST(RunWord32AndAndWord32ShrP) { | 1687 TEST(RunWord32AndAndWord32ShrP) { |
1684 { | 1688 { |
1685 RawMachineAssemblerTester<int32_t> m; | 1689 RawMachineAssemblerTester<int32_t> m; |
1686 Uint32BinopTester bt(&m); | 1690 Uint32BinopTester bt(&m); |
1687 bt.AddReturn( | 1691 bt.AddReturn( |
1688 m.Word32Shr(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); | 1692 m.Word32Shr(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); |
1689 FOR_UINT32_INPUTS(i) { | 1693 FOR_UINT32_INPUTS(i) { |
1690 FOR_UINT32_INPUTS(j) { | 1694 FOR_UINT32_INPUTS(j) { |
1691 uint32_t expected = *i >> (*j & 0x1f); | 1695 uint32_t expected = *i >> (*j & 0x1f); |
1692 CHECK_EQ(expected, bt.call(*i, *j)); | 1696 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1693 } | 1697 } |
1694 } | 1698 } |
1695 } | 1699 } |
1696 { | 1700 { |
1697 RawMachineAssemblerTester<int32_t> m; | 1701 RawMachineAssemblerTester<int32_t> m; |
1698 Uint32BinopTester bt(&m); | 1702 Uint32BinopTester bt(&m); |
1699 bt.AddReturn( | 1703 bt.AddReturn( |
1700 m.Word32Shr(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); | 1704 m.Word32Shr(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); |
1701 FOR_UINT32_INPUTS(i) { | 1705 FOR_UINT32_INPUTS(i) { |
1702 FOR_UINT32_INPUTS(j) { | 1706 FOR_UINT32_INPUTS(j) { |
1703 uint32_t expected = *i >> (0x1f & *j); | 1707 uint32_t expected = *i >> (0x1f & *j); |
1704 CHECK_EQ(expected, bt.call(*i, *j)); | 1708 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1705 } | 1709 } |
1706 } | 1710 } |
1707 } | 1711 } |
1708 } | 1712 } |
1709 | 1713 |
1710 | 1714 |
1711 TEST(RunWord32AndAndWord32SarP) { | 1715 TEST(RunWord32AndAndWord32SarP) { |
1712 { | 1716 { |
1713 RawMachineAssemblerTester<int32_t> m; | 1717 RawMachineAssemblerTester<int32_t> m; |
1714 Int32BinopTester bt(&m); | 1718 Int32BinopTester bt(&m); |
1715 bt.AddReturn( | 1719 bt.AddReturn( |
1716 m.Word32Sar(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); | 1720 m.Word32Sar(bt.param0, m.Word32And(bt.param1, m.Int32Constant(0x1f)))); |
1717 FOR_INT32_INPUTS(i) { | 1721 FOR_INT32_INPUTS(i) { |
1718 FOR_INT32_INPUTS(j) { | 1722 FOR_INT32_INPUTS(j) { |
1719 int32_t expected = *i >> (*j & 0x1f); | 1723 int32_t expected = *i >> (*j & 0x1f); |
1720 CHECK_EQ(expected, bt.call(*i, *j)); | 1724 CHECK_EQ(expected, bt.call(*i, *j)); |
1721 } | 1725 } |
1722 } | 1726 } |
1723 } | 1727 } |
1724 { | 1728 { |
1725 RawMachineAssemblerTester<int32_t> m; | 1729 RawMachineAssemblerTester<int32_t> m; |
1726 Int32BinopTester bt(&m); | 1730 Int32BinopTester bt(&m); |
1727 bt.AddReturn( | 1731 bt.AddReturn( |
1728 m.Word32Sar(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); | 1732 m.Word32Sar(bt.param0, m.Word32And(m.Int32Constant(0x1f), bt.param1))); |
1729 FOR_INT32_INPUTS(i) { | 1733 FOR_INT32_INPUTS(i) { |
1730 FOR_INT32_INPUTS(j) { | 1734 FOR_INT32_INPUTS(j) { |
1731 int32_t expected = *i >> (0x1f & *j); | 1735 uint32_t expected = *i >> (0x1f & *j); |
1732 CHECK_EQ(expected, bt.call(*i, *j)); | 1736 CHECK_EQ(expected, bt.call(*i, *j)); |
1733 } | 1737 } |
1734 } | 1738 } |
1735 } | 1739 } |
1736 } | 1740 } |
1737 | 1741 |
1738 | 1742 |
1739 TEST(RunWord32AndImm) { | 1743 TEST(RunWord32AndImm) { |
1740 { | 1744 { |
1741 FOR_UINT32_INPUTS(i) { | 1745 FOR_UINT32_INPUTS(i) { |
1742 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1746 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1743 m.Return(m.Word32And(m.Int32Constant(*i), m.Parameter(0))); | 1747 m.Return(m.Word32And(m.Int32Constant(*i), m.Parameter(0))); |
1744 FOR_UINT32_INPUTS(j) { | 1748 FOR_UINT32_INPUTS(j) { |
1745 uint32_t expected = *i & *j; | 1749 uint32_t expected = *i & *j; |
1746 CHECK_EQ(expected, m.Call(*j)); | 1750 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1747 } | 1751 } |
1748 } | 1752 } |
1749 } | 1753 } |
1750 { | 1754 { |
1751 FOR_UINT32_INPUTS(i) { | 1755 FOR_UINT32_INPUTS(i) { |
1752 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1756 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1753 m.Return(m.Word32And(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); | 1757 m.Return(m.Word32And(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); |
1754 FOR_UINT32_INPUTS(j) { | 1758 FOR_UINT32_INPUTS(j) { |
1755 uint32_t expected = *i & ~(*j); | 1759 uint32_t expected = *i & ~(*j); |
1756 CHECK_EQ(expected, m.Call(*j)); | 1760 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1757 } | 1761 } |
1758 } | 1762 } |
1759 } | 1763 } |
1760 } | 1764 } |
1761 | 1765 |
1762 | 1766 |
1763 TEST(RunWord32AndInBranch) { | 1767 TEST(RunWord32AndInBranch) { |
1764 static const int constant = 987654321; | 1768 static const int constant = 987654321; |
1765 { | 1769 { |
1766 RawMachineAssemblerTester<int32_t> m; | 1770 RawMachineAssemblerTester<int32_t> m; |
1767 Int32BinopTester bt(&m); | 1771 Uint32BinopTester bt(&m); |
1768 MLabel blocka, blockb; | 1772 MLabel blocka, blockb; |
1769 m.Branch( | 1773 m.Branch( |
1770 m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)), | 1774 m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)), |
1771 &blocka, &blockb); | 1775 &blocka, &blockb); |
1772 m.Bind(&blocka); | 1776 m.Bind(&blocka); |
1773 bt.AddReturn(m.Int32Constant(constant)); | 1777 bt.AddReturn(m.Int32Constant(constant)); |
1774 m.Bind(&blockb); | 1778 m.Bind(&blockb); |
1775 bt.AddReturn(m.Int32Constant(0 - constant)); | 1779 bt.AddReturn(m.Int32Constant(0 - constant)); |
1776 FOR_UINT32_INPUTS(i) { | 1780 FOR_UINT32_INPUTS(i) { |
1777 FOR_UINT32_INPUTS(j) { | 1781 FOR_UINT32_INPUTS(j) { |
1778 int32_t expected = (*i & *j) == 0 ? constant : 0 - constant; | 1782 int32_t expected = (*i & *j) == 0 ? constant : 0 - constant; |
1779 CHECK_EQ(expected, bt.call(*i, *j)); | 1783 CHECK_EQ(expected, bt.call(*i, *j)); |
1780 } | 1784 } |
1781 } | 1785 } |
1782 } | 1786 } |
1783 { | 1787 { |
1784 RawMachineAssemblerTester<int32_t> m; | 1788 RawMachineAssemblerTester<int32_t> m; |
1785 Int32BinopTester bt(&m); | 1789 Uint32BinopTester bt(&m); |
1786 MLabel blocka, blockb; | 1790 MLabel blocka, blockb; |
1787 m.Branch( | 1791 m.Branch( |
1788 m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)), | 1792 m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)), |
1789 &blocka, &blockb); | 1793 &blocka, &blockb); |
1790 m.Bind(&blocka); | 1794 m.Bind(&blocka); |
1791 bt.AddReturn(m.Int32Constant(constant)); | 1795 bt.AddReturn(m.Int32Constant(constant)); |
1792 m.Bind(&blockb); | 1796 m.Bind(&blockb); |
1793 bt.AddReturn(m.Int32Constant(0 - constant)); | 1797 bt.AddReturn(m.Int32Constant(0 - constant)); |
1794 FOR_UINT32_INPUTS(i) { | 1798 FOR_UINT32_INPUTS(i) { |
1795 FOR_UINT32_INPUTS(j) { | 1799 FOR_UINT32_INPUTS(j) { |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1880 | 1884 |
1881 TEST(RunWord32AndInComparison) { | 1885 TEST(RunWord32AndInComparison) { |
1882 { | 1886 { |
1883 RawMachineAssemblerTester<int32_t> m; | 1887 RawMachineAssemblerTester<int32_t> m; |
1884 Uint32BinopTester bt(&m); | 1888 Uint32BinopTester bt(&m); |
1885 bt.AddReturn( | 1889 bt.AddReturn( |
1886 m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0))); | 1890 m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0))); |
1887 FOR_UINT32_INPUTS(i) { | 1891 FOR_UINT32_INPUTS(i) { |
1888 FOR_UINT32_INPUTS(j) { | 1892 FOR_UINT32_INPUTS(j) { |
1889 uint32_t expected = (*i & *j) == 0; | 1893 uint32_t expected = (*i & *j) == 0; |
1890 CHECK_EQ(expected, bt.call(*i, *j)); | 1894 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1891 } | 1895 } |
1892 } | 1896 } |
1893 } | 1897 } |
1894 { | 1898 { |
1895 RawMachineAssemblerTester<int32_t> m; | 1899 RawMachineAssemblerTester<int32_t> m; |
1896 Uint32BinopTester bt(&m); | 1900 Uint32BinopTester bt(&m); |
1897 bt.AddReturn( | 1901 bt.AddReturn( |
1898 m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1))); | 1902 m.Word32Equal(m.Int32Constant(0), m.Word32And(bt.param0, bt.param1))); |
1899 FOR_UINT32_INPUTS(i) { | 1903 FOR_UINT32_INPUTS(i) { |
1900 FOR_UINT32_INPUTS(j) { | 1904 FOR_UINT32_INPUTS(j) { |
1901 uint32_t expected = (*i & *j) == 0; | 1905 uint32_t expected = (*i & *j) == 0; |
1902 CHECK_EQ(expected, bt.call(*i, *j)); | 1906 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1903 } | 1907 } |
1904 } | 1908 } |
1905 } | 1909 } |
1906 { | 1910 { |
1907 FOR_UINT32_INPUTS(i) { | 1911 FOR_UINT32_INPUTS(i) { |
1908 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1912 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1909 m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)), | 1913 m.Return(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)), |
1910 m.Int32Constant(0))); | 1914 m.Int32Constant(0))); |
1911 FOR_UINT32_INPUTS(j) { | 1915 FOR_UINT32_INPUTS(j) { |
1912 uint32_t expected = (*i & *j) == 0; | 1916 uint32_t expected = (*i & *j) == 0; |
1913 CHECK_EQ(expected, m.Call(*j)); | 1917 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1914 } | 1918 } |
1915 } | 1919 } |
1916 } | 1920 } |
1917 { | 1921 { |
1918 FOR_UINT32_INPUTS(i) { | 1922 FOR_UINT32_INPUTS(i) { |
1919 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1923 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1920 m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(*i)), | 1924 m.Return(m.Word32Equal(m.Word32And(m.Parameter(0), m.Int32Constant(*i)), |
1921 m.Int32Constant(0))); | 1925 m.Int32Constant(0))); |
1922 FOR_UINT32_INPUTS(j) { | 1926 FOR_UINT32_INPUTS(j) { |
1923 uint32_t expected = (*j & *i) == 0; | 1927 uint32_t expected = (*j & *i) == 0; |
1924 CHECK_EQ(expected, m.Call(*j)); | 1928 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1925 } | 1929 } |
1926 } | 1930 } |
1927 } | 1931 } |
1928 } | 1932 } |
1929 | 1933 |
1930 | 1934 |
1931 TEST(RunWord32OrP) { | 1935 TEST(RunWord32OrP) { |
1932 { | 1936 { |
1933 RawMachineAssemblerTester<int32_t> m; | 1937 RawMachineAssemblerTester<int32_t> m; |
1934 Uint32BinopTester bt(&m); | 1938 Uint32BinopTester bt(&m); |
1935 bt.AddReturn(m.Word32Or(bt.param0, bt.param1)); | 1939 bt.AddReturn(m.Word32Or(bt.param0, bt.param1)); |
1936 FOR_UINT32_INPUTS(i) { | 1940 FOR_UINT32_INPUTS(i) { |
1937 FOR_UINT32_INPUTS(j) { | 1941 FOR_UINT32_INPUTS(j) { |
1938 uint32_t expected = *i | *j; | 1942 uint32_t expected = *i | *j; |
1939 CHECK_EQ(expected, bt.call(*i, *j)); | 1943 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1940 } | 1944 } |
1941 } | 1945 } |
1942 } | 1946 } |
1943 { | 1947 { |
1944 RawMachineAssemblerTester<int32_t> m; | 1948 RawMachineAssemblerTester<int32_t> m; |
1945 Uint32BinopTester bt(&m); | 1949 Uint32BinopTester bt(&m); |
1946 bt.AddReturn(m.Word32Or(bt.param0, m.Word32Not(bt.param1))); | 1950 bt.AddReturn(m.Word32Or(bt.param0, m.Word32Not(bt.param1))); |
1947 FOR_UINT32_INPUTS(i) { | 1951 FOR_UINT32_INPUTS(i) { |
1948 FOR_UINT32_INPUTS(j) { | 1952 FOR_UINT32_INPUTS(j) { |
1949 uint32_t expected = *i | ~(*j); | 1953 uint32_t expected = *i | ~(*j); |
1950 CHECK_EQ(expected, bt.call(*i, *j)); | 1954 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1951 } | 1955 } |
1952 } | 1956 } |
1953 } | 1957 } |
1954 { | 1958 { |
1955 RawMachineAssemblerTester<int32_t> m; | 1959 RawMachineAssemblerTester<int32_t> m; |
1956 Uint32BinopTester bt(&m); | 1960 Uint32BinopTester bt(&m); |
1957 bt.AddReturn(m.Word32Or(m.Word32Not(bt.param0), bt.param1)); | 1961 bt.AddReturn(m.Word32Or(m.Word32Not(bt.param0), bt.param1)); |
1958 FOR_UINT32_INPUTS(i) { | 1962 FOR_UINT32_INPUTS(i) { |
1959 FOR_UINT32_INPUTS(j) { | 1963 FOR_UINT32_INPUTS(j) { |
1960 uint32_t expected = ~(*i) | *j; | 1964 uint32_t expected = ~(*i) | *j; |
1961 CHECK_EQ(expected, bt.call(*i, *j)); | 1965 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
1962 } | 1966 } |
1963 } | 1967 } |
1964 } | 1968 } |
1965 } | 1969 } |
1966 | 1970 |
1967 | 1971 |
1968 TEST(RunWord32OrImm) { | 1972 TEST(RunWord32OrImm) { |
1969 { | 1973 { |
1970 FOR_UINT32_INPUTS(i) { | 1974 FOR_UINT32_INPUTS(i) { |
1971 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1975 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1972 m.Return(m.Word32Or(m.Int32Constant(*i), m.Parameter(0))); | 1976 m.Return(m.Word32Or(m.Int32Constant(*i), m.Parameter(0))); |
1973 FOR_UINT32_INPUTS(j) { | 1977 FOR_UINT32_INPUTS(j) { |
1974 uint32_t expected = *i | *j; | 1978 uint32_t expected = *i | *j; |
1975 CHECK_EQ(expected, m.Call(*j)); | 1979 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1976 } | 1980 } |
1977 } | 1981 } |
1978 } | 1982 } |
1979 { | 1983 { |
1980 FOR_UINT32_INPUTS(i) { | 1984 FOR_UINT32_INPUTS(i) { |
1981 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 1985 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
1982 m.Return(m.Word32Or(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); | 1986 m.Return(m.Word32Or(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); |
1983 FOR_UINT32_INPUTS(j) { | 1987 FOR_UINT32_INPUTS(j) { |
1984 uint32_t expected = *i | ~(*j); | 1988 uint32_t expected = *i | ~(*j); |
1985 CHECK_EQ(expected, m.Call(*j)); | 1989 CHECK_UINT32_EQ(expected, m.Call(*j)); |
1986 } | 1990 } |
1987 } | 1991 } |
1988 } | 1992 } |
1989 } | 1993 } |
1990 | 1994 |
1991 | 1995 |
1992 TEST(RunWord32OrInBranch) { | 1996 TEST(RunWord32OrInBranch) { |
1993 static const int constant = 987654321; | 1997 static const int constant = 987654321; |
1994 { | 1998 { |
1995 RawMachineAssemblerTester<int32_t> m; | 1999 RawMachineAssemblerTester<int32_t> m; |
(...skipping 106 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2102 } | 2106 } |
2103 } | 2107 } |
2104 } | 2108 } |
2105 } | 2109 } |
2106 } | 2110 } |
2107 | 2111 |
2108 | 2112 |
2109 TEST(RunWord32OrInComparison) { | 2113 TEST(RunWord32OrInComparison) { |
2110 { | 2114 { |
2111 RawMachineAssemblerTester<int32_t> m; | 2115 RawMachineAssemblerTester<int32_t> m; |
2112 Int32BinopTester bt(&m); | 2116 Uint32BinopTester bt(&m); |
2113 bt.AddReturn( | 2117 bt.AddReturn( |
2114 m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0))); | 2118 m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0))); |
2115 FOR_UINT32_INPUTS(i) { | 2119 FOR_UINT32_INPUTS(i) { |
2116 FOR_UINT32_INPUTS(j) { | 2120 FOR_UINT32_INPUTS(j) { |
2117 int32_t expected = (*i | *j) == 0; | 2121 int32_t expected = (*i | *j) == 0; |
2118 CHECK_EQ(expected, bt.call(*i, *j)); | 2122 CHECK_EQ(expected, bt.call(*i, *j)); |
2119 } | 2123 } |
2120 } | 2124 } |
2121 } | 2125 } |
2122 { | 2126 { |
2123 RawMachineAssemblerTester<int32_t> m; | 2127 RawMachineAssemblerTester<int32_t> m; |
2124 Int32BinopTester bt(&m); | 2128 Uint32BinopTester bt(&m); |
2125 bt.AddReturn( | 2129 bt.AddReturn( |
2126 m.Word32Equal(m.Int32Constant(0), m.Word32Or(bt.param0, bt.param1))); | 2130 m.Word32Equal(m.Int32Constant(0), m.Word32Or(bt.param0, bt.param1))); |
2127 FOR_UINT32_INPUTS(i) { | 2131 FOR_UINT32_INPUTS(i) { |
2128 FOR_UINT32_INPUTS(j) { | 2132 FOR_UINT32_INPUTS(j) { |
2129 int32_t expected = (*i | *j) == 0; | 2133 int32_t expected = (*i | *j) == 0; |
2130 CHECK_EQ(expected, bt.call(*i, *j)); | 2134 CHECK_EQ(expected, bt.call(*i, *j)); |
2131 } | 2135 } |
2132 } | 2136 } |
2133 } | 2137 } |
2134 { | 2138 { |
2135 FOR_UINT32_INPUTS(i) { | 2139 FOR_UINT32_INPUTS(i) { |
2136 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2140 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2137 m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)), | 2141 m.Return(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)), |
2138 m.Int32Constant(0))); | 2142 m.Int32Constant(0))); |
2139 FOR_UINT32_INPUTS(j) { | 2143 FOR_UINT32_INPUTS(j) { |
2140 uint32_t expected = (*i | *j) == 0; | 2144 uint32_t expected = (*i | *j) == 0; |
2141 CHECK_EQ(expected, m.Call(*j)); | 2145 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2142 } | 2146 } |
2143 } | 2147 } |
2144 } | 2148 } |
2145 { | 2149 { |
2146 FOR_UINT32_INPUTS(i) { | 2150 FOR_UINT32_INPUTS(i) { |
2147 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2151 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2148 m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(*i)), | 2152 m.Return(m.Word32Equal(m.Word32Or(m.Parameter(0), m.Int32Constant(*i)), |
2149 m.Int32Constant(0))); | 2153 m.Int32Constant(0))); |
2150 FOR_UINT32_INPUTS(j) { | 2154 FOR_UINT32_INPUTS(j) { |
2151 uint32_t expected = (*j | *i) == 0; | 2155 uint32_t expected = (*j | *i) == 0; |
2152 CHECK_EQ(expected, m.Call(*j)); | 2156 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2153 } | 2157 } |
2154 } | 2158 } |
2155 } | 2159 } |
2156 } | 2160 } |
2157 | 2161 |
2158 | 2162 |
2159 TEST(RunWord32XorP) { | 2163 TEST(RunWord32XorP) { |
2160 { | 2164 { |
2161 FOR_UINT32_INPUTS(i) { | 2165 FOR_UINT32_INPUTS(i) { |
2162 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2166 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2163 m.Return(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0))); | 2167 m.Return(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0))); |
2164 FOR_UINT32_INPUTS(j) { | 2168 FOR_UINT32_INPUTS(j) { |
2165 uint32_t expected = *i ^ *j; | 2169 uint32_t expected = *i ^ *j; |
2166 CHECK_EQ(expected, m.Call(*j)); | 2170 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2167 } | 2171 } |
2168 } | 2172 } |
2169 } | 2173 } |
2170 { | 2174 { |
2171 RawMachineAssemblerTester<int32_t> m; | 2175 RawMachineAssemblerTester<int32_t> m; |
2172 Uint32BinopTester bt(&m); | 2176 Uint32BinopTester bt(&m); |
2173 bt.AddReturn(m.Word32Xor(bt.param0, bt.param1)); | 2177 bt.AddReturn(m.Word32Xor(bt.param0, bt.param1)); |
2174 FOR_UINT32_INPUTS(i) { | 2178 FOR_UINT32_INPUTS(i) { |
2175 FOR_UINT32_INPUTS(j) { | 2179 FOR_UINT32_INPUTS(j) { |
2176 uint32_t expected = *i ^ *j; | 2180 int32_t expected = *i ^ *j; |
2177 CHECK_EQ(expected, bt.call(*i, *j)); | 2181 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
2178 } | 2182 } |
2179 } | 2183 } |
2180 } | 2184 } |
2181 { | 2185 { |
2182 RawMachineAssemblerTester<int32_t> m; | 2186 RawMachineAssemblerTester<int32_t> m; |
2183 Int32BinopTester bt(&m); | 2187 Int32BinopTester bt(&m); |
2184 bt.AddReturn(m.Word32Xor(bt.param0, m.Word32Not(bt.param1))); | 2188 bt.AddReturn(m.Word32Xor(bt.param0, m.Word32Not(bt.param1))); |
2185 FOR_INT32_INPUTS(i) { | 2189 FOR_INT32_INPUTS(i) { |
2186 FOR_INT32_INPUTS(j) { | 2190 FOR_INT32_INPUTS(j) { |
2187 int32_t expected = *i ^ ~(*j); | 2191 int32_t expected = *i ^ ~(*j); |
(...skipping 11 matching lines...) Expand all Loading... |
2199 CHECK_EQ(expected, bt.call(*i, *j)); | 2203 CHECK_EQ(expected, bt.call(*i, *j)); |
2200 } | 2204 } |
2201 } | 2205 } |
2202 } | 2206 } |
2203 { | 2207 { |
2204 FOR_UINT32_INPUTS(i) { | 2208 FOR_UINT32_INPUTS(i) { |
2205 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2209 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2206 m.Return(m.Word32Xor(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); | 2210 m.Return(m.Word32Xor(m.Int32Constant(*i), m.Word32Not(m.Parameter(0)))); |
2207 FOR_UINT32_INPUTS(j) { | 2211 FOR_UINT32_INPUTS(j) { |
2208 uint32_t expected = *i ^ ~(*j); | 2212 uint32_t expected = *i ^ ~(*j); |
2209 CHECK_EQ(expected, m.Call(*j)); | 2213 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2210 } | 2214 } |
2211 } | 2215 } |
2212 } | 2216 } |
2213 } | 2217 } |
2214 | 2218 |
2215 | 2219 |
2216 TEST(RunWord32XorInBranch) { | 2220 TEST(RunWord32XorInBranch) { |
2217 static const uint32_t constant = 987654321; | 2221 static const uint32_t constant = 987654321; |
2218 { | 2222 { |
2219 RawMachineAssemblerTester<int32_t> m; | 2223 RawMachineAssemblerTester<int32_t> m; |
2220 Uint32BinopTester bt(&m); | 2224 Uint32BinopTester bt(&m); |
2221 MLabel blocka, blockb; | 2225 MLabel blocka, blockb; |
2222 m.Branch( | 2226 m.Branch( |
2223 m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)), | 2227 m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)), |
2224 &blocka, &blockb); | 2228 &blocka, &blockb); |
2225 m.Bind(&blocka); | 2229 m.Bind(&blocka); |
2226 bt.AddReturn(m.Int32Constant(constant)); | 2230 bt.AddReturn(m.Int32Constant(constant)); |
2227 m.Bind(&blockb); | 2231 m.Bind(&blockb); |
2228 bt.AddReturn(m.Int32Constant(0 - constant)); | 2232 bt.AddReturn(m.Int32Constant(0 - constant)); |
2229 FOR_UINT32_INPUTS(i) { | 2233 FOR_UINT32_INPUTS(i) { |
2230 FOR_UINT32_INPUTS(j) { | 2234 FOR_UINT32_INPUTS(j) { |
2231 uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant; | 2235 uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant; |
2232 CHECK_EQ(expected, bt.call(*i, *j)); | 2236 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
2233 } | 2237 } |
2234 } | 2238 } |
2235 } | 2239 } |
2236 { | 2240 { |
2237 RawMachineAssemblerTester<int32_t> m; | 2241 RawMachineAssemblerTester<int32_t> m; |
2238 Uint32BinopTester bt(&m); | 2242 Uint32BinopTester bt(&m); |
2239 MLabel blocka, blockb; | 2243 MLabel blocka, blockb; |
2240 m.Branch( | 2244 m.Branch( |
2241 m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)), | 2245 m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)), |
2242 &blocka, &blockb); | 2246 &blocka, &blockb); |
2243 m.Bind(&blocka); | 2247 m.Bind(&blocka); |
2244 bt.AddReturn(m.Int32Constant(constant)); | 2248 bt.AddReturn(m.Int32Constant(constant)); |
2245 m.Bind(&blockb); | 2249 m.Bind(&blockb); |
2246 bt.AddReturn(m.Int32Constant(0 - constant)); | 2250 bt.AddReturn(m.Int32Constant(0 - constant)); |
2247 FOR_UINT32_INPUTS(i) { | 2251 FOR_UINT32_INPUTS(i) { |
2248 FOR_UINT32_INPUTS(j) { | 2252 FOR_UINT32_INPUTS(j) { |
2249 uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant; | 2253 uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant; |
2250 CHECK_EQ(expected, bt.call(*i, *j)); | 2254 CHECK_UINT32_EQ(expected, bt.call(*i, *j)); |
2251 } | 2255 } |
2252 } | 2256 } |
2253 } | 2257 } |
2254 { | 2258 { |
2255 FOR_UINT32_INPUTS(i) { | 2259 FOR_UINT32_INPUTS(i) { |
2256 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2260 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2257 MLabel blocka, blockb; | 2261 MLabel blocka, blockb; |
2258 m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)), | 2262 m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)), |
2259 m.Int32Constant(0)), | 2263 m.Int32Constant(0)), |
2260 &blocka, &blockb); | 2264 &blocka, &blockb); |
2261 m.Bind(&blocka); | 2265 m.Bind(&blocka); |
2262 m.Return(m.Int32Constant(constant)); | 2266 m.Return(m.Int32Constant(constant)); |
2263 m.Bind(&blockb); | 2267 m.Bind(&blockb); |
2264 m.Return(m.Int32Constant(0 - constant)); | 2268 m.Return(m.Int32Constant(0 - constant)); |
2265 FOR_UINT32_INPUTS(j) { | 2269 FOR_UINT32_INPUTS(j) { |
2266 uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant; | 2270 uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant; |
2267 CHECK_EQ(expected, m.Call(*j)); | 2271 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2268 } | 2272 } |
2269 } | 2273 } |
2270 } | 2274 } |
2271 { | 2275 { |
2272 FOR_UINT32_INPUTS(i) { | 2276 FOR_UINT32_INPUTS(i) { |
2273 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2277 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2274 MLabel blocka, blockb; | 2278 MLabel blocka, blockb; |
2275 m.Branch( | 2279 m.Branch( |
2276 m.Word32NotEqual(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)), | 2280 m.Word32NotEqual(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)), |
2277 m.Int32Constant(0)), | 2281 m.Int32Constant(0)), |
2278 &blocka, &blockb); | 2282 &blocka, &blockb); |
2279 m.Bind(&blocka); | 2283 m.Bind(&blocka); |
2280 m.Return(m.Int32Constant(constant)); | 2284 m.Return(m.Int32Constant(constant)); |
2281 m.Bind(&blockb); | 2285 m.Bind(&blockb); |
2282 m.Return(m.Int32Constant(0 - constant)); | 2286 m.Return(m.Int32Constant(0 - constant)); |
2283 FOR_UINT32_INPUTS(j) { | 2287 FOR_UINT32_INPUTS(j) { |
2284 uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant; | 2288 uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant; |
2285 CHECK_EQ(expected, m.Call(*j)); | 2289 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2286 } | 2290 } |
2287 } | 2291 } |
2288 } | 2292 } |
2289 { | 2293 { |
2290 RawMachineAssemblerTester<void> m; | 2294 RawMachineAssemblerTester<void> m; |
2291 const Operator* shops[] = {m.machine()->Word32Sar(), | 2295 const Operator* shops[] = {m.machine()->Word32Sar(), |
2292 m.machine()->Word32Shl(), | 2296 m.machine()->Word32Shl(), |
2293 m.machine()->Word32Shr()}; | 2297 m.machine()->Word32Shr()}; |
2294 for (size_t n = 0; n < arraysize(shops); n++) { | 2298 for (size_t n = 0; n < arraysize(shops); n++) { |
2295 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, | 2299 RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32, |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2331 } | 2335 } |
2332 | 2336 |
2333 | 2337 |
2334 TEST(RunWord32ShlP) { | 2338 TEST(RunWord32ShlP) { |
2335 { | 2339 { |
2336 FOR_UINT32_SHIFTS(shift) { | 2340 FOR_UINT32_SHIFTS(shift) { |
2337 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2341 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2338 m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift))); | 2342 m.Return(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift))); |
2339 FOR_UINT32_INPUTS(j) { | 2343 FOR_UINT32_INPUTS(j) { |
2340 uint32_t expected = *j << shift; | 2344 uint32_t expected = *j << shift; |
2341 CHECK_EQ(expected, m.Call(*j)); | 2345 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2342 } | 2346 } |
2343 } | 2347 } |
2344 } | 2348 } |
2345 { | 2349 { |
2346 RawMachineAssemblerTester<int32_t> m; | 2350 RawMachineAssemblerTester<int32_t> m; |
2347 Uint32BinopTester bt(&m); | 2351 Uint32BinopTester bt(&m); |
2348 bt.AddReturn(m.Word32Shl(bt.param0, bt.param1)); | 2352 bt.AddReturn(m.Word32Shl(bt.param0, bt.param1)); |
2349 FOR_UINT32_INPUTS(i) { | 2353 FOR_UINT32_INPUTS(i) { |
2350 FOR_UINT32_SHIFTS(shift) { | 2354 FOR_UINT32_SHIFTS(shift) { |
2351 uint32_t expected = *i << shift; | 2355 uint32_t expected = *i << shift; |
2352 CHECK_EQ(expected, bt.call(*i, shift)); | 2356 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2353 } | 2357 } |
2354 } | 2358 } |
2355 } | 2359 } |
2356 } | 2360 } |
2357 | 2361 |
2358 | 2362 |
2359 TEST(RunWord32ShlInComparison) { | 2363 TEST(RunWord32ShlInComparison) { |
2360 { | 2364 { |
2361 RawMachineAssemblerTester<int32_t> m; | 2365 RawMachineAssemblerTester<int32_t> m; |
2362 Uint32BinopTester bt(&m); | 2366 Uint32BinopTester bt(&m); |
2363 bt.AddReturn( | 2367 bt.AddReturn( |
2364 m.Word32Equal(m.Word32Shl(bt.param0, bt.param1), m.Int32Constant(0))); | 2368 m.Word32Equal(m.Word32Shl(bt.param0, bt.param1), m.Int32Constant(0))); |
2365 FOR_UINT32_INPUTS(i) { | 2369 FOR_UINT32_INPUTS(i) { |
2366 FOR_UINT32_SHIFTS(shift) { | 2370 FOR_UINT32_SHIFTS(shift) { |
2367 uint32_t expected = 0 == (*i << shift); | 2371 uint32_t expected = 0 == (*i << shift); |
2368 CHECK_EQ(expected, bt.call(*i, shift)); | 2372 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2369 } | 2373 } |
2370 } | 2374 } |
2371 } | 2375 } |
2372 { | 2376 { |
2373 RawMachineAssemblerTester<int32_t> m; | 2377 RawMachineAssemblerTester<int32_t> m; |
2374 Uint32BinopTester bt(&m); | 2378 Uint32BinopTester bt(&m); |
2375 bt.AddReturn( | 2379 bt.AddReturn( |
2376 m.Word32Equal(m.Int32Constant(0), m.Word32Shl(bt.param0, bt.param1))); | 2380 m.Word32Equal(m.Int32Constant(0), m.Word32Shl(bt.param0, bt.param1))); |
2377 FOR_UINT32_INPUTS(i) { | 2381 FOR_UINT32_INPUTS(i) { |
2378 FOR_UINT32_SHIFTS(shift) { | 2382 FOR_UINT32_SHIFTS(shift) { |
2379 uint32_t expected = 0 == (*i << shift); | 2383 uint32_t expected = 0 == (*i << shift); |
2380 CHECK_EQ(expected, bt.call(*i, shift)); | 2384 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2381 } | 2385 } |
2382 } | 2386 } |
2383 } | 2387 } |
2384 { | 2388 { |
2385 FOR_UINT32_SHIFTS(shift) { | 2389 FOR_UINT32_SHIFTS(shift) { |
2386 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2390 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2387 m.Return( | 2391 m.Return( |
2388 m.Word32Equal(m.Int32Constant(0), | 2392 m.Word32Equal(m.Int32Constant(0), |
2389 m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)))); | 2393 m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)))); |
2390 FOR_UINT32_INPUTS(i) { | 2394 FOR_UINT32_INPUTS(i) { |
2391 uint32_t expected = 0 == (*i << shift); | 2395 uint32_t expected = 0 == (*i << shift); |
2392 CHECK_EQ(expected, m.Call(*i)); | 2396 CHECK_UINT32_EQ(expected, m.Call(*i)); |
2393 } | 2397 } |
2394 } | 2398 } |
2395 } | 2399 } |
2396 { | 2400 { |
2397 FOR_UINT32_SHIFTS(shift) { | 2401 FOR_UINT32_SHIFTS(shift) { |
2398 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2402 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2399 m.Return( | 2403 m.Return( |
2400 m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)), | 2404 m.Word32Equal(m.Word32Shl(m.Parameter(0), m.Int32Constant(shift)), |
2401 m.Int32Constant(0))); | 2405 m.Int32Constant(0))); |
2402 FOR_UINT32_INPUTS(i) { | 2406 FOR_UINT32_INPUTS(i) { |
2403 uint32_t expected = 0 == (*i << shift); | 2407 uint32_t expected = 0 == (*i << shift); |
2404 CHECK_EQ(expected, m.Call(*i)); | 2408 CHECK_UINT32_EQ(expected, m.Call(*i)); |
2405 } | 2409 } |
2406 } | 2410 } |
2407 } | 2411 } |
2408 } | 2412 } |
2409 | 2413 |
2410 | 2414 |
2411 TEST(RunWord32ShrP) { | 2415 TEST(RunWord32ShrP) { |
2412 { | 2416 { |
2413 FOR_UINT32_SHIFTS(shift) { | 2417 FOR_UINT32_SHIFTS(shift) { |
2414 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2418 RawMachineAssemblerTester<uint32_t> m(kMachUint32); |
2415 m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift))); | 2419 m.Return(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift))); |
2416 FOR_UINT32_INPUTS(j) { | 2420 FOR_UINT32_INPUTS(j) { |
2417 uint32_t expected = *j >> shift; | 2421 uint32_t expected = *j >> shift; |
2418 CHECK_EQ(expected, m.Call(*j)); | 2422 CHECK_UINT32_EQ(expected, m.Call(*j)); |
2419 } | 2423 } |
2420 } | 2424 } |
2421 } | 2425 } |
2422 { | 2426 { |
2423 RawMachineAssemblerTester<int32_t> m; | 2427 RawMachineAssemblerTester<int32_t> m; |
2424 Uint32BinopTester bt(&m); | 2428 Uint32BinopTester bt(&m); |
2425 bt.AddReturn(m.Word32Shr(bt.param0, bt.param1)); | 2429 bt.AddReturn(m.Word32Shr(bt.param0, bt.param1)); |
2426 FOR_UINT32_INPUTS(i) { | 2430 FOR_UINT32_INPUTS(i) { |
2427 FOR_UINT32_SHIFTS(shift) { | 2431 FOR_UINT32_SHIFTS(shift) { |
2428 uint32_t expected = *i >> shift; | 2432 uint32_t expected = *i >> shift; |
2429 CHECK_EQ(expected, bt.call(*i, shift)); | 2433 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2430 } | 2434 } |
2431 } | 2435 } |
2432 CHECK_EQ(0x00010000u, bt.call(0x80000000, 15)); | 2436 CHECK_EQ(0x00010000, bt.call(0x80000000, 15)); |
2433 } | 2437 } |
2434 } | 2438 } |
2435 | 2439 |
2436 | 2440 |
2437 TEST(RunWord32ShrInComparison) { | 2441 TEST(RunWord32ShrInComparison) { |
2438 { | 2442 { |
2439 RawMachineAssemblerTester<int32_t> m; | 2443 RawMachineAssemblerTester<int32_t> m; |
2440 Uint32BinopTester bt(&m); | 2444 Uint32BinopTester bt(&m); |
2441 bt.AddReturn( | 2445 bt.AddReturn( |
2442 m.Word32Equal(m.Word32Shr(bt.param0, bt.param1), m.Int32Constant(0))); | 2446 m.Word32Equal(m.Word32Shr(bt.param0, bt.param1), m.Int32Constant(0))); |
2443 FOR_UINT32_INPUTS(i) { | 2447 FOR_UINT32_INPUTS(i) { |
2444 FOR_UINT32_SHIFTS(shift) { | 2448 FOR_UINT32_SHIFTS(shift) { |
2445 uint32_t expected = 0 == (*i >> shift); | 2449 uint32_t expected = 0 == (*i >> shift); |
2446 CHECK_EQ(expected, bt.call(*i, shift)); | 2450 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2447 } | 2451 } |
2448 } | 2452 } |
2449 } | 2453 } |
2450 { | 2454 { |
2451 RawMachineAssemblerTester<int32_t> m; | 2455 RawMachineAssemblerTester<int32_t> m; |
2452 Uint32BinopTester bt(&m); | 2456 Uint32BinopTester bt(&m); |
2453 bt.AddReturn( | 2457 bt.AddReturn( |
2454 m.Word32Equal(m.Int32Constant(0), m.Word32Shr(bt.param0, bt.param1))); | 2458 m.Word32Equal(m.Int32Constant(0), m.Word32Shr(bt.param0, bt.param1))); |
2455 FOR_UINT32_INPUTS(i) { | 2459 FOR_UINT32_INPUTS(i) { |
2456 FOR_UINT32_SHIFTS(shift) { | 2460 FOR_UINT32_SHIFTS(shift) { |
2457 uint32_t expected = 0 == (*i >> shift); | 2461 uint32_t expected = 0 == (*i >> shift); |
2458 CHECK_EQ(expected, bt.call(*i, shift)); | 2462 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2459 } | 2463 } |
2460 } | 2464 } |
2461 } | 2465 } |
2462 { | 2466 { |
2463 FOR_UINT32_SHIFTS(shift) { | 2467 FOR_UINT32_SHIFTS(shift) { |
2464 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2468 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2465 m.Return( | 2469 m.Return( |
2466 m.Word32Equal(m.Int32Constant(0), | 2470 m.Word32Equal(m.Int32Constant(0), |
2467 m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)))); | 2471 m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)))); |
2468 FOR_UINT32_INPUTS(i) { | 2472 FOR_UINT32_INPUTS(i) { |
2469 uint32_t expected = 0 == (*i >> shift); | 2473 uint32_t expected = 0 == (*i >> shift); |
2470 CHECK_EQ(expected, m.Call(*i)); | 2474 CHECK_UINT32_EQ(expected, m.Call(*i)); |
2471 } | 2475 } |
2472 } | 2476 } |
2473 } | 2477 } |
2474 { | 2478 { |
2475 FOR_UINT32_SHIFTS(shift) { | 2479 FOR_UINT32_SHIFTS(shift) { |
2476 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2480 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2477 m.Return( | 2481 m.Return( |
2478 m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)), | 2482 m.Word32Equal(m.Word32Shr(m.Parameter(0), m.Int32Constant(shift)), |
2479 m.Int32Constant(0))); | 2483 m.Int32Constant(0))); |
2480 FOR_UINT32_INPUTS(i) { | 2484 FOR_UINT32_INPUTS(i) { |
2481 uint32_t expected = 0 == (*i >> shift); | 2485 uint32_t expected = 0 == (*i >> shift); |
2482 CHECK_EQ(expected, m.Call(*i)); | 2486 CHECK_UINT32_EQ(expected, m.Call(*i)); |
2483 } | 2487 } |
2484 } | 2488 } |
2485 } | 2489 } |
2486 } | 2490 } |
2487 | 2491 |
2488 | 2492 |
2489 TEST(RunWord32SarP) { | 2493 TEST(RunWord32SarP) { |
2490 { | 2494 { |
2491 FOR_INT32_SHIFTS(shift) { | 2495 FOR_INT32_SHIFTS(shift) { |
2492 RawMachineAssemblerTester<int32_t> m(kMachInt32); | 2496 RawMachineAssemblerTester<int32_t> m(kMachInt32); |
2493 m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift))); | 2497 m.Return(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift))); |
2494 FOR_INT32_INPUTS(j) { | 2498 FOR_INT32_INPUTS(j) { |
2495 int32_t expected = *j >> shift; | 2499 int32_t expected = *j >> shift; |
2496 CHECK_EQ(expected, m.Call(*j)); | 2500 CHECK_EQ(expected, m.Call(*j)); |
2497 } | 2501 } |
2498 } | 2502 } |
2499 } | 2503 } |
2500 { | 2504 { |
2501 RawMachineAssemblerTester<int32_t> m; | 2505 RawMachineAssemblerTester<int32_t> m; |
2502 Int32BinopTester bt(&m); | 2506 Int32BinopTester bt(&m); |
2503 bt.AddReturn(m.Word32Sar(bt.param0, bt.param1)); | 2507 bt.AddReturn(m.Word32Sar(bt.param0, bt.param1)); |
2504 FOR_INT32_INPUTS(i) { | 2508 FOR_INT32_INPUTS(i) { |
2505 FOR_INT32_SHIFTS(shift) { | 2509 FOR_INT32_SHIFTS(shift) { |
2506 int32_t expected = *i >> shift; | 2510 int32_t expected = *i >> shift; |
2507 CHECK_EQ(expected, bt.call(*i, shift)); | 2511 CHECK_EQ(expected, bt.call(*i, shift)); |
2508 } | 2512 } |
2509 } | 2513 } |
2510 CHECK_EQ(bit_cast<int32_t>(0xFFFF0000), bt.call(0x80000000, 15)); | 2514 CHECK_EQ(0xFFFF0000, bt.call(0x80000000, 15)); |
2511 } | 2515 } |
2512 } | 2516 } |
2513 | 2517 |
2514 | 2518 |
2515 TEST(RunWord32SarInComparison) { | 2519 TEST(RunWord32SarInComparison) { |
2516 { | 2520 { |
2517 RawMachineAssemblerTester<int32_t> m; | 2521 RawMachineAssemblerTester<int32_t> m; |
2518 Int32BinopTester bt(&m); | 2522 Int32BinopTester bt(&m); |
2519 bt.AddReturn( | 2523 bt.AddReturn( |
2520 m.Word32Equal(m.Word32Sar(bt.param0, bt.param1), m.Int32Constant(0))); | 2524 m.Word32Equal(m.Word32Sar(bt.param0, bt.param1), m.Int32Constant(0))); |
(...skipping 28 matching lines...) Expand all Loading... |
2549 } | 2553 } |
2550 } | 2554 } |
2551 } | 2555 } |
2552 { | 2556 { |
2553 FOR_INT32_SHIFTS(shift) { | 2557 FOR_INT32_SHIFTS(shift) { |
2554 RawMachineAssemblerTester<int32_t> m(kMachInt32); | 2558 RawMachineAssemblerTester<int32_t> m(kMachInt32); |
2555 m.Return( | 2559 m.Return( |
2556 m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)), | 2560 m.Word32Equal(m.Word32Sar(m.Parameter(0), m.Int32Constant(shift)), |
2557 m.Int32Constant(0))); | 2561 m.Int32Constant(0))); |
2558 FOR_INT32_INPUTS(i) { | 2562 FOR_INT32_INPUTS(i) { |
2559 int32_t expected = 0 == (*i >> shift); | 2563 uint32_t expected = 0 == (*i >> shift); |
2560 CHECK_EQ(expected, m.Call(*i)); | 2564 CHECK_EQ(expected, m.Call(*i)); |
2561 } | 2565 } |
2562 } | 2566 } |
2563 } | 2567 } |
2564 } | 2568 } |
2565 | 2569 |
2566 | 2570 |
2567 TEST(RunWord32RorP) { | 2571 TEST(RunWord32RorP) { |
2568 { | 2572 { |
2569 FOR_UINT32_SHIFTS(shift) { | 2573 FOR_UINT32_SHIFTS(shift) { |
2570 RawMachineAssemblerTester<int32_t> m(kMachUint32); | 2574 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2571 m.Return(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift))); | 2575 m.Return(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift))); |
2572 FOR_UINT32_INPUTS(j) { | 2576 FOR_UINT32_INPUTS(j) { |
2573 int32_t expected = bits::RotateRight32(*j, shift); | 2577 int32_t expected = bits::RotateRight32(*j, shift); |
2574 CHECK_EQ(expected, m.Call(*j)); | 2578 CHECK_EQ(expected, m.Call(*j)); |
2575 } | 2579 } |
2576 } | 2580 } |
2577 } | 2581 } |
2578 { | 2582 { |
2579 RawMachineAssemblerTester<int32_t> m; | 2583 RawMachineAssemblerTester<int32_t> m; |
2580 Uint32BinopTester bt(&m); | 2584 Uint32BinopTester bt(&m); |
2581 bt.AddReturn(m.Word32Ror(bt.param0, bt.param1)); | 2585 bt.AddReturn(m.Word32Ror(bt.param0, bt.param1)); |
2582 FOR_UINT32_INPUTS(i) { | 2586 FOR_UINT32_INPUTS(i) { |
2583 FOR_UINT32_SHIFTS(shift) { | 2587 FOR_UINT32_SHIFTS(shift) { |
2584 uint32_t expected = bits::RotateRight32(*i, shift); | 2588 uint32_t expected = bits::RotateRight32(*i, shift); |
2585 CHECK_EQ(expected, bt.call(*i, shift)); | 2589 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2586 } | 2590 } |
2587 } | 2591 } |
2588 } | 2592 } |
2589 } | 2593 } |
2590 | 2594 |
2591 | 2595 |
2592 TEST(RunWord32RorInComparison) { | 2596 TEST(RunWord32RorInComparison) { |
2593 { | 2597 { |
2594 RawMachineAssemblerTester<int32_t> m; | 2598 RawMachineAssemblerTester<int32_t> m; |
2595 Uint32BinopTester bt(&m); | 2599 Uint32BinopTester bt(&m); |
2596 bt.AddReturn( | 2600 bt.AddReturn( |
2597 m.Word32Equal(m.Word32Ror(bt.param0, bt.param1), m.Int32Constant(0))); | 2601 m.Word32Equal(m.Word32Ror(bt.param0, bt.param1), m.Int32Constant(0))); |
2598 FOR_UINT32_INPUTS(i) { | 2602 FOR_UINT32_INPUTS(i) { |
2599 FOR_UINT32_SHIFTS(shift) { | 2603 FOR_UINT32_SHIFTS(shift) { |
2600 uint32_t expected = 0 == bits::RotateRight32(*i, shift); | 2604 uint32_t expected = 0 == bits::RotateRight32(*i, shift); |
2601 CHECK_EQ(expected, bt.call(*i, shift)); | 2605 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2602 } | 2606 } |
2603 } | 2607 } |
2604 } | 2608 } |
2605 { | 2609 { |
2606 RawMachineAssemblerTester<int32_t> m; | 2610 RawMachineAssemblerTester<int32_t> m; |
2607 Uint32BinopTester bt(&m); | 2611 Uint32BinopTester bt(&m); |
2608 bt.AddReturn( | 2612 bt.AddReturn( |
2609 m.Word32Equal(m.Int32Constant(0), m.Word32Ror(bt.param0, bt.param1))); | 2613 m.Word32Equal(m.Int32Constant(0), m.Word32Ror(bt.param0, bt.param1))); |
2610 FOR_UINT32_INPUTS(i) { | 2614 FOR_UINT32_INPUTS(i) { |
2611 FOR_UINT32_SHIFTS(shift) { | 2615 FOR_UINT32_SHIFTS(shift) { |
2612 uint32_t expected = 0 == bits::RotateRight32(*i, shift); | 2616 uint32_t expected = 0 == bits::RotateRight32(*i, shift); |
2613 CHECK_EQ(expected, bt.call(*i, shift)); | 2617 CHECK_UINT32_EQ(expected, bt.call(*i, shift)); |
2614 } | 2618 } |
2615 } | 2619 } |
2616 } | 2620 } |
2617 { | 2621 { |
2618 FOR_UINT32_SHIFTS(shift) { | 2622 FOR_UINT32_SHIFTS(shift) { |
2619 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2623 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2620 m.Return( | 2624 m.Return( |
2621 m.Word32Equal(m.Int32Constant(0), | 2625 m.Word32Equal(m.Int32Constant(0), |
2622 m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)))); | 2626 m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)))); |
2623 FOR_UINT32_INPUTS(i) { | 2627 FOR_UINT32_INPUTS(i) { |
2624 uint32_t expected = 0 == bits::RotateRight32(*i, shift); | 2628 uint32_t expected = 0 == bits::RotateRight32(*i, shift); |
2625 CHECK_EQ(expected, m.Call(*i)); | 2629 CHECK_UINT32_EQ(expected, m.Call(*i)); |
2626 } | 2630 } |
2627 } | 2631 } |
2628 } | 2632 } |
2629 { | 2633 { |
2630 FOR_UINT32_SHIFTS(shift) { | 2634 FOR_UINT32_SHIFTS(shift) { |
2631 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 2635 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
2632 m.Return( | 2636 m.Return( |
2633 m.Word32Equal(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)), | 2637 m.Word32Equal(m.Word32Ror(m.Parameter(0), m.Int32Constant(shift)), |
2634 m.Int32Constant(0))); | 2638 m.Int32Constant(0))); |
2635 FOR_UINT32_INPUTS(i) { | 2639 FOR_UINT32_INPUTS(i) { |
2636 uint32_t expected = 0 == bits::RotateRight32(*i, shift); | 2640 uint32_t expected = 0 == bits::RotateRight32(*i, shift); |
2637 CHECK_EQ(expected, m.Call(*i)); | 2641 CHECK_UINT32_EQ(expected, m.Call(*i)); |
2638 } | 2642 } |
2639 } | 2643 } |
2640 } | 2644 } |
2641 } | 2645 } |
2642 | 2646 |
2643 | 2647 |
2644 TEST(RunWord32NotP) { | 2648 TEST(RunWord32NotP) { |
2645 RawMachineAssemblerTester<int32_t> m(kMachInt32); | 2649 RawMachineAssemblerTester<int32_t> m(kMachInt32); |
2646 m.Return(m.Word32Not(m.Parameter(0))); | 2650 m.Return(m.Word32Not(m.Parameter(0))); |
2647 FOR_INT32_INPUTS(i) { | 2651 FOR_INT32_INPUTS(i) { |
(...skipping 305 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2953 | 2957 |
2954 TEST(RunFloat64AddP) { | 2958 TEST(RunFloat64AddP) { |
2955 RawMachineAssemblerTester<int32_t> m; | 2959 RawMachineAssemblerTester<int32_t> m; |
2956 Float64BinopTester bt(&m); | 2960 Float64BinopTester bt(&m); |
2957 | 2961 |
2958 bt.AddReturn(m.Float64Add(bt.param0, bt.param1)); | 2962 bt.AddReturn(m.Float64Add(bt.param0, bt.param1)); |
2959 | 2963 |
2960 FOR_FLOAT64_INPUTS(pl) { | 2964 FOR_FLOAT64_INPUTS(pl) { |
2961 FOR_FLOAT64_INPUTS(pr) { | 2965 FOR_FLOAT64_INPUTS(pr) { |
2962 double expected = *pl + *pr; | 2966 double expected = *pl + *pr; |
2963 CheckDoubleEq(expected, bt.call(*pl, *pr)); | 2967 CHECK_EQ(expected, bt.call(*pl, *pr)); |
2964 } | 2968 } |
2965 } | 2969 } |
2966 } | 2970 } |
2967 | 2971 |
2968 | 2972 |
2969 TEST(RunFloat64SubP) { | 2973 TEST(RunFloat64SubP) { |
2970 RawMachineAssemblerTester<int32_t> m; | 2974 RawMachineAssemblerTester<int32_t> m; |
2971 Float64BinopTester bt(&m); | 2975 Float64BinopTester bt(&m); |
2972 | 2976 |
2973 bt.AddReturn(m.Float64Sub(bt.param0, bt.param1)); | 2977 bt.AddReturn(m.Float64Sub(bt.param0, bt.param1)); |
2974 | 2978 |
2975 FOR_FLOAT64_INPUTS(pl) { | 2979 FOR_FLOAT64_INPUTS(pl) { |
2976 FOR_FLOAT64_INPUTS(pr) { | 2980 FOR_FLOAT64_INPUTS(pr) { |
2977 double expected = *pl - *pr; | 2981 double expected = *pl - *pr; |
2978 CheckDoubleEq(expected, bt.call(*pl, *pr)); | 2982 CHECK_EQ(expected, bt.call(*pl, *pr)); |
2979 } | 2983 } |
2980 } | 2984 } |
2981 } | 2985 } |
2982 | 2986 |
2983 | 2987 |
2984 TEST(RunFloat64SubImm1) { | 2988 TEST(RunFloat64SubImm1) { |
2985 double input = 0.0; | 2989 double input = 0.0; |
2986 double output = 0.0; | 2990 double output = 0.0; |
2987 | 2991 |
2988 FOR_FLOAT64_INPUTS(i) { | 2992 FOR_FLOAT64_INPUTS(i) { |
2989 RawMachineAssemblerTester<int32_t> m; | 2993 RawMachineAssemblerTester<int32_t> m; |
2990 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); | 2994 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); |
2991 Node* t1 = m.Float64Sub(m.Float64Constant(*i), t0); | 2995 Node* t1 = m.Float64Sub(m.Float64Constant(*i), t0); |
2992 m.StoreToPointer(&output, kMachFloat64, t1); | 2996 m.StoreToPointer(&output, kMachFloat64, t1); |
2993 m.Return(m.Int32Constant(0)); | 2997 m.Return(m.Int32Constant(0)); |
2994 FOR_FLOAT64_INPUTS(j) { | 2998 FOR_FLOAT64_INPUTS(j) { |
2995 input = *j; | 2999 input = *j; |
2996 double expected = *i - input; | 3000 double expected = *i - input; |
2997 CHECK_EQ(0, m.Call()); | 3001 CHECK_EQ(0, m.Call()); |
2998 CheckDoubleEq(expected, output); | 3002 CHECK_EQ(expected, output); |
2999 } | 3003 } |
3000 } | 3004 } |
3001 } | 3005 } |
3002 | 3006 |
3003 | 3007 |
3004 TEST(RunFloat64SubImm2) { | 3008 TEST(RunFloat64SubImm2) { |
3005 double input = 0.0; | 3009 double input = 0.0; |
3006 double output = 0.0; | 3010 double output = 0.0; |
3007 | 3011 |
3008 FOR_FLOAT64_INPUTS(i) { | 3012 FOR_FLOAT64_INPUTS(i) { |
3009 RawMachineAssemblerTester<int32_t> m; | 3013 RawMachineAssemblerTester<int32_t> m; |
3010 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); | 3014 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); |
3011 Node* t1 = m.Float64Sub(t0, m.Float64Constant(*i)); | 3015 Node* t1 = m.Float64Sub(t0, m.Float64Constant(*i)); |
3012 m.StoreToPointer(&output, kMachFloat64, t1); | 3016 m.StoreToPointer(&output, kMachFloat64, t1); |
3013 m.Return(m.Int32Constant(0)); | 3017 m.Return(m.Int32Constant(0)); |
3014 FOR_FLOAT64_INPUTS(j) { | 3018 FOR_FLOAT64_INPUTS(j) { |
3015 input = *j; | 3019 input = *j; |
3016 double expected = input - *i; | 3020 double expected = input - *i; |
3017 CHECK_EQ(0, m.Call()); | 3021 CHECK_EQ(0, m.Call()); |
3018 CheckDoubleEq(expected, output); | 3022 CHECK_EQ(expected, output); |
3019 } | 3023 } |
3020 } | 3024 } |
3021 } | 3025 } |
3022 | 3026 |
3023 | 3027 |
3024 TEST(RunFloat64MulP) { | 3028 TEST(RunFloat64MulP) { |
3025 RawMachineAssemblerTester<int32_t> m; | 3029 RawMachineAssemblerTester<int32_t> m; |
3026 Float64BinopTester bt(&m); | 3030 Float64BinopTester bt(&m); |
3027 | 3031 |
3028 bt.AddReturn(m.Float64Mul(bt.param0, bt.param1)); | 3032 bt.AddReturn(m.Float64Mul(bt.param0, bt.param1)); |
3029 | 3033 |
3030 FOR_FLOAT64_INPUTS(pl) { | 3034 FOR_FLOAT64_INPUTS(pl) { |
3031 FOR_FLOAT64_INPUTS(pr) { | 3035 FOR_FLOAT64_INPUTS(pr) { |
3032 double expected = *pl * *pr; | 3036 double expected = *pl * *pr; |
3033 CheckDoubleEq(expected, bt.call(*pl, *pr)); | 3037 CHECK_EQ(expected, bt.call(*pl, *pr)); |
3034 } | 3038 } |
3035 } | 3039 } |
3036 } | 3040 } |
3037 | 3041 |
3038 | 3042 |
3039 TEST(RunFloat64MulAndFloat64AddP) { | 3043 TEST(RunFloat64MulAndFloat64AddP) { |
3040 double input_a = 0.0; | 3044 double input_a = 0.0; |
3041 double input_b = 0.0; | 3045 double input_b = 0.0; |
3042 double input_c = 0.0; | 3046 double input_c = 0.0; |
3043 double output = 0.0; | 3047 double output = 0.0; |
3044 | 3048 |
3045 { | 3049 { |
3046 RawMachineAssemblerTester<int32_t> m; | 3050 RawMachineAssemblerTester<int32_t> m; |
3047 Node* a = m.LoadFromPointer(&input_a, kMachFloat64); | 3051 Node* a = m.LoadFromPointer(&input_a, kMachFloat64); |
3048 Node* b = m.LoadFromPointer(&input_b, kMachFloat64); | 3052 Node* b = m.LoadFromPointer(&input_b, kMachFloat64); |
3049 Node* c = m.LoadFromPointer(&input_c, kMachFloat64); | 3053 Node* c = m.LoadFromPointer(&input_c, kMachFloat64); |
3050 m.StoreToPointer(&output, kMachFloat64, | 3054 m.StoreToPointer(&output, kMachFloat64, |
3051 m.Float64Add(m.Float64Mul(a, b), c)); | 3055 m.Float64Add(m.Float64Mul(a, b), c)); |
3052 m.Return(m.Int32Constant(0)); | 3056 m.Return(m.Int32Constant(0)); |
3053 FOR_FLOAT64_INPUTS(i) { | 3057 FOR_FLOAT64_INPUTS(i) { |
3054 FOR_FLOAT64_INPUTS(j) { | 3058 FOR_FLOAT64_INPUTS(j) { |
3055 FOR_FLOAT64_INPUTS(k) { | 3059 FOR_FLOAT64_INPUTS(k) { |
3056 input_a = *i; | 3060 input_a = *i; |
3057 input_b = *j; | 3061 input_b = *j; |
3058 input_c = *k; | 3062 input_c = *k; |
3059 volatile double temp = input_a * input_b; | 3063 volatile double temp = input_a * input_b; |
3060 volatile double expected = temp + input_c; | 3064 volatile double expected = temp + input_c; |
3061 CHECK_EQ(0, m.Call()); | 3065 CHECK_EQ(0, m.Call()); |
3062 CheckDoubleEq(expected, output); | 3066 CHECK_EQ(expected, output); |
3063 } | 3067 } |
3064 } | 3068 } |
3065 } | 3069 } |
3066 } | 3070 } |
3067 { | 3071 { |
3068 RawMachineAssemblerTester<int32_t> m; | 3072 RawMachineAssemblerTester<int32_t> m; |
3069 Node* a = m.LoadFromPointer(&input_a, kMachFloat64); | 3073 Node* a = m.LoadFromPointer(&input_a, kMachFloat64); |
3070 Node* b = m.LoadFromPointer(&input_b, kMachFloat64); | 3074 Node* b = m.LoadFromPointer(&input_b, kMachFloat64); |
3071 Node* c = m.LoadFromPointer(&input_c, kMachFloat64); | 3075 Node* c = m.LoadFromPointer(&input_c, kMachFloat64); |
3072 m.StoreToPointer(&output, kMachFloat64, | 3076 m.StoreToPointer(&output, kMachFloat64, |
3073 m.Float64Add(a, m.Float64Mul(b, c))); | 3077 m.Float64Add(a, m.Float64Mul(b, c))); |
3074 m.Return(m.Int32Constant(0)); | 3078 m.Return(m.Int32Constant(0)); |
3075 FOR_FLOAT64_INPUTS(i) { | 3079 FOR_FLOAT64_INPUTS(i) { |
3076 FOR_FLOAT64_INPUTS(j) { | 3080 FOR_FLOAT64_INPUTS(j) { |
3077 FOR_FLOAT64_INPUTS(k) { | 3081 FOR_FLOAT64_INPUTS(k) { |
3078 input_a = *i; | 3082 input_a = *i; |
3079 input_b = *j; | 3083 input_b = *j; |
3080 input_c = *k; | 3084 input_c = *k; |
3081 volatile double temp = input_b * input_c; | 3085 volatile double temp = input_b * input_c; |
3082 volatile double expected = input_a + temp; | 3086 volatile double expected = input_a + temp; |
3083 CHECK_EQ(0, m.Call()); | 3087 CHECK_EQ(0, m.Call()); |
3084 CheckDoubleEq(expected, output); | 3088 CHECK_EQ(expected, output); |
3085 } | 3089 } |
3086 } | 3090 } |
3087 } | 3091 } |
3088 } | 3092 } |
3089 } | 3093 } |
3090 | 3094 |
3091 | 3095 |
3092 TEST(RunFloat64MulAndFloat64SubP) { | 3096 TEST(RunFloat64MulAndFloat64SubP) { |
3093 double input_a = 0.0; | 3097 double input_a = 0.0; |
3094 double input_b = 0.0; | 3098 double input_b = 0.0; |
3095 double input_c = 0.0; | 3099 double input_c = 0.0; |
3096 double output = 0.0; | 3100 double output = 0.0; |
3097 | 3101 |
3098 RawMachineAssemblerTester<int32_t> m; | 3102 RawMachineAssemblerTester<int32_t> m; |
3099 Node* a = m.LoadFromPointer(&input_a, kMachFloat64); | 3103 Node* a = m.LoadFromPointer(&input_a, kMachFloat64); |
3100 Node* b = m.LoadFromPointer(&input_b, kMachFloat64); | 3104 Node* b = m.LoadFromPointer(&input_b, kMachFloat64); |
3101 Node* c = m.LoadFromPointer(&input_c, kMachFloat64); | 3105 Node* c = m.LoadFromPointer(&input_c, kMachFloat64); |
3102 m.StoreToPointer(&output, kMachFloat64, m.Float64Sub(a, m.Float64Mul(b, c))); | 3106 m.StoreToPointer(&output, kMachFloat64, m.Float64Sub(a, m.Float64Mul(b, c))); |
3103 m.Return(m.Int32Constant(0)); | 3107 m.Return(m.Int32Constant(0)); |
3104 | 3108 |
3105 FOR_FLOAT64_INPUTS(i) { | 3109 FOR_FLOAT64_INPUTS(i) { |
3106 FOR_FLOAT64_INPUTS(j) { | 3110 FOR_FLOAT64_INPUTS(j) { |
3107 FOR_FLOAT64_INPUTS(k) { | 3111 FOR_FLOAT64_INPUTS(k) { |
3108 input_a = *i; | 3112 input_a = *i; |
3109 input_b = *j; | 3113 input_b = *j; |
3110 input_c = *k; | 3114 input_c = *k; |
3111 volatile double temp = input_b * input_c; | 3115 volatile double temp = input_b * input_c; |
3112 volatile double expected = input_a - temp; | 3116 volatile double expected = input_a - temp; |
3113 CHECK_EQ(0, m.Call()); | 3117 CHECK_EQ(0, m.Call()); |
3114 CheckDoubleEq(expected, output); | 3118 CHECK_EQ(expected, output); |
3115 } | 3119 } |
3116 } | 3120 } |
3117 } | 3121 } |
3118 } | 3122 } |
3119 | 3123 |
3120 | 3124 |
3121 TEST(RunFloat64MulImm) { | 3125 TEST(RunFloat64MulImm) { |
3122 double input = 0.0; | 3126 double input = 0.0; |
3123 double output = 0.0; | 3127 double output = 0.0; |
3124 | 3128 |
3125 { | 3129 { |
3126 FOR_FLOAT64_INPUTS(i) { | 3130 FOR_FLOAT64_INPUTS(i) { |
3127 RawMachineAssemblerTester<int32_t> m; | 3131 RawMachineAssemblerTester<int32_t> m; |
3128 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); | 3132 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); |
3129 Node* t1 = m.Float64Mul(m.Float64Constant(*i), t0); | 3133 Node* t1 = m.Float64Mul(m.Float64Constant(*i), t0); |
3130 m.StoreToPointer(&output, kMachFloat64, t1); | 3134 m.StoreToPointer(&output, kMachFloat64, t1); |
3131 m.Return(m.Int32Constant(0)); | 3135 m.Return(m.Int32Constant(0)); |
3132 FOR_FLOAT64_INPUTS(j) { | 3136 FOR_FLOAT64_INPUTS(j) { |
3133 input = *j; | 3137 input = *j; |
3134 double expected = *i * input; | 3138 double expected = *i * input; |
3135 CHECK_EQ(0, m.Call()); | 3139 CHECK_EQ(0, m.Call()); |
3136 CheckDoubleEq(expected, output); | 3140 CHECK_EQ(expected, output); |
3137 } | 3141 } |
3138 } | 3142 } |
3139 } | 3143 } |
3140 { | 3144 { |
3141 FOR_FLOAT64_INPUTS(i) { | 3145 FOR_FLOAT64_INPUTS(i) { |
3142 RawMachineAssemblerTester<int32_t> m; | 3146 RawMachineAssemblerTester<int32_t> m; |
3143 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); | 3147 Node* t0 = m.LoadFromPointer(&input, kMachFloat64); |
3144 Node* t1 = m.Float64Mul(t0, m.Float64Constant(*i)); | 3148 Node* t1 = m.Float64Mul(t0, m.Float64Constant(*i)); |
3145 m.StoreToPointer(&output, kMachFloat64, t1); | 3149 m.StoreToPointer(&output, kMachFloat64, t1); |
3146 m.Return(m.Int32Constant(0)); | 3150 m.Return(m.Int32Constant(0)); |
3147 FOR_FLOAT64_INPUTS(j) { | 3151 FOR_FLOAT64_INPUTS(j) { |
3148 input = *j; | 3152 input = *j; |
3149 double expected = input * *i; | 3153 double expected = input * *i; |
3150 CHECK_EQ(0, m.Call()); | 3154 CHECK_EQ(0, m.Call()); |
3151 CheckDoubleEq(expected, output); | 3155 CHECK_EQ(expected, output); |
3152 } | 3156 } |
3153 } | 3157 } |
3154 } | 3158 } |
3155 } | 3159 } |
3156 | 3160 |
3157 | 3161 |
3158 TEST(RunFloat64DivP) { | 3162 TEST(RunFloat64DivP) { |
3159 RawMachineAssemblerTester<int32_t> m; | 3163 RawMachineAssemblerTester<int32_t> m; |
3160 Float64BinopTester bt(&m); | 3164 Float64BinopTester bt(&m); |
3161 | 3165 |
3162 bt.AddReturn(m.Float64Div(bt.param0, bt.param1)); | 3166 bt.AddReturn(m.Float64Div(bt.param0, bt.param1)); |
3163 | 3167 |
3164 FOR_FLOAT64_INPUTS(pl) { | 3168 FOR_FLOAT64_INPUTS(pl) { |
3165 FOR_FLOAT64_INPUTS(pr) { | 3169 FOR_FLOAT64_INPUTS(pr) { |
3166 double expected = *pl / *pr; | 3170 double expected = *pl / *pr; |
3167 CheckDoubleEq(expected, bt.call(*pl, *pr)); | 3171 CHECK_EQ(expected, bt.call(*pl, *pr)); |
3168 } | 3172 } |
3169 } | 3173 } |
3170 } | 3174 } |
3171 | 3175 |
3172 | 3176 |
3173 TEST(RunFloat64ModP) { | 3177 TEST(RunFloat64ModP) { |
3174 RawMachineAssemblerTester<int32_t> m; | 3178 RawMachineAssemblerTester<int32_t> m; |
3175 Float64BinopTester bt(&m); | 3179 Float64BinopTester bt(&m); |
3176 | 3180 |
3177 bt.AddReturn(m.Float64Mod(bt.param0, bt.param1)); | 3181 bt.AddReturn(m.Float64Mod(bt.param0, bt.param1)); |
3178 | 3182 |
3179 FOR_FLOAT64_INPUTS(i) { | 3183 FOR_FLOAT64_INPUTS(i) { |
3180 FOR_FLOAT64_INPUTS(j) { | 3184 FOR_FLOAT64_INPUTS(j) { |
3181 double expected = modulo(*i, *j); | 3185 double expected = modulo(*i, *j); |
3182 double found = bt.call(*i, *j); | 3186 double found = bt.call(*i, *j); |
3183 CheckDoubleEq(expected, found); | 3187 CHECK_EQ(expected, found); |
3184 } | 3188 } |
3185 } | 3189 } |
3186 } | 3190 } |
3187 | 3191 |
3188 | 3192 |
3189 TEST(RunChangeInt32ToFloat64_A) { | 3193 TEST(RunChangeInt32ToFloat64_A) { |
3190 RawMachineAssemblerTester<int32_t> m; | 3194 RawMachineAssemblerTester<int32_t> m; |
3191 int32_t magic = 0x986234; | 3195 int32_t magic = 0x986234; |
3192 double result = 0; | 3196 double result = 0; |
3193 | 3197 |
(...skipping 18 matching lines...) Expand all Loading... |
3212 | 3216 |
3213 FOR_INT32_INPUTS(i) { | 3217 FOR_INT32_INPUTS(i) { |
3214 int32_t expect = *i; | 3218 int32_t expect = *i; |
3215 CHECK_EQ(expect, m.Call(expect)); | 3219 CHECK_EQ(expect, m.Call(expect)); |
3216 CHECK_EQ(static_cast<double>(expect), output); | 3220 CHECK_EQ(static_cast<double>(expect), output); |
3217 } | 3221 } |
3218 } | 3222 } |
3219 | 3223 |
3220 | 3224 |
3221 TEST(RunChangeUint32ToFloat64_B) { | 3225 TEST(RunChangeUint32ToFloat64_B) { |
3222 RawMachineAssemblerTester<uint32_t> m(kMachUint32); | 3226 RawMachineAssemblerTester<int32_t> m(kMachUint32); |
3223 double output = 0; | 3227 double output = 0; |
3224 | 3228 |
3225 Node* convert = m.ChangeUint32ToFloat64(m.Parameter(0)); | 3229 Node* convert = m.ChangeUint32ToFloat64(m.Parameter(0)); |
3226 m.Store(kMachFloat64, m.PointerConstant(&output), m.Int32Constant(0), | 3230 m.Store(kMachFloat64, m.PointerConstant(&output), m.Int32Constant(0), |
3227 convert); | 3231 convert); |
3228 m.Return(m.Parameter(0)); | 3232 m.Return(m.Parameter(0)); |
3229 | 3233 |
3230 FOR_UINT32_INPUTS(i) { | 3234 FOR_UINT32_INPUTS(i) { |
3231 uint32_t expect = *i; | 3235 uint32_t expect = *i; |
3232 CHECK_EQ(expect, m.Call(expect)); | 3236 CHECK_EQ(expect, m.Call(expect)); |
(...skipping 160 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3393 | 3397 |
3394 for (int i = 0; i < kNumInputs; i++) { | 3398 for (int i = 0; i < kNumInputs; i++) { |
3395 CHECK_EQ(result[i], 100 + i); | 3399 CHECK_EQ(result[i], 100 + i); |
3396 } | 3400 } |
3397 } | 3401 } |
3398 | 3402 |
3399 | 3403 |
3400 TEST(RunChangeFloat64ToUint32_spilled) { | 3404 TEST(RunChangeFloat64ToUint32_spilled) { |
3401 RawMachineAssemblerTester<uint32_t> m; | 3405 RawMachineAssemblerTester<uint32_t> m; |
3402 const int kNumInputs = 32; | 3406 const int kNumInputs = 32; |
3403 uint32_t magic = 0x786234; | 3407 int32_t magic = 0x786234; |
3404 double input[kNumInputs]; | 3408 double input[kNumInputs]; |
3405 uint32_t result[kNumInputs]; | 3409 uint32_t result[kNumInputs]; |
3406 Node* input_node[kNumInputs]; | 3410 Node* input_node[kNumInputs]; |
3407 | 3411 |
3408 for (int i = 0; i < kNumInputs; i++) { | 3412 for (int i = 0; i < kNumInputs; i++) { |
3409 input_node[i] = | 3413 input_node[i] = |
3410 m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8)); | 3414 m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8)); |
3411 } | 3415 } |
3412 | 3416 |
3413 for (int i = 0; i < kNumInputs; i++) { | 3417 for (int i = 0; i < kNumInputs; i++) { |
3414 m.Store(kMachUint32, m.PointerConstant(&result), m.Int32Constant(i * 4), | 3418 m.Store(kMachUint32, m.PointerConstant(&result), m.Int32Constant(i * 4), |
3415 m.ChangeFloat64ToUint32(input_node[i])); | 3419 m.ChangeFloat64ToUint32(input_node[i])); |
3416 } | 3420 } |
3417 | 3421 |
3418 m.Return(m.Int32Constant(magic)); | 3422 m.Return(m.Int32Constant(magic)); |
3419 | 3423 |
3420 for (int i = 0; i < kNumInputs; i++) { | 3424 for (int i = 0; i < kNumInputs; i++) { |
3421 if (i % 2) { | 3425 if (i % 2) { |
3422 input[i] = 100 + i + 2147483648u; | 3426 input[i] = 100 + i + 2147483648u; |
3423 } else { | 3427 } else { |
3424 input[i] = 100 + i; | 3428 input[i] = 100 + i; |
3425 } | 3429 } |
3426 } | 3430 } |
3427 | 3431 |
3428 CHECK_EQ(magic, m.Call()); | 3432 CHECK_EQ(magic, m.Call()); |
3429 | 3433 |
3430 for (int i = 0; i < kNumInputs; i++) { | 3434 for (int i = 0; i < kNumInputs; i++) { |
3431 if (i % 2) { | 3435 if (i % 2) { |
3432 CHECK_EQ(result[i], static_cast<uint32_t>(100 + i + 2147483648u)); | 3436 CHECK_UINT32_EQ(result[i], static_cast<uint32_t>(100 + i + 2147483648u)); |
3433 } else { | 3437 } else { |
3434 CHECK_EQ(result[i], static_cast<uint32_t>(100 + i)); | 3438 CHECK_UINT32_EQ(result[i], static_cast<uint32_t>(100 + i)); |
3435 } | 3439 } |
3436 } | 3440 } |
3437 } | 3441 } |
3438 | 3442 |
3439 | 3443 |
3440 TEST(RunTruncateFloat64ToFloat32_spilled) { | 3444 TEST(RunTruncateFloat64ToFloat32_spilled) { |
3441 RawMachineAssemblerTester<uint32_t> m; | 3445 RawMachineAssemblerTester<uint32_t> m; |
3442 const int kNumInputs = 32; | 3446 const int kNumInputs = 32; |
3443 uint32_t magic = 0x786234; | 3447 int32_t magic = 0x786234; |
3444 double input[kNumInputs]; | 3448 double input[kNumInputs]; |
3445 float result[kNumInputs]; | 3449 float result[kNumInputs]; |
3446 Node* input_node[kNumInputs]; | 3450 Node* input_node[kNumInputs]; |
3447 | 3451 |
3448 for (int i = 0; i < kNumInputs; i++) { | 3452 for (int i = 0; i < kNumInputs; i++) { |
3449 input_node[i] = | 3453 input_node[i] = |
3450 m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8)); | 3454 m.Load(kMachFloat64, m.PointerConstant(&input), m.Int32Constant(i * 8)); |
3451 } | 3455 } |
3452 | 3456 |
3453 for (int i = 0; i < kNumInputs; i++) { | 3457 for (int i = 0; i < kNumInputs; i++) { |
(...skipping 903 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4357 | 4361 |
4358 | 4362 |
4359 TEST(RunTruncateInt64ToInt32P) { | 4363 TEST(RunTruncateInt64ToInt32P) { |
4360 if (kPointerSize < 8) return; | 4364 if (kPointerSize < 8) return; |
4361 int64_t expected = -1; | 4365 int64_t expected = -1; |
4362 RawMachineAssemblerTester<int32_t> m; | 4366 RawMachineAssemblerTester<int32_t> m; |
4363 m.Return(m.TruncateInt64ToInt32(m.LoadFromPointer(&expected, kMachInt64))); | 4367 m.Return(m.TruncateInt64ToInt32(m.LoadFromPointer(&expected, kMachInt64))); |
4364 FOR_UINT32_INPUTS(i) { | 4368 FOR_UINT32_INPUTS(i) { |
4365 FOR_UINT32_INPUTS(j) { | 4369 FOR_UINT32_INPUTS(j) { |
4366 expected = (static_cast<uint64_t>(*j) << 32) | *i; | 4370 expected = (static_cast<uint64_t>(*j) << 32) | *i; |
4367 CHECK_EQ(static_cast<int32_t>(expected), m.Call()); | 4371 CHECK_UINT32_EQ(expected, m.Call()); |
4368 } | 4372 } |
4369 } | 4373 } |
4370 } | 4374 } |
4371 | 4375 |
4372 | 4376 |
4373 TEST(RunTruncateFloat64ToInt32P) { | 4377 TEST(RunTruncateFloat64ToInt32P) { |
4374 struct { | 4378 struct { |
4375 double from; | 4379 double from; |
4376 double raw; | 4380 double raw; |
4377 } kValues[] = {{0, 0}, | 4381 } kValues[] = {{0, 0}, |
(...skipping 115 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4493 double input = 0.0; | 4497 double input = 0.0; |
4494 RawMachineAssemblerTester<int32_t> m; | 4498 RawMachineAssemblerTester<int32_t> m; |
4495 m.StoreToPointer( | 4499 m.StoreToPointer( |
4496 &actual, kMachFloat32, | 4500 &actual, kMachFloat32, |
4497 m.TruncateFloat64ToFloat32(m.LoadFromPointer(&input, kMachFloat64))); | 4501 m.TruncateFloat64ToFloat32(m.LoadFromPointer(&input, kMachFloat64))); |
4498 m.Return(m.Int32Constant(0)); | 4502 m.Return(m.Int32Constant(0)); |
4499 FOR_FLOAT64_INPUTS(i) { | 4503 FOR_FLOAT64_INPUTS(i) { |
4500 input = *i; | 4504 input = *i; |
4501 volatile double expected = DoubleToFloat32(input); | 4505 volatile double expected = DoubleToFloat32(input); |
4502 CHECK_EQ(0, m.Call()); | 4506 CHECK_EQ(0, m.Call()); |
4503 CheckDoubleEq(expected, actual); | 4507 CHECK_EQ(expected, actual); |
4504 } | 4508 } |
4505 } | 4509 } |
4506 | 4510 |
4507 | 4511 |
4508 TEST(RunFloat32Constant) { | 4512 TEST(RunFloat32Constant) { |
4509 FOR_FLOAT32_INPUTS(i) { | 4513 FOR_FLOAT32_INPUTS(i) { |
4510 float expected = *i; | 4514 float expected = *i; |
4511 float actual = *i; | 4515 float actual = *i; |
4512 RawMachineAssemblerTester<int32_t> m; | 4516 RawMachineAssemblerTester<int32_t> m; |
4513 m.StoreToPointer(&actual, kMachFloat32, m.Float32Constant(expected)); | 4517 m.StoreToPointer(&actual, kMachFloat32, m.Float32Constant(expected)); |
(...skipping 164 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4678 m.Float64RoundTiesAway(m.LoadFromPointer(&input, kMachFloat64))); | 4682 m.Float64RoundTiesAway(m.LoadFromPointer(&input, kMachFloat64))); |
4679 m.Return(m.Int32Constant(0)); | 4683 m.Return(m.Int32Constant(0)); |
4680 for (size_t i = 0; i < arraysize(kValues); ++i) { | 4684 for (size_t i = 0; i < arraysize(kValues); ++i) { |
4681 input = kValues[i]; | 4685 input = kValues[i]; |
4682 CHECK_EQ(0, m.Call()); | 4686 CHECK_EQ(0, m.Call()); |
4683 double expected = round(kValues[i]); | 4687 double expected = round(kValues[i]); |
4684 CHECK_EQ(expected, result); | 4688 CHECK_EQ(expected, result); |
4685 } | 4689 } |
4686 } | 4690 } |
4687 #endif // V8_TURBOFAN_TARGET | 4691 #endif // V8_TURBOFAN_TARGET |
OLD | NEW |