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 10 : CodeAssemblerTestState::CodeAssemblerTestState(CodeAssemblerTest* test)
22 : : CodeAssemblerState(test->isolate(), test->zone(), VoidDescriptor{},
23 : Code::STUB, "test",
24 20 : PoisoningMitigationLevel::kPoisonCriticalOnly) {}
25 :
26 15189 : TARGET_TEST_F(CodeAssemblerTest, IntPtrAdd) {
27 1 : CodeAssemblerTestState state(this);
28 : CodeAssemblerForTest m(&state);
29 : {
30 1 : Node* a = m.Parameter(0);
31 2 : Node* b = m.Int32Constant(1);
32 2 : Node* add = m.IntPtrAdd(a, b);
33 6 : EXPECT_THAT(add, IsIntPtrAdd(a, b));
34 : }
35 : // x + 0 => x
36 : {
37 1 : Node* a = m.Parameter(0);
38 2 : Node* b = m.Int32Constant(0);
39 2 : Node* add = m.IntPtrAdd(a, b);
40 1 : EXPECT_THAT(add, a);
41 : }
42 : // 0 + x => x
43 : {
44 1 : Node* a = m.Parameter(0);
45 2 : Node* b = m.Int32Constant(0);
46 2 : Node* add = m.IntPtrAdd(b, a);
47 1 : EXPECT_THAT(add, a);
48 : }
49 : // CONST_a + CONST_b => CONST_c
50 : {
51 2 : Node* a = m.IntPtrConstant(22);
52 2 : Node* b = m.IntPtrConstant(33);
53 2 : Node* c = m.IntPtrAdd(a, b);
54 4 : EXPECT_THAT(c, IsIntPtrConstant(55));
55 : }
56 1 : }
57 :
58 15189 : TARGET_TEST_F(CodeAssemblerTest, IntPtrSub) {
59 1 : CodeAssemblerTestState state(this);
60 : CodeAssemblerForTest m(&state);
61 : {
62 1 : Node* a = m.Parameter(0);
63 2 : Node* b = m.Int32Constant(1);
64 2 : Node* sub = m.IntPtrSub(a, b);
65 6 : EXPECT_THAT(sub, IsIntPtrSub(a, b));
66 : }
67 : // x - 0 => x
68 : {
69 1 : Node* a = m.Parameter(0);
70 2 : Node* b = m.Int32Constant(0);
71 2 : Node* c = m.IntPtrSub(a, b);
72 1 : EXPECT_THAT(c, a);
73 : }
74 : // CONST_a - CONST_b => CONST_c
75 : {
76 2 : Node* a = m.IntPtrConstant(100);
77 2 : Node* b = m.IntPtrConstant(1);
78 2 : Node* c = m.IntPtrSub(a, b);
79 4 : EXPECT_THAT(c, IsIntPtrConstant(99));
80 : }
81 1 : }
82 :
83 15189 : TARGET_TEST_F(CodeAssemblerTest, IntPtrMul) {
84 1 : CodeAssemblerTestState state(this);
85 : CodeAssemblerForTest m(&state);
86 : {
87 1 : Node* a = m.Parameter(0);
88 2 : Node* b = m.Int32Constant(100);
89 2 : Node* mul = m.IntPtrMul(a, b);
90 6 : EXPECT_THAT(mul, IsIntPtrMul(a, b));
91 : }
92 : // x * 1 => x
93 : {
94 1 : Node* a = m.Parameter(0);
95 2 : Node* b = m.Int32Constant(1);
96 2 : Node* mul = m.IntPtrMul(a, b);
97 1 : EXPECT_THAT(mul, a);
98 : }
99 : // 1 * x => x
100 : {
101 1 : Node* a = m.Parameter(0);
102 2 : Node* b = m.Int32Constant(1);
103 2 : Node* mul = m.IntPtrMul(b, a);
104 1 : EXPECT_THAT(mul, a);
105 : }
106 : // CONST_a * CONST_b => CONST_c
107 : {
108 2 : Node* a = m.IntPtrConstant(100);
109 2 : Node* b = m.IntPtrConstant(5);
110 2 : Node* c = m.IntPtrMul(a, b);
111 4 : EXPECT_THAT(c, IsIntPtrConstant(500));
112 : }
113 : // x * 2^CONST => x << CONST
114 : {
115 1 : Node* a = m.Parameter(0);
116 2 : Node* b = m.IntPtrConstant(1 << 3);
117 2 : Node* c = m.IntPtrMul(a, b);
118 6 : EXPECT_THAT(c, IsWordShl(a, IsIntPtrConstant(3)));
119 : }
120 : // 2^CONST * x => x << CONST
121 : {
122 2 : Node* a = m.IntPtrConstant(1 << 3);
123 1 : Node* b = m.Parameter(0);
124 2 : Node* c = m.IntPtrMul(a, b);
125 6 : EXPECT_THAT(c, IsWordShl(b, IsIntPtrConstant(3)));
126 : }
127 1 : }
128 :
129 15189 : TARGET_TEST_F(CodeAssemblerTest, IntPtrDiv) {
130 1 : CodeAssemblerTestState state(this);
131 : CodeAssemblerForTest m(&state);
132 : {
133 1 : TNode<IntPtrT> a = m.UncheckedCast<IntPtrT>(m.Parameter(0));
134 1 : TNode<IntPtrT> b = m.IntPtrConstant(100);
135 1 : TNode<IntPtrT> div = m.IntPtrDiv(a, b);
136 6 : EXPECT_THAT(div, IsIntPtrDiv(Matcher<Node*>(a), Matcher<Node*>(b)));
137 : }
138 : // x / 1 => x
139 : {
140 1 : TNode<IntPtrT> a = m.UncheckedCast<IntPtrT>(m.Parameter(0));
141 1 : TNode<IntPtrT> b = m.IntPtrConstant(1);
142 1 : TNode<IntPtrT> div = m.IntPtrDiv(a, b);
143 1 : EXPECT_THAT(div, a);
144 : }
145 : // CONST_a / CONST_b => CONST_c
146 : {
147 1 : TNode<IntPtrT> a = m.IntPtrConstant(100);
148 1 : TNode<IntPtrT> b = m.IntPtrConstant(5);
149 1 : TNode<IntPtrT> div = m.IntPtrDiv(a, b);
150 4 : EXPECT_THAT(div, IsIntPtrConstant(20));
151 : }
152 : {
153 1 : TNode<IntPtrT> a = m.IntPtrConstant(100);
154 1 : TNode<IntPtrT> b = m.IntPtrConstant(5);
155 1 : TNode<IntPtrT> div = m.IntPtrDiv(a, b);
156 4 : EXPECT_THAT(div, IsIntPtrConstant(20));
157 : }
158 : // x / 2^CONST => x >> CONST
159 : {
160 1 : TNode<IntPtrT> a = m.UncheckedCast<IntPtrT>(m.Parameter(0));
161 1 : TNode<IntPtrT> b = m.IntPtrConstant(1 << 3);
162 1 : TNode<IntPtrT> div = m.IntPtrDiv(a, b);
163 6 : EXPECT_THAT(div, IsWordSar(Matcher<Node*>(a), IsIntPtrConstant(3)));
164 : }
165 1 : }
166 :
167 15189 : TARGET_TEST_F(CodeAssemblerTest, WordShl) {
168 1 : CodeAssemblerTestState state(this);
169 : CodeAssemblerForTest m(&state);
170 : {
171 1 : Node* a = m.Parameter(0);
172 2 : Node* add = m.WordShl(a, 10);
173 6 : EXPECT_THAT(add, IsWordShl(a, IsIntPtrConstant(10)));
174 : }
175 : // x << 0 => x
176 : {
177 1 : Node* a = m.Parameter(0);
178 2 : Node* add = m.WordShl(a, 0);
179 1 : EXPECT_THAT(add, a);
180 : }
181 : // CONST_a << CONST_b => CONST_c
182 : {
183 2 : Node* a = m.IntPtrConstant(1024);
184 2 : Node* shl = m.WordShl(a, 2);
185 4 : EXPECT_THAT(shl, IsIntPtrConstant(4096));
186 : }
187 1 : }
188 :
189 15189 : TARGET_TEST_F(CodeAssemblerTest, WordShr) {
190 1 : CodeAssemblerTestState state(this);
191 : CodeAssemblerForTest m(&state);
192 : {
193 1 : Node* a = m.Parameter(0);
194 2 : Node* shr = m.WordShr(a, 10);
195 6 : EXPECT_THAT(shr, IsWordShr(a, IsIntPtrConstant(10)));
196 : }
197 : // x >> 0 => x
198 : {
199 1 : Node* a = m.Parameter(0);
200 2 : Node* shr = m.WordShr(a, 0);
201 1 : EXPECT_THAT(shr, a);
202 : }
203 : // +CONST_a >> CONST_b => CONST_c
204 : {
205 2 : Node* a = m.IntPtrConstant(4096);
206 2 : Node* shr = m.WordShr(a, 2);
207 4 : EXPECT_THAT(shr, IsIntPtrConstant(1024));
208 : }
209 : // -CONST_a >> CONST_b => CONST_c
210 : {
211 2 : Node* a = m.IntPtrConstant(-1234);
212 2 : Node* shr = m.WordShr(a, 2);
213 4 : EXPECT_THAT(shr, IsIntPtrConstant(static_cast<uintptr_t>(-1234) >> 2));
214 : }
215 1 : }
216 :
217 15189 : TARGET_TEST_F(CodeAssemblerTest, WordSar) {
218 1 : CodeAssemblerTestState state(this);
219 : CodeAssemblerForTest m(&state);
220 : {
221 1 : Node* a = m.Parameter(0);
222 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(10));
223 6 : EXPECT_THAT(sar, IsWordSar(a, IsIntPtrConstant(10)));
224 : }
225 : // x >>> 0 => x
226 : {
227 1 : Node* a = m.Parameter(0);
228 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(0));
229 1 : EXPECT_THAT(sar, a);
230 : }
231 : // +CONST_a >>> CONST_b => CONST_c
232 : {
233 2 : Node* a = m.IntPtrConstant(4096);
234 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(2));
235 4 : EXPECT_THAT(sar, IsIntPtrConstant(1024));
236 : }
237 : // -CONST_a >>> CONST_b => CONST_c
238 : {
239 2 : Node* a = m.IntPtrConstant(-1234);
240 3 : Node* sar = m.WordSar(a, m.IntPtrConstant(2));
241 4 : EXPECT_THAT(sar, IsIntPtrConstant(static_cast<intptr_t>(-1234) >> 2));
242 : }
243 1 : }
244 :
245 15189 : TARGET_TEST_F(CodeAssemblerTest, WordOr) {
246 1 : CodeAssemblerTestState state(this);
247 : CodeAssemblerForTest m(&state);
248 : {
249 1 : Node* a = m.Parameter(0);
250 3 : Node* z = m.WordOr(a, m.IntPtrConstant(8));
251 6 : EXPECT_THAT(z, IsWordOr(a, IsIntPtrConstant(8)));
252 : }
253 : // x | 0 => x
254 : {
255 1 : Node* a = m.Parameter(0);
256 3 : Node* z = m.WordOr(a, m.IntPtrConstant(0));
257 1 : EXPECT_THAT(z, a);
258 : }
259 : // 0 | x => x
260 : {
261 1 : Node* a = m.Parameter(0);
262 3 : Node* z = m.WordOr(m.IntPtrConstant(0), a);
263 1 : EXPECT_THAT(z, a);
264 : }
265 : // CONST_a | CONST_b => CONST_c
266 : {
267 2 : Node* a = m.IntPtrConstant(3);
268 3 : Node* b = m.WordOr(a, m.IntPtrConstant(7));
269 4 : EXPECT_THAT(b, IsIntPtrConstant(7));
270 : }
271 1 : }
272 :
273 15189 : TARGET_TEST_F(CodeAssemblerTest, WordAnd) {
274 1 : CodeAssemblerTestState state(this);
275 : CodeAssemblerForTest m(&state);
276 : {
277 1 : Node* a = m.Parameter(0);
278 3 : Node* z = m.WordAnd(a, m.IntPtrConstant(8));
279 6 : EXPECT_THAT(z, IsWordAnd(a, IsIntPtrConstant(8)));
280 : }
281 : // CONST_a & CONST_b => CONST_c
282 : {
283 2 : Node* a = m.IntPtrConstant(3);
284 3 : Node* b = m.WordAnd(a, m.IntPtrConstant(7));
285 4 : EXPECT_THAT(b, IsIntPtrConstant(3));
286 : }
287 1 : }
288 :
289 15189 : TARGET_TEST_F(CodeAssemblerTest, WordXor) {
290 1 : CodeAssemblerTestState state(this);
291 : CodeAssemblerForTest m(&state);
292 : {
293 1 : Node* a = m.Parameter(0);
294 3 : Node* z = m.WordXor(a, m.IntPtrConstant(8));
295 6 : EXPECT_THAT(z, IsWordXor(a, IsIntPtrConstant(8)));
296 : }
297 : // CONST_a ^ CONST_b => CONST_c
298 : {
299 2 : Node* a = m.IntPtrConstant(3);
300 3 : Node* b = m.WordXor(a, m.IntPtrConstant(7));
301 4 : EXPECT_THAT(b, IsIntPtrConstant(4));
302 : }
303 1 : }
304 :
305 : } // namespace compiler
306 : } // namespace internal
307 9111 : } // namespace v8
|
