Line data Source code
1 : // Copyright 2016 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/test-utils.h"
6 :
7 : #include "src/base/overflowing-math.h"
8 : #include "src/objects-inl.h"
9 : #include "src/wasm/decoder.h"
10 : #include "test/common/wasm/wasm-macro-gen.h"
11 :
12 : namespace v8 {
13 : namespace internal {
14 : namespace wasm {
15 :
16 58 : class DecoderTest : public TestWithZone {
17 : public:
18 29 : DecoderTest() : decoder(nullptr, nullptr) {}
19 :
20 : Decoder decoder;
21 : };
22 :
23 : #define CHECK_UINT32V_INLINE(expected, expected_length, ...) \
24 : do { \
25 : const byte data[] = {__VA_ARGS__}; \
26 : decoder.Reset(data, data + sizeof(data)); \
27 : unsigned length; \
28 : EXPECT_EQ( \
29 : static_cast<uint32_t>(expected), \
30 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length)); \
31 : EXPECT_EQ(static_cast<unsigned>(expected_length), length); \
32 : EXPECT_EQ(data, decoder.pc()); \
33 : EXPECT_TRUE(decoder.ok()); \
34 : EXPECT_EQ(static_cast<uint32_t>(expected), decoder.consume_u32v()); \
35 : EXPECT_EQ(data + expected_length, decoder.pc()); \
36 : } while (false)
37 :
38 : #define CHECK_INT32V_INLINE(expected, expected_length, ...) \
39 : do { \
40 : const byte data[] = {__VA_ARGS__}; \
41 : decoder.Reset(data, data + sizeof(data)); \
42 : unsigned length; \
43 : EXPECT_EQ(expected, decoder.read_i32v<Decoder::kValidate>(decoder.start(), \
44 : &length)); \
45 : EXPECT_EQ(static_cast<unsigned>(expected_length), length); \
46 : EXPECT_EQ(data, decoder.pc()); \
47 : EXPECT_TRUE(decoder.ok()); \
48 : EXPECT_EQ(expected, decoder.consume_i32v()); \
49 : EXPECT_EQ(data + expected_length, decoder.pc()); \
50 : } while (false)
51 :
52 : #define CHECK_UINT64V_INLINE(expected, expected_length, ...) \
53 : do { \
54 : const byte data[] = {__VA_ARGS__}; \
55 : decoder.Reset(data, data + sizeof(data)); \
56 : unsigned length; \
57 : EXPECT_EQ( \
58 : static_cast<uint64_t>(expected), \
59 : decoder.read_u64v<Decoder::kValidate>(decoder.start(), &length)); \
60 : EXPECT_EQ(static_cast<unsigned>(expected_length), length); \
61 : } while (false)
62 :
63 : #define CHECK_INT64V_INLINE(expected, expected_length, ...) \
64 : do { \
65 : const byte data[] = {__VA_ARGS__}; \
66 : decoder.Reset(data, data + sizeof(data)); \
67 : unsigned length; \
68 : EXPECT_EQ(expected, decoder.read_i64v<Decoder::kValidate>(decoder.start(), \
69 : &length)); \
70 : EXPECT_EQ(static_cast<unsigned>(expected_length), length); \
71 : } while (false)
72 :
73 15188 : TEST_F(DecoderTest, ReadU32v_OneByte) {
74 39 : CHECK_UINT32V_INLINE(0, 1, 0);
75 12 : CHECK_UINT32V_INLINE(5, 1, 5);
76 12 : CHECK_UINT32V_INLINE(7, 1, 7);
77 12 : CHECK_UINT32V_INLINE(9, 1, 9);
78 12 : CHECK_UINT32V_INLINE(37, 1, 37);
79 12 : CHECK_UINT32V_INLINE(69, 1, 69);
80 12 : CHECK_UINT32V_INLINE(110, 1, 110);
81 12 : CHECK_UINT32V_INLINE(125, 1, 125);
82 12 : CHECK_UINT32V_INLINE(126, 1, 126);
83 12 : CHECK_UINT32V_INLINE(127, 1, 127);
84 1 : }
85 :
86 15188 : TEST_F(DecoderTest, ReadU32v_TwoByte) {
87 51 : CHECK_UINT32V_INLINE(0, 1, 0, 0);
88 12 : CHECK_UINT32V_INLINE(10, 1, 10, 0);
89 12 : CHECK_UINT32V_INLINE(27, 1, 27, 0);
90 12 : CHECK_UINT32V_INLINE(100, 1, 100, 0);
91 :
92 12 : CHECK_UINT32V_INLINE(444, 2, U32V_2(444));
93 12 : CHECK_UINT32V_INLINE(544, 2, U32V_2(544));
94 12 : CHECK_UINT32V_INLINE(1311, 2, U32V_2(1311));
95 12 : CHECK_UINT32V_INLINE(2333, 2, U32V_2(2333));
96 :
97 6 : for (uint32_t i = 0; i < 1 << 14; i = i * 13 + 1) {
98 60 : CHECK_UINT32V_INLINE(i, 2, U32V_2(i));
99 : }
100 :
101 : const uint32_t max = (1 << 14) - 1;
102 12 : CHECK_UINT32V_INLINE(max, 2, U32V_2(max));
103 1 : }
104 :
105 15188 : TEST_F(DecoderTest, ReadU32v_ThreeByte) {
106 78 : CHECK_UINT32V_INLINE(0, 1, 0, 0, 0, 0);
107 12 : CHECK_UINT32V_INLINE(10, 1, 10, 0, 0, 0);
108 12 : CHECK_UINT32V_INLINE(27, 1, 27, 0, 0, 0);
109 12 : CHECK_UINT32V_INLINE(100, 1, 100, 0, 0, 0);
110 :
111 12 : CHECK_UINT32V_INLINE(11, 3, U32V_3(11));
112 12 : CHECK_UINT32V_INLINE(101, 3, U32V_3(101));
113 12 : CHECK_UINT32V_INLINE(446, 3, U32V_3(446));
114 12 : CHECK_UINT32V_INLINE(546, 3, U32V_3(546));
115 12 : CHECK_UINT32V_INLINE(1319, 3, U32V_3(1319));
116 12 : CHECK_UINT32V_INLINE(2338, 3, U32V_3(2338));
117 12 : CHECK_UINT32V_INLINE(8191, 3, U32V_3(8191));
118 12 : CHECK_UINT32V_INLINE(9999, 3, U32V_3(9999));
119 12 : CHECK_UINT32V_INLINE(14444, 3, U32V_3(14444));
120 12 : CHECK_UINT32V_INLINE(314444, 3, U32V_3(314444));
121 12 : CHECK_UINT32V_INLINE(614444, 3, U32V_3(614444));
122 :
123 : const uint32_t max = (1 << 21) - 1;
124 :
125 8 : for (uint32_t i = 0; i <= max; i = i * 13 + 3) {
126 84 : CHECK_UINT32V_INLINE(i, 3, U32V_3(i), 0);
127 : }
128 :
129 12 : CHECK_UINT32V_INLINE(max, 3, U32V_3(max));
130 1 : }
131 :
132 15188 : TEST_F(DecoderTest, ReadU32v_FourByte) {
133 90 : CHECK_UINT32V_INLINE(0, 1, 0, 0, 0, 0, 0);
134 12 : CHECK_UINT32V_INLINE(10, 1, 10, 0, 0, 0, 0);
135 12 : CHECK_UINT32V_INLINE(27, 1, 27, 0, 0, 0, 0);
136 12 : CHECK_UINT32V_INLINE(100, 1, 100, 0, 0, 0, 0);
137 :
138 12 : CHECK_UINT32V_INLINE(13, 4, U32V_4(13));
139 12 : CHECK_UINT32V_INLINE(107, 4, U32V_4(107));
140 12 : CHECK_UINT32V_INLINE(449, 4, U32V_4(449));
141 12 : CHECK_UINT32V_INLINE(541, 4, U32V_4(541));
142 12 : CHECK_UINT32V_INLINE(1317, 4, U32V_4(1317));
143 12 : CHECK_UINT32V_INLINE(2334, 4, U32V_4(2334));
144 12 : CHECK_UINT32V_INLINE(8191, 4, U32V_4(8191));
145 12 : CHECK_UINT32V_INLINE(9994, 4, U32V_4(9994));
146 12 : CHECK_UINT32V_INLINE(14442, 4, U32V_4(14442));
147 12 : CHECK_UINT32V_INLINE(314442, 4, U32V_4(314442));
148 12 : CHECK_UINT32V_INLINE(614442, 4, U32V_4(614442));
149 12 : CHECK_UINT32V_INLINE(1614442, 4, U32V_4(1614442));
150 12 : CHECK_UINT32V_INLINE(5614442, 4, U32V_4(5614442));
151 12 : CHECK_UINT32V_INLINE(19614442, 4, U32V_4(19614442));
152 :
153 : const uint32_t max = (1 << 28) - 1;
154 :
155 9 : for (uint32_t i = 0; i <= max; i = i * 13 + 5) {
156 96 : CHECK_UINT32V_INLINE(i, 4, U32V_4(i), 0);
157 : }
158 :
159 12 : CHECK_UINT32V_INLINE(max, 4, U32V_4(max));
160 1 : }
161 :
162 15188 : TEST_F(DecoderTest, ReadU32v_FiveByte) {
163 168 : CHECK_UINT32V_INLINE(0, 1, 0, 0, 0, 0, 0);
164 12 : CHECK_UINT32V_INLINE(10, 1, 10, 0, 0, 0, 0);
165 12 : CHECK_UINT32V_INLINE(27, 1, 27, 0, 0, 0, 0);
166 12 : CHECK_UINT32V_INLINE(100, 1, 100, 0, 0, 0, 0);
167 :
168 12 : CHECK_UINT32V_INLINE(13, 5, U32V_5(13));
169 12 : CHECK_UINT32V_INLINE(107, 5, U32V_5(107));
170 12 : CHECK_UINT32V_INLINE(449, 5, U32V_5(449));
171 12 : CHECK_UINT32V_INLINE(541, 5, U32V_5(541));
172 12 : CHECK_UINT32V_INLINE(1317, 5, U32V_5(1317));
173 12 : CHECK_UINT32V_INLINE(2334, 5, U32V_5(2334));
174 12 : CHECK_UINT32V_INLINE(8191, 5, U32V_5(8191));
175 12 : CHECK_UINT32V_INLINE(9994, 5, U32V_5(9994));
176 12 : CHECK_UINT32V_INLINE(24442, 5, U32V_5(24442));
177 12 : CHECK_UINT32V_INLINE(414442, 5, U32V_5(414442));
178 12 : CHECK_UINT32V_INLINE(714442, 5, U32V_5(714442));
179 12 : CHECK_UINT32V_INLINE(1614442, 5, U32V_5(1614442));
180 12 : CHECK_UINT32V_INLINE(6614442, 5, U32V_5(6614442));
181 12 : CHECK_UINT32V_INLINE(89614442, 5, U32V_5(89614442));
182 12 : CHECK_UINT32V_INLINE(2219614442u, 5, U32V_5(2219614442u));
183 12 : CHECK_UINT32V_INLINE(3219614442u, 5, U32V_5(3219614442u));
184 12 : CHECK_UINT32V_INLINE(4019614442u, 5, U32V_5(4019614442u));
185 :
186 : const uint32_t max = 0xFFFFFFFFu;
187 :
188 32 : for (uint32_t i = 1; i < 32; i++) {
189 31 : uint32_t val = 0x983489AAu << i;
190 372 : CHECK_UINT32V_INLINE(val, 5, U32V_5(val), 0);
191 : }
192 :
193 12 : CHECK_UINT32V_INLINE(max, 5, U32V_5(max));
194 1 : }
195 :
196 15188 : TEST_F(DecoderTest, ReadU32v_various) {
197 11 : for (int i = 0; i < 10; i++) {
198 10 : uint32_t x = 0xCCCCCCCCu * i;
199 330 : for (int width = 0; width < 32; width++) {
200 320 : uint32_t val = x >> width;
201 :
202 7680 : CHECK_UINT32V_INLINE(val & MASK_7, 1, U32V_1(val));
203 3840 : CHECK_UINT32V_INLINE(val & MASK_14, 2, U32V_2(val));
204 3840 : CHECK_UINT32V_INLINE(val & MASK_21, 3, U32V_3(val));
205 3840 : CHECK_UINT32V_INLINE(val & MASK_28, 4, U32V_4(val));
206 3840 : CHECK_UINT32V_INLINE(val, 5, U32V_5(val));
207 : }
208 : }
209 1 : }
210 :
211 15188 : TEST_F(DecoderTest, ReadI32v_OneByte) {
212 48 : CHECK_INT32V_INLINE(0, 1, 0);
213 12 : CHECK_INT32V_INLINE(4, 1, 4);
214 12 : CHECK_INT32V_INLINE(6, 1, 6);
215 12 : CHECK_INT32V_INLINE(9, 1, 9);
216 12 : CHECK_INT32V_INLINE(33, 1, 33);
217 12 : CHECK_INT32V_INLINE(61, 1, 61);
218 12 : CHECK_INT32V_INLINE(63, 1, 63);
219 :
220 12 : CHECK_INT32V_INLINE(-1, 1, 127);
221 12 : CHECK_INT32V_INLINE(-2, 1, 126);
222 12 : CHECK_INT32V_INLINE(-11, 1, 117);
223 12 : CHECK_INT32V_INLINE(-62, 1, 66);
224 12 : CHECK_INT32V_INLINE(-63, 1, 65);
225 12 : CHECK_INT32V_INLINE(-64, 1, 64);
226 1 : }
227 :
228 15188 : TEST_F(DecoderTest, ReadI32v_TwoByte) {
229 117 : CHECK_INT32V_INLINE(0, 2, U32V_2(0));
230 12 : CHECK_INT32V_INLINE(9, 2, U32V_2(9));
231 12 : CHECK_INT32V_INLINE(61, 2, U32V_2(61));
232 12 : CHECK_INT32V_INLINE(63, 2, U32V_2(63));
233 :
234 12 : CHECK_INT32V_INLINE(-1, 2, U32V_2(-1));
235 12 : CHECK_INT32V_INLINE(-2, 2, U32V_2(-2));
236 12 : CHECK_INT32V_INLINE(-63, 2, U32V_2(-63));
237 12 : CHECK_INT32V_INLINE(-64, 2, U32V_2(-64));
238 :
239 12 : CHECK_INT32V_INLINE(-200, 2, U32V_2(-200));
240 12 : CHECK_INT32V_INLINE(-1002, 2, U32V_2(-1002));
241 12 : CHECK_INT32V_INLINE(-2004, 2, U32V_2(-2004));
242 12 : CHECK_INT32V_INLINE(-4077, 2, U32V_2(-4077));
243 :
244 12 : CHECK_INT32V_INLINE(207, 2, U32V_2(207));
245 12 : CHECK_INT32V_INLINE(1009, 2, U32V_2(1009));
246 12 : CHECK_INT32V_INLINE(2003, 2, U32V_2(2003));
247 12 : CHECK_INT32V_INLINE(4072, 2, U32V_2(4072));
248 :
249 : const int32_t min = 0 - (1 << 13);
250 11 : for (int i = min; i < min + 10; i++) {
251 120 : CHECK_INT32V_INLINE(i, 2, U32V_2(i));
252 : }
253 :
254 : const int32_t max = (1 << 13) - 1;
255 11 : for (int i = max; i > max - 10; i--) {
256 120 : CHECK_INT32V_INLINE(i, 2, U32V_2(i));
257 : }
258 1 : }
259 :
260 15188 : TEST_F(DecoderTest, ReadI32v_ThreeByte) {
261 123 : CHECK_INT32V_INLINE(0, 3, U32V_3(0));
262 12 : CHECK_INT32V_INLINE(9, 3, U32V_3(9));
263 12 : CHECK_INT32V_INLINE(61, 3, U32V_3(61));
264 12 : CHECK_INT32V_INLINE(63, 3, U32V_3(63));
265 :
266 12 : CHECK_INT32V_INLINE(-1, 3, U32V_3(-1));
267 12 : CHECK_INT32V_INLINE(-2, 3, U32V_3(-2));
268 12 : CHECK_INT32V_INLINE(-63, 3, U32V_3(-63));
269 12 : CHECK_INT32V_INLINE(-64, 3, U32V_3(-64));
270 :
271 12 : CHECK_INT32V_INLINE(-207, 3, U32V_3(-207));
272 12 : CHECK_INT32V_INLINE(-1012, 3, U32V_3(-1012));
273 12 : CHECK_INT32V_INLINE(-4067, 3, U32V_3(-4067));
274 12 : CHECK_INT32V_INLINE(-14067, 3, U32V_3(-14067));
275 12 : CHECK_INT32V_INLINE(-234061, 3, U32V_3(-234061));
276 :
277 12 : CHECK_INT32V_INLINE(237, 3, U32V_3(237));
278 12 : CHECK_INT32V_INLINE(1309, 3, U32V_3(1309));
279 12 : CHECK_INT32V_INLINE(4372, 3, U32V_3(4372));
280 12 : CHECK_INT32V_INLINE(64372, 3, U32V_3(64372));
281 12 : CHECK_INT32V_INLINE(374372, 3, U32V_3(374372));
282 :
283 : const int32_t min = 0 - (1 << 20);
284 11 : for (int i = min; i < min + 10; i++) {
285 120 : CHECK_INT32V_INLINE(i, 3, U32V_3(i));
286 : }
287 :
288 : const int32_t max = (1 << 20) - 1;
289 11 : for (int i = max; i > max - 10; i--) {
290 120 : CHECK_INT32V_INLINE(i, 3, U32V_3(i));
291 : }
292 1 : }
293 :
294 15188 : TEST_F(DecoderTest, ReadI32v_FourByte) {
295 141 : CHECK_INT32V_INLINE(0, 4, U32V_4(0));
296 12 : CHECK_INT32V_INLINE(9, 4, U32V_4(9));
297 12 : CHECK_INT32V_INLINE(61, 4, U32V_4(61));
298 12 : CHECK_INT32V_INLINE(63, 4, U32V_4(63));
299 :
300 12 : CHECK_INT32V_INLINE(-1, 4, U32V_4(-1));
301 12 : CHECK_INT32V_INLINE(-2, 4, U32V_4(-2));
302 12 : CHECK_INT32V_INLINE(-63, 4, U32V_4(-63));
303 12 : CHECK_INT32V_INLINE(-64, 4, U32V_4(-64));
304 :
305 12 : CHECK_INT32V_INLINE(-267, 4, U32V_4(-267));
306 12 : CHECK_INT32V_INLINE(-1612, 4, U32V_4(-1612));
307 12 : CHECK_INT32V_INLINE(-4667, 4, U32V_4(-4667));
308 12 : CHECK_INT32V_INLINE(-16067, 4, U32V_4(-16067));
309 12 : CHECK_INT32V_INLINE(-264061, 4, U32V_4(-264061));
310 12 : CHECK_INT32V_INLINE(-1264061, 4, U32V_4(-1264061));
311 12 : CHECK_INT32V_INLINE(-6264061, 4, U32V_4(-6264061));
312 11 : CHECK_INT32V_INLINE(-8264061, 4, U32V_4(-8264061));
313 :
314 12 : CHECK_INT32V_INLINE(277, 4, U32V_4(277));
315 12 : CHECK_INT32V_INLINE(1709, 4, U32V_4(1709));
316 12 : CHECK_INT32V_INLINE(4772, 4, U32V_4(4772));
317 12 : CHECK_INT32V_INLINE(67372, 4, U32V_4(67372));
318 12 : CHECK_INT32V_INLINE(374372, 4, U32V_4(374372));
319 12 : CHECK_INT32V_INLINE(2374372, 4, U32V_4(2374372));
320 12 : CHECK_INT32V_INLINE(7374372, 4, U32V_4(7374372));
321 12 : CHECK_INT32V_INLINE(9374372, 4, U32V_4(9374372));
322 :
323 : const int32_t min = 0 - (1 << 27);
324 11 : for (int i = min; i < min + 10; i++) {
325 120 : CHECK_INT32V_INLINE(i, 4, U32V_4(i));
326 : }
327 :
328 : const int32_t max = (1 << 27) - 1;
329 11 : for (int i = max; i > max - 10; i--) {
330 120 : CHECK_INT32V_INLINE(i, 4, U32V_4(i));
331 : }
332 1 : }
333 :
334 15188 : TEST_F(DecoderTest, ReadI32v_FiveByte) {
335 153 : CHECK_INT32V_INLINE(0, 5, U32V_5(0));
336 12 : CHECK_INT32V_INLINE(16, 5, U32V_5(16));
337 12 : CHECK_INT32V_INLINE(94, 5, U32V_5(94));
338 12 : CHECK_INT32V_INLINE(127, 5, U32V_5(127));
339 :
340 12 : CHECK_INT32V_INLINE(-1, 5, U32V_5(-1));
341 12 : CHECK_INT32V_INLINE(-2, 5, U32V_5(-2));
342 12 : CHECK_INT32V_INLINE(-63, 5, U32V_5(-63));
343 12 : CHECK_INT32V_INLINE(-64, 5, U32V_5(-64));
344 :
345 12 : CHECK_INT32V_INLINE(-257, 5, U32V_5(-257));
346 12 : CHECK_INT32V_INLINE(-1512, 5, U32V_5(-1512));
347 12 : CHECK_INT32V_INLINE(-4567, 5, U32V_5(-4567));
348 12 : CHECK_INT32V_INLINE(-15067, 5, U32V_5(-15067));
349 12 : CHECK_INT32V_INLINE(-254061, 5, U32V_5(-254061));
350 12 : CHECK_INT32V_INLINE(-1364061, 5, U32V_5(-1364061));
351 12 : CHECK_INT32V_INLINE(-6364061, 5, U32V_5(-6364061));
352 12 : CHECK_INT32V_INLINE(-8364061, 5, U32V_5(-8364061));
353 12 : CHECK_INT32V_INLINE(-28364061, 5, U32V_5(-28364061));
354 12 : CHECK_INT32V_INLINE(-228364061, 5, U32V_5(-228364061));
355 :
356 12 : CHECK_INT32V_INLINE(227, 5, U32V_5(227));
357 12 : CHECK_INT32V_INLINE(1209, 5, U32V_5(1209));
358 12 : CHECK_INT32V_INLINE(4272, 5, U32V_5(4272));
359 12 : CHECK_INT32V_INLINE(62372, 5, U32V_5(62372));
360 12 : CHECK_INT32V_INLINE(324372, 5, U32V_5(324372));
361 12 : CHECK_INT32V_INLINE(2274372, 5, U32V_5(2274372));
362 12 : CHECK_INT32V_INLINE(7274372, 5, U32V_5(7274372));
363 12 : CHECK_INT32V_INLINE(9274372, 5, U32V_5(9274372));
364 12 : CHECK_INT32V_INLINE(42374372, 5, U32V_5(42374372));
365 12 : CHECK_INT32V_INLINE(429374372, 5, U32V_5(429374372));
366 :
367 : const int32_t min = kMinInt;
368 11 : for (int i = min; i < min + 10; i++) {
369 120 : CHECK_INT32V_INLINE(i, 5, U32V_5(i));
370 : }
371 :
372 : const int32_t max = kMaxInt;
373 11 : for (int i = max; i > max - 10; i--) {
374 120 : CHECK_INT32V_INLINE(i, 5, U32V_5(i));
375 : }
376 1 : }
377 :
378 15188 : TEST_F(DecoderTest, ReadU32v_off_end1) {
379 : static const byte data[] = {U32V_1(11)};
380 1 : unsigned length = 0;
381 1 : decoder.Reset(data, data);
382 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length);
383 2 : EXPECT_EQ(0u, length);
384 2 : EXPECT_FALSE(decoder.ok());
385 1 : }
386 :
387 15188 : TEST_F(DecoderTest, ReadU32v_off_end2) {
388 : static const byte data[] = {U32V_2(1111)};
389 3 : for (size_t i = 0; i < sizeof(data); i++) {
390 2 : unsigned length = 0;
391 2 : decoder.Reset(data, data + i);
392 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length);
393 2 : EXPECT_EQ(i, length);
394 4 : EXPECT_FALSE(decoder.ok());
395 : }
396 1 : }
397 :
398 15188 : TEST_F(DecoderTest, ReadU32v_off_end3) {
399 : static const byte data[] = {U32V_3(111111)};
400 4 : for (size_t i = 0; i < sizeof(data); i++) {
401 3 : unsigned length = 0;
402 3 : decoder.Reset(data, data + i);
403 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length);
404 3 : EXPECT_EQ(i, length);
405 6 : EXPECT_FALSE(decoder.ok());
406 : }
407 1 : }
408 :
409 15188 : TEST_F(DecoderTest, ReadU32v_off_end4) {
410 : static const byte data[] = {U32V_4(11111111)};
411 5 : for (size_t i = 0; i < sizeof(data); i++) {
412 4 : unsigned length = 0;
413 4 : decoder.Reset(data, data + i);
414 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length);
415 4 : EXPECT_EQ(i, length);
416 8 : EXPECT_FALSE(decoder.ok());
417 : }
418 1 : }
419 :
420 15188 : TEST_F(DecoderTest, ReadU32v_off_end5) {
421 : static const byte data[] = {U32V_5(111111111)};
422 6 : for (size_t i = 0; i < sizeof(data); i++) {
423 5 : unsigned length = 0;
424 5 : decoder.Reset(data, data + i);
425 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length);
426 5 : EXPECT_EQ(i, length);
427 10 : EXPECT_FALSE(decoder.ok());
428 : }
429 1 : }
430 :
431 15188 : TEST_F(DecoderTest, ReadU32v_extra_bits) {
432 1 : byte data[] = {0x80, 0x80, 0x80, 0x80, 0x00};
433 16 : for (int i = 1; i < 16; i++) {
434 15 : data[4] = static_cast<byte>(i << 4);
435 15 : unsigned length = 0;
436 15 : decoder.Reset(data, data + sizeof(data));
437 : decoder.read_u32v<Decoder::kValidate>(decoder.start(), &length);
438 30 : EXPECT_EQ(5u, length);
439 30 : EXPECT_FALSE(decoder.ok());
440 : }
441 1 : }
442 :
443 15188 : TEST_F(DecoderTest, ReadI32v_extra_bits_negative) {
444 : // OK for negative signed values to have extra ones.
445 1 : unsigned length = 0;
446 1 : byte data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0x7F};
447 1 : decoder.Reset(data, data + sizeof(data));
448 : decoder.read_i32v<Decoder::kValidate>(decoder.start(), &length);
449 2 : EXPECT_EQ(5u, length);
450 1 : EXPECT_TRUE(decoder.ok());
451 1 : }
452 :
453 15188 : TEST_F(DecoderTest, ReadI32v_extra_bits_positive) {
454 : // Not OK for positive signed values to have extra ones.
455 1 : unsigned length = 0;
456 1 : byte data[] = {0x80, 0x80, 0x80, 0x80, 0x77};
457 1 : decoder.Reset(data, data + sizeof(data));
458 : decoder.read_i32v<Decoder::kValidate>(decoder.start(), &length);
459 2 : EXPECT_EQ(5u, length);
460 2 : EXPECT_FALSE(decoder.ok());
461 1 : }
462 :
463 15188 : TEST_F(DecoderTest, ReadU32v_Bits) {
464 : // A more exhaustive test.
465 : const int kMaxSize = 5;
466 : const uint32_t kVals[] = {
467 : 0xAABBCCDD, 0x11223344, 0x33445566, 0xFFEEDDCC, 0xF0F0F0F0, 0x0F0F0F0F,
468 : 0xEEEEEEEE, 0xAAAAAAAA, 0x12345678, 0x9ABCDEF0, 0x80309488, 0x729ED997,
469 : 0xC4A0CF81, 0x16C6EB85, 0x4206DB8E, 0xF3B089D5, 0xAA2E223E, 0xF99E29C8,
470 : 0x4A4357D8, 0x1890B1C1, 0x8D80A085, 0xACB6AE4C, 0x1B827E10, 0xEB5C7BD9,
471 1 : 0xBB1BC146, 0xDF57A33l};
472 : byte data[kMaxSize];
473 :
474 : // foreach value in above array
475 27 : for (size_t v = 0; v < arraysize(kVals); v++) {
476 : // foreach length 1...32
477 832 : for (int i = 1; i <= 32; i++) {
478 832 : uint32_t val = kVals[v];
479 832 : if (i < 32)
480 806 : val &= base::SubWithWraparound(base::ShlWithWraparound(1, i), 1);
481 :
482 832 : unsigned length = 1 + i / 7;
483 4992 : for (unsigned j = 0; j < kMaxSize; j++) {
484 4160 : data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
485 : }
486 1612 : for (unsigned j = 0; j < length - 1; j++) {
487 1612 : data[j] |= 0x80;
488 : }
489 :
490 : // foreach buffer size 0...5
491 4992 : for (unsigned limit = 0; limit <= kMaxSize; limit++) {
492 4992 : decoder.Reset(data, data + limit);
493 : unsigned rlen;
494 4992 : uint32_t result = decoder.read_u32v<Decoder::kValidate>(data, &rlen);
495 4992 : if (limit < length) {
496 4888 : EXPECT_FALSE(decoder.ok());
497 : } else {
498 2548 : EXPECT_TRUE(decoder.ok());
499 2548 : EXPECT_EQ(val, result);
500 2548 : EXPECT_EQ(length, rlen);
501 : }
502 : }
503 : }
504 : }
505 1 : }
506 :
507 15188 : TEST_F(DecoderTest, ReadU64v_OneByte) {
508 14 : CHECK_UINT64V_INLINE(0, 1, 0);
509 5 : CHECK_UINT64V_INLINE(6, 1, 6);
510 5 : CHECK_UINT64V_INLINE(8, 1, 8);
511 5 : CHECK_UINT64V_INLINE(12, 1, 12);
512 5 : CHECK_UINT64V_INLINE(33, 1, 33);
513 5 : CHECK_UINT64V_INLINE(59, 1, 59);
514 5 : CHECK_UINT64V_INLINE(110, 1, 110);
515 5 : CHECK_UINT64V_INLINE(125, 1, 125);
516 5 : CHECK_UINT64V_INLINE(126, 1, 126);
517 5 : CHECK_UINT64V_INLINE(127, 1, 127);
518 1 : }
519 :
520 15188 : TEST_F(DecoderTest, ReadI64v_OneByte) {
521 17 : CHECK_INT64V_INLINE(0, 1, 0);
522 5 : CHECK_INT64V_INLINE(4, 1, 4);
523 5 : CHECK_INT64V_INLINE(6, 1, 6);
524 5 : CHECK_INT64V_INLINE(9, 1, 9);
525 5 : CHECK_INT64V_INLINE(33, 1, 33);
526 5 : CHECK_INT64V_INLINE(61, 1, 61);
527 5 : CHECK_INT64V_INLINE(63, 1, 63);
528 :
529 5 : CHECK_INT64V_INLINE(-1, 1, 127);
530 5 : CHECK_INT64V_INLINE(-2, 1, 126);
531 5 : CHECK_INT64V_INLINE(-11, 1, 117);
532 5 : CHECK_INT64V_INLINE(-62, 1, 66);
533 5 : CHECK_INT64V_INLINE(-63, 1, 65);
534 5 : CHECK_INT64V_INLINE(-64, 1, 64);
535 1 : }
536 :
537 15188 : TEST_F(DecoderTest, ReadU64v_PowerOf2) {
538 : const int kMaxSize = 10;
539 : byte data[kMaxSize];
540 :
541 65 : for (unsigned i = 0; i < 64; i++) {
542 64 : const uint64_t val = 1ull << i;
543 64 : unsigned index = i / 7;
544 64 : data[index] = 1 << (i % 7);
545 64 : memset(data, 0x80, index);
546 :
547 704 : for (unsigned limit = 0; limit <= kMaxSize; limit++) {
548 704 : decoder.Reset(data, data + limit);
549 : unsigned length;
550 704 : uint64_t result = decoder.read_u64v<Decoder::kValidate>(data, &length);
551 704 : if (limit <= index) {
552 650 : EXPECT_FALSE(decoder.ok());
553 : } else {
554 379 : EXPECT_TRUE(decoder.ok());
555 379 : EXPECT_EQ(val, result);
556 758 : EXPECT_EQ(index + 1, length);
557 : }
558 : }
559 : }
560 1 : }
561 :
562 15188 : TEST_F(DecoderTest, ReadU64v_Bits) {
563 : const int kMaxSize = 10;
564 : const uint64_t kVals[] = {
565 : 0xAABBCCDD11223344ull, 0x33445566FFEEDDCCull, 0xF0F0F0F0F0F0F0F0ull,
566 : 0x0F0F0F0F0F0F0F0Full, 0xEEEEEEEEEEEEEEEEull, 0xAAAAAAAAAAAAAAAAull,
567 : 0x123456789ABCDEF0ull, 0x80309488729ED997ull, 0xC4A0CF8116C6EB85ull,
568 : 0x4206DB8EF3B089D5ull, 0xAA2E223EF99E29C8ull, 0x4A4357D81890B1C1ull,
569 1 : 0x8D80A085ACB6AE4Cull, 0x1B827E10EB5C7BD9ull, 0xBB1BC146DF57A338ull};
570 : byte data[kMaxSize];
571 :
572 : // foreach value in above array
573 16 : for (size_t v = 0; v < arraysize(kVals); v++) {
574 : // foreach length 1...64
575 960 : for (int i = 1; i <= 64; i++) {
576 960 : uint64_t val = kVals[v];
577 960 : if (i < 64) val &= ((1ull << i) - 1);
578 :
579 960 : unsigned length = 1 + i / 7;
580 10560 : for (unsigned j = 0; j < kMaxSize; j++) {
581 9600 : data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
582 : }
583 4050 : for (unsigned j = 0; j < length - 1; j++) {
584 4050 : data[j] |= 0x80;
585 : }
586 :
587 : // foreach buffer size 0...10
588 10560 : for (unsigned limit = 0; limit <= kMaxSize; limit++) {
589 10560 : decoder.Reset(data, data + limit);
590 : unsigned rlen;
591 10560 : uint64_t result = decoder.read_u64v<Decoder::kValidate>(data, &rlen);
592 10560 : if (limit < length) {
593 10020 : EXPECT_FALSE(decoder.ok());
594 : } else {
595 5550 : EXPECT_TRUE(decoder.ok());
596 5550 : EXPECT_EQ(val, result);
597 5550 : EXPECT_EQ(length, rlen);
598 : }
599 : }
600 : }
601 : }
602 1 : }
603 :
604 15188 : TEST_F(DecoderTest, ReadI64v_Bits) {
605 : const int kMaxSize = 10;
606 : // Exhaustive signedness test.
607 : const uint64_t kVals[] = {
608 : 0xAABBCCDD11223344ull, 0x33445566FFEEDDCCull, 0xF0F0F0F0F0F0F0F0ull,
609 : 0x0F0F0F0F0F0F0F0Full, 0xEEEEEEEEEEEEEEEEull, 0xAAAAAAAAAAAAAAAAull,
610 : 0x123456789ABCDEF0ull, 0x80309488729ED997ull, 0xC4A0CF8116C6EB85ull,
611 : 0x4206DB8EF3B089D5ull, 0xAA2E223EF99E29C8ull, 0x4A4357D81890B1C1ull,
612 1 : 0x8D80A085ACB6AE4Cull, 0x1B827E10EB5C7BD9ull, 0xBB1BC146DF57A338ull};
613 : byte data[kMaxSize];
614 :
615 : // foreach value in above array
616 16 : for (size_t v = 0; v < arraysize(kVals); v++) {
617 : // foreach length 1...64
618 960 : for (int i = 1; i <= 64; i++) {
619 1920 : const int64_t val = bit_cast<int64_t>(kVals[v] << (64 - i)) >> (64 - i);
620 :
621 960 : unsigned length = 1 + i / 7;
622 10560 : for (unsigned j = 0; j < kMaxSize; j++) {
623 9600 : data[j] = static_cast<byte>((val >> (7 * j)) & MASK_7);
624 : }
625 4050 : for (unsigned j = 0; j < length - 1; j++) {
626 4050 : data[j] |= 0x80;
627 : }
628 :
629 : // foreach buffer size 0...10
630 10560 : for (unsigned limit = 0; limit <= kMaxSize; limit++) {
631 10560 : decoder.Reset(data, data + limit);
632 : unsigned rlen;
633 10560 : int64_t result = decoder.read_i64v<Decoder::kValidate>(data, &rlen);
634 10560 : if (limit < length) {
635 10020 : EXPECT_FALSE(decoder.ok());
636 : } else {
637 5550 : EXPECT_TRUE(decoder.ok());
638 5550 : EXPECT_EQ(val, result);
639 5550 : EXPECT_EQ(length, rlen);
640 : }
641 : }
642 : }
643 : }
644 1 : }
645 :
646 15188 : TEST_F(DecoderTest, ReadU64v_extra_bits) {
647 1 : byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x00};
648 128 : for (int i = 1; i < 128; i++) {
649 127 : data[9] = static_cast<byte>(i << 1);
650 127 : unsigned length = 0;
651 127 : decoder.Reset(data, data + sizeof(data));
652 : decoder.read_u64v<Decoder::kValidate>(decoder.start(), &length);
653 254 : EXPECT_EQ(10u, length);
654 254 : EXPECT_FALSE(decoder.ok());
655 : }
656 1 : }
657 :
658 15188 : TEST_F(DecoderTest, ReadI64v_extra_bits_negative) {
659 : // OK for negative signed values to have extra ones.
660 1 : unsigned length = 0;
661 1 : byte data[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F};
662 1 : decoder.Reset(data, data + sizeof(data));
663 : decoder.read_i64v<Decoder::kValidate>(decoder.start(), &length);
664 2 : EXPECT_EQ(10u, length);
665 1 : EXPECT_TRUE(decoder.ok());
666 1 : }
667 :
668 15188 : TEST_F(DecoderTest, ReadI64v_extra_bits_positive) {
669 : // Not OK for positive signed values to have extra ones.
670 1 : unsigned length = 0;
671 1 : byte data[] = {0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x77};
672 1 : decoder.Reset(data, data + sizeof(data));
673 : decoder.read_i64v<Decoder::kValidate>(decoder.start(), &length);
674 2 : EXPECT_EQ(10u, length);
675 2 : EXPECT_FALSE(decoder.ok());
676 1 : }
677 :
678 15188 : TEST_F(DecoderTest, FailOnNullData) {
679 1 : decoder.Reset(nullptr, nullptr);
680 1 : decoder.checkAvailable(1);
681 2 : EXPECT_FALSE(decoder.ok());
682 3 : EXPECT_FALSE(decoder.toResult(nullptr).ok());
683 1 : }
684 :
685 : #undef CHECK_UINT32V_INLINE
686 : #undef CHECK_INT32V_INLINE
687 : #undef CHECK_UINT64V_INLINE
688 : #undef CHECK_INT64V_INLINE
689 :
690 : } // namespace wasm
691 : } // namespace internal
692 9111 : } // namespace v8
|
