Line data Source code
1 : // Copyright 2017 the V8 project authors. All rights reserved.
2 : // Use of this source code is governed by a BSD-style license that can be
3 : // found in the LICENSE file.
4 :
5 : #include "test/unittests/compiler/code-assembler-unittest.h"
6 :
7 : #include "src/code-factory.h"
8 : #include "src/compiler/node.h"
9 : #include "src/interface-descriptors.h"
10 : #include "src/isolate.h"
11 : #include "src/objects-inl.h"
12 : #include "test/unittests/compiler/compiler-test-utils.h"
13 : #include "test/unittests/compiler/node-test-utils.h"
14 :
15 : using ::testing::_;
16 :
17 : namespace v8 {
18 : namespace internal {
19 : namespace compiler {
20 :
21 9 : CodeAssemblerTestState::CodeAssemblerTestState(CodeAssemblerTest* test)
22 : : CodeAssemblerState(test->isolate(), test->zone(),
23 18 : VoidDescriptor(test->isolate()), Code::STUB, "test") {}
24 :
25 13160 : TARGET_TEST_F(CodeAssemblerTest, IntPtrAdd) {
26 1 : CodeAssemblerTestState state(this);
27 : CodeAssemblerForTest m(&state);
28 : {
29 1 : Node* a = m.Parameter(0);
30 2 : Node* b = m.Int32Constant(1);
31 2 : Node* add = m.IntPtrAdd(a, b);
32 6 : EXPECT_THAT(add, IsIntPtrAdd(a, b));
33 : }
34 : // x + 0 => x
35 : {
36 1 : Node* a = m.Parameter(0);
37 2 : Node* b = m.Int32Constant(0);
38 2 : Node* add = m.IntPtrAdd(a, b);
39 1 : EXPECT_THAT(add, a);
40 : }
41 : // 0 + x => x
42 : {
43 1 : Node* a = m.Parameter(0);
44 2 : Node* b = m.Int32Constant(0);
45 2 : Node* add = m.IntPtrAdd(b, a);
46 1 : EXPECT_THAT(add, a);
47 : }
48 : // CONST_a + CONST_b => CONST_c
49 : {
50 2 : Node* a = m.IntPtrConstant(22);
51 2 : Node* b = m.IntPtrConstant(33);
52 2 : Node* c = m.IntPtrAdd(a, b);
53 3 : EXPECT_THAT(c, IsIntPtrConstant(55));
54 : }
55 1 : }
56 :
57 13160 : TARGET_TEST_F(CodeAssemblerTest, IntPtrSub) {
58 1 : CodeAssemblerTestState state(this);
59 : CodeAssemblerForTest m(&state);
60 : {
61 1 : Node* a = m.Parameter(0);
62 2 : Node* b = m.Int32Constant(1);
63 2 : Node* sub = m.IntPtrSub(a, b);
64 6 : EXPECT_THAT(sub, IsIntPtrSub(a, b));
65 : }
66 : // x - 0 => x
67 : {
68 1 : Node* a = m.Parameter(0);
69 2 : Node* b = m.Int32Constant(0);
70 2 : Node* c = m.IntPtrSub(a, b);
71 1 : EXPECT_THAT(c, a);
72 : }
73 : // CONST_a - CONST_b => CONST_c
74 : {
75 2 : Node* a = m.IntPtrConstant(100);
76 2 : Node* b = m.IntPtrConstant(1);
77 2 : Node* c = m.IntPtrSub(a, b);
78 3 : EXPECT_THAT(c, IsIntPtrConstant(99));
79 : }
80 1 : }
81 :
82 13160 : TARGET_TEST_F(CodeAssemblerTest, IntPtrMul) {
83 1 : CodeAssemblerTestState state(this);
84 : CodeAssemblerForTest m(&state);
85 : {
86 1 : Node* a = m.Parameter(0);
87 2 : Node* b = m.Int32Constant(100);
88 2 : Node* mul = m.IntPtrMul(a, b);
89 6 : EXPECT_THAT(mul, IsIntPtrMul(a, b));
90 : }
91 : // x * 1 => x
92 : {
93 1 : Node* a = m.Parameter(0);
94 2 : Node* b = m.Int32Constant(1);
95 2 : Node* mul = m.IntPtrMul(a, b);
96 1 : EXPECT_THAT(mul, a);
97 : }
98 : // 1 * x => x
99 : {
100 1 : Node* a = m.Parameter(0);
101 2 : Node* b = m.Int32Constant(1);
102 2 : Node* mul = m.IntPtrMul(b, a);
103 1 : EXPECT_THAT(mul, a);
104 : }
105 : // CONST_a * CONST_b => CONST_c
106 : {
107 2 : Node* a = m.IntPtrConstant(100);
108 2 : Node* b = m.IntPtrConstant(5);
109 2 : Node* c = m.IntPtrMul(a, b);
110 3 : EXPECT_THAT(c, IsIntPtrConstant(500));
111 : }
112 1 : }
113 :
114 13160 : TARGET_TEST_F(CodeAssemblerTest, WordShl) {
115 1 : CodeAssemblerTestState state(this);
116 : CodeAssemblerForTest m(&state);
117 : {
118 1 : Node* a = m.Parameter(0);
119 2 : Node* add = m.WordShl(a, 10);
120 6 : EXPECT_THAT(add, IsWordShl(a, IsIntPtrConstant(10)));
121 : }
122 : // x << 0 => x
123 : {
124 1 : Node* a = m.Parameter(0);
125 2 : Node* add = m.WordShl(a, 0);
126 1 : EXPECT_THAT(add, a);
127 : }
128 : // CONST_a << CONST_b => CONST_c
129 : {
130 2 : Node* a = m.IntPtrConstant(1024);
131 2 : Node* shl = m.WordShl(a, 2);
132 3 : EXPECT_THAT(shl, IsIntPtrConstant(4096));
133 : }
134 1 : }
135 :
136 13160 : TARGET_TEST_F(CodeAssemblerTest, WordShr) {
137 1 : CodeAssemblerTestState state(this);
138 : CodeAssemblerForTest m(&state);
139 : {
140 1 : Node* a = m.Parameter(0);
141 2 : Node* shr = m.WordShr(a, 10);
142 6 : EXPECT_THAT(shr, IsWordShr(a, IsIntPtrConstant(10)));
143 : }
144 : // x >> 0 => x
145 : {
146 1 : Node* a = m.Parameter(0);
147 2 : Node* shr = m.WordShr(a, 0);
148 1 : EXPECT_THAT(shr, a);
149 : }
150 : // +CONST_a >> CONST_b => CONST_c
151 : {
152 2 : Node* a = m.IntPtrConstant(4096);
153 2 : Node* shr = m.WordShr(a, 2);
154 3 : EXPECT_THAT(shr, IsIntPtrConstant(1024));
155 : }
156 : // -CONST_a >> CONST_b => CONST_c
157 : {
158 2 : Node* a = m.IntPtrConstant(-1234);
159 2 : Node* shr = m.WordShr(a, 2);
160 3 : EXPECT_THAT(shr, IsIntPtrConstant(static_cast<uintptr_t>(-1234) >> 2));
161 : }
162 1 : }
163 :
164 13160 : TARGET_TEST_F(CodeAssemblerTest, WordSar) {
165 1 : CodeAssemblerTestState state(this);
166 : CodeAssemblerForTest m(&state);
167 : {
168 1 : Node* a = m.Parameter(0);
169 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(10));
170 6 : EXPECT_THAT(sar, IsWordSar(a, IsIntPtrConstant(10)));
171 : }
172 : // x >>> 0 => x
173 : {
174 1 : Node* a = m.Parameter(0);
175 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(0));
176 1 : EXPECT_THAT(sar, a);
177 : }
178 : // +CONST_a >>> CONST_b => CONST_c
179 : {
180 2 : Node* a = m.IntPtrConstant(4096);
181 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(2));
182 3 : EXPECT_THAT(sar, IsIntPtrConstant(1024));
183 : }
184 : // -CONST_a >>> CONST_b => CONST_c
185 : {
186 2 : Node* a = m.IntPtrConstant(-1234);
187 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(2));
188 3 : EXPECT_THAT(sar, IsIntPtrConstant(static_cast<intptr_t>(-1234) >> 2));
189 : }
190 1 : }
191 :
192 13160 : TARGET_TEST_F(CodeAssemblerTest, WordOr) {
193 1 : CodeAssemblerTestState state(this);
194 : CodeAssemblerForTest m(&state);
195 : {
196 1 : Node* a = m.Parameter(0);
197 3 : Node* z = m.WordOr(a, m.IntPtrConstant(8));
198 6 : EXPECT_THAT(z, IsWordOr(a, IsIntPtrConstant(8)));
199 : }
200 : // x | 0 => x
201 : {
202 1 : Node* a = m.Parameter(0);
203 3 : Node* z = m.WordOr(a, m.IntPtrConstant(0));
204 1 : EXPECT_THAT(z, a);
205 : }
206 : // 0 | x => x
207 : {
208 1 : Node* a = m.Parameter(0);
209 3 : Node* z = m.WordOr(m.IntPtrConstant(0), a);
210 1 : EXPECT_THAT(z, a);
211 : }
212 : // CONST_a | CONST_b => CONST_c
213 : {
214 2 : Node* a = m.IntPtrConstant(3);
215 3 : Node* b = m.WordOr(a, m.IntPtrConstant(7));
216 3 : EXPECT_THAT(b, IsIntPtrConstant(7));
217 : }
218 1 : }
219 :
220 13160 : TARGET_TEST_F(CodeAssemblerTest, WordAnd) {
221 1 : CodeAssemblerTestState state(this);
222 : CodeAssemblerForTest m(&state);
223 : {
224 1 : Node* a = m.Parameter(0);
225 3 : Node* z = m.WordAnd(a, m.IntPtrConstant(8));
226 6 : EXPECT_THAT(z, IsWordAnd(a, IsIntPtrConstant(8)));
227 : }
228 : // CONST_a & CONST_b => CONST_c
229 : {
230 2 : Node* a = m.IntPtrConstant(3);
231 3 : Node* b = m.WordAnd(a, m.IntPtrConstant(7));
232 3 : EXPECT_THAT(b, IsIntPtrConstant(3));
233 : }
234 1 : }
235 :
236 13160 : TARGET_TEST_F(CodeAssemblerTest, WordXor) {
237 1 : CodeAssemblerTestState state(this);
238 : CodeAssemblerForTest m(&state);
239 : {
240 1 : Node* a = m.Parameter(0);
241 3 : Node* z = m.WordXor(a, m.IntPtrConstant(8));
242 6 : EXPECT_THAT(z, IsWordXor(a, IsIntPtrConstant(8)));
243 : }
244 : // CONST_a ^ CONST_b => CONST_c
245 : {
246 2 : Node* a = m.IntPtrConstant(3);
247 3 : Node* b = m.WordXor(a, m.IntPtrConstant(7));
248 3 : EXPECT_THAT(b, IsIntPtrConstant(4));
249 : }
250 1 : }
251 :
252 : } // namespace compiler
253 : } // namespace internal
254 7893 : } // namespace v8
|
