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