Lines Matching +full:0 +full:x80
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
34 } while (0)
37 EXPECT_SLEB128_EQ("\x00", 0, 0);
38 EXPECT_SLEB128_EQ("\x01", 1, 0);
39 EXPECT_SLEB128_EQ("\x7f", -1, 0);
40 EXPECT_SLEB128_EQ("\x3f", 63, 0);
41 EXPECT_SLEB128_EQ("\x41", -63, 0);
42 EXPECT_SLEB128_EQ("\x40", -64, 0);
43 EXPECT_SLEB128_EQ("\xbf\x7f", -65, 0);
44 EXPECT_SLEB128_EQ("\xc0\x00", 64, 0);
47 EXPECT_SLEB128_EQ("\x80\x00", 0, 2);
48 EXPECT_SLEB128_EQ("\x80\x80\x00", 0, 3);
49 EXPECT_SLEB128_EQ("\xff\x80\x00", 0x7f, 3);
50 EXPECT_SLEB128_EQ("\xff\x80\x80\x00", 0x7f, 4);
51 EXPECT_SLEB128_EQ("\x80\x81\x00", 0x80, 3);
52 EXPECT_SLEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
53 EXPECT_SLEB128_EQ("\xc0\x7f", -0x40, 2);
55 EXPECT_SLEB128_EQ("\xc0\xff\x7f", -0x40, 3);
56 EXPECT_SLEB128_EQ("\x80\xff\x7f", -0x80, 3);
57 EXPECT_SLEB128_EQ("\x80\xff\xff\x7f", -0x80, 4);
78 } while (0)
81 EXPECT_ULEB128_EQ("\x00", 0, 0);
82 EXPECT_ULEB128_EQ("\x01", 1, 0);
83 EXPECT_ULEB128_EQ("\x3f", 63, 0);
84 EXPECT_ULEB128_EQ("\x40", 64, 0);
85 EXPECT_ULEB128_EQ("\x7f", 0x7f, 0);
86 EXPECT_ULEB128_EQ("\x80\x01", 0x80, 0);
87 EXPECT_ULEB128_EQ("\x81\x01", 0x81, 0);
88 EXPECT_ULEB128_EQ("\x90\x01", 0x90, 0);
89 EXPECT_ULEB128_EQ("\xff\x01", 0xff, 0);
90 EXPECT_ULEB128_EQ("\x80\x02", 0x100, 0);
91 EXPECT_ULEB128_EQ("\x81\x02", 0x101, 0);
94 EXPECT_ULEB128_EQ("\x80\x00", 0, 2);
95 EXPECT_ULEB128_EQ("\x80\x80\x00", 0, 3);
96 EXPECT_ULEB128_EQ("\xff\x00", 0x7f, 2);
97 EXPECT_ULEB128_EQ("\xff\x80\x00", 0x7f, 3);
98 EXPECT_ULEB128_EQ("\x80\x81\x00", 0x80, 3);
99 EXPECT_ULEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
107 unsigned ActualSize = 0; \
112 } while (0)
115 EXPECT_EQ(0u, decodeULEB128(nullptr, nullptr, nullptr));
118 EXPECT_DECODE_ULEB128_EQ(0u, "\x00");
122 EXPECT_DECODE_ULEB128_EQ(0x7fu, "\x7f");
123 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x01");
124 EXPECT_DECODE_ULEB128_EQ(0x81u, "\x81\x01");
125 EXPECT_DECODE_ULEB128_EQ(0x90u, "\x90\x01");
126 EXPECT_DECODE_ULEB128_EQ(0xffu, "\xff\x01");
127 EXPECT_DECODE_ULEB128_EQ(0x100u, "\x80\x02");
128 EXPECT_DECODE_ULEB128_EQ(0x101u, "\x81\x02");
129 EXPECT_DECODE_ULEB128_EQ(4294975616ULL, "\x80\xc1\x80\x80\x10");
132 EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x00");
133 EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x80\x00");
134 EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x00");
135 EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x80\x00");
136 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x00");
137 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x00");
138 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x80\x80\x80\x80\x80\x80\x00");
139 EXPECT_DECODE_ULEB128_EQ(0x80000000'00000000ul,
140 "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01");
151 unsigned ErrorOffset = 0; \
155 EXPECT_EQ(0ul, Actual); \
161 EXPECT_EQ(0ul, Actual); \
164 } while (0)
167 EXPECT_INVALID_ULEB128("", 0u);
168 EXPECT_INVALID_ULEB128("\x80", 1u);
171 EXPECT_INVALID_ULEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 9u);
172 EXPECT_INVALID_ULEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 10u);
180 unsigned ActualSize = 0; \
185 } while (0)
188 EXPECT_EQ(0, decodeSLEB128(nullptr, nullptr, nullptr));
191 EXPECT_DECODE_SLEB128_EQ(0L, "\x00");
197 EXPECT_DECODE_SLEB128_EQ(128L, "\x80\x01");
200 EXPECT_DECODE_SLEB128_EQ(-128L, "\x80\x7f");
206 EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x00");
207 EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x80\x00");
208 EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x00");
209 EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x80\x00");
210 EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x00");
211 EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x00");
212 EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x80\x80\x80\x80\x80\x80\x00");
215 "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7F");
228 unsigned ErrorOffset = 0; \
232 EXPECT_EQ(0ul, Actual); \
238 EXPECT_EQ(0ul, Actual); \
241 } while (0)
244 EXPECT_INVALID_SLEB128("", 0u);
245 EXPECT_INVALID_SLEB128("\x80", 1u);
248 EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 9u);
249 EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E", 9u);
250 EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 10u);
268 } while (0)
270 EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);
272 EXPECT_LEB128(decodeSLEB128, "\x80\x01", 2);
281 } while (0)
283 EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);
295 EXPECT_EQ(1u, getSLEB128Size(0x0LL));
296 EXPECT_EQ(1u, getSLEB128Size(0x1LL));
297 EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
298 EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
299 EXPECT_EQ(2u, getSLEB128Size(0x40LL));
301 EXPECT_EQ(2u, getSLEB128Size(0x7fLL));
302 EXPECT_EQ(2u, getSLEB128Size(0x80LL));
303 EXPECT_EQ(2u, getSLEB128Size(0x1f80LL));
304 EXPECT_EQ(2u, getSLEB128Size(0x1fffLL));
305 EXPECT_EQ(3u, getSLEB128Size(0x2000LL));
307 EXPECT_EQ(3u, getSLEB128Size(0x3fffLL));
308 EXPECT_EQ(3u, getSLEB128Size(0x4000LL));
309 EXPECT_EQ(3u, getSLEB128Size(0xfc000LL));
310 EXPECT_EQ(3u, getSLEB128Size(0xfffffLL));
311 EXPECT_EQ(4u, getSLEB128Size(0x100000LL));
313 EXPECT_EQ(4u, getSLEB128Size(0x1fffffLL));
314 EXPECT_EQ(4u, getSLEB128Size(0x200000LL));
315 EXPECT_EQ(4u, getSLEB128Size(0x7e00000LL));
316 EXPECT_EQ(4u, getSLEB128Size(0x7ffffffLL));
317 EXPECT_EQ(5u, getSLEB128Size(0x8000000LL));
319 EXPECT_EQ(5u, getSLEB128Size(0xfffffffLL));
320 EXPECT_EQ(5u, getSLEB128Size(0x10000000LL));
321 EXPECT_EQ(5u, getSLEB128Size(0x3f0000000LL));
322 EXPECT_EQ(5u, getSLEB128Size(0x3ffffffffLL));
323 EXPECT_EQ(6u, getSLEB128Size(0x400000000LL));
325 EXPECT_EQ(6u, getSLEB128Size(0x7ffffffffLL));
326 EXPECT_EQ(6u, getSLEB128Size(0x800000000LL));
327 EXPECT_EQ(6u, getSLEB128Size(0x1f800000000LL));
328 EXPECT_EQ(6u, getSLEB128Size(0x1ffffffffffLL));
329 EXPECT_EQ(7u, getSLEB128Size(0x20000000000LL));
331 EXPECT_EQ(7u, getSLEB128Size(0x3ffffffffffLL));
332 EXPECT_EQ(7u, getSLEB128Size(0x40000000000LL));
333 EXPECT_EQ(7u, getSLEB128Size(0xfc0000000000LL));
334 EXPECT_EQ(7u, getSLEB128Size(0xffffffffffffLL));
335 EXPECT_EQ(8u, getSLEB128Size(0x1000000000000LL));
337 EXPECT_EQ(8u, getSLEB128Size(0x1ffffffffffffLL));
338 EXPECT_EQ(8u, getSLEB128Size(0x2000000000000LL));
339 EXPECT_EQ(8u, getSLEB128Size(0x7e000000000000LL));
340 EXPECT_EQ(8u, getSLEB128Size(0x7fffffffffffffLL));
341 EXPECT_EQ(9u, getSLEB128Size(0x80000000000000LL));
343 EXPECT_EQ(9u, getSLEB128Size(0xffffffffffffffLL));
344 EXPECT_EQ(9u, getSLEB128Size(0x100000000000000LL));
345 EXPECT_EQ(9u, getSLEB128Size(0x3f00000000000000LL));
346 EXPECT_EQ(9u, getSLEB128Size(0x3fffffffffffffffLL));
347 EXPECT_EQ(10u, getSLEB128Size(0x4000000000000000LL));
349 EXPECT_EQ(10u, getSLEB128Size(0x7fffffffffffffffLL));
357 // (5) - 128 ^ n * 65 - 1 ... need (n+2) bytes (if n > 0)
360 EXPECT_EQ(1u, getSLEB128Size(0x0LL));
361 EXPECT_EQ(1u, getSLEB128Size(-0x1LL));
362 EXPECT_EQ(1u, getSLEB128Size(-0x3fLL));
363 EXPECT_EQ(1u, getSLEB128Size(-0x40LL));
364 EXPECT_EQ(1u, getSLEB128Size(-0x40LL)); // special case
365 EXPECT_EQ(2u, getSLEB128Size(-0x41LL));
367 EXPECT_EQ(2u, getSLEB128Size(-0x7fLL));
368 EXPECT_EQ(2u, getSLEB128Size(-0x80LL));
369 EXPECT_EQ(2u, getSLEB128Size(-0x1f80LL));
370 EXPECT_EQ(2u, getSLEB128Size(-0x2000LL));
371 EXPECT_EQ(3u, getSLEB128Size(-0x207fLL));
372 EXPECT_EQ(3u, getSLEB128Size(-0x2080LL));
374 EXPECT_EQ(3u, getSLEB128Size(-0x3fffLL));
375 EXPECT_EQ(3u, getSLEB128Size(-0x4000LL));
376 EXPECT_EQ(3u, getSLEB128Size(-0xfc000LL));
377 EXPECT_EQ(3u, getSLEB128Size(-0x100000LL));
378 EXPECT_EQ(4u, getSLEB128Size(-0x103fffLL));
379 EXPECT_EQ(4u, getSLEB128Size(-0x104000LL));
381 EXPECT_EQ(4u, getSLEB128Size(-0x1fffffLL));
382 EXPECT_EQ(4u, getSLEB128Size(-0x200000LL));
383 EXPECT_EQ(4u, getSLEB128Size(-0x7e00000LL));
384 EXPECT_EQ(4u, getSLEB128Size(-0x8000000LL));
385 EXPECT_EQ(5u, getSLEB128Size(-0x81fffffLL));
386 EXPECT_EQ(5u, getSLEB128Size(-0x8200000LL));
388 EXPECT_EQ(5u, getSLEB128Size(-0xfffffffLL));
389 EXPECT_EQ(5u, getSLEB128Size(-0x10000000LL));
390 EXPECT_EQ(5u, getSLEB128Size(-0x3f0000000LL));
391 EXPECT_EQ(5u, getSLEB128Size(-0x400000000LL));
392 EXPECT_EQ(6u, getSLEB128Size(-0x40fffffffLL));
393 EXPECT_EQ(6u, getSLEB128Size(-0x410000000LL));
395 EXPECT_EQ(6u, getSLEB128Size(-0x7ffffffffLL));
396 EXPECT_EQ(6u, getSLEB128Size(-0x800000000LL));
397 EXPECT_EQ(6u, getSLEB128Size(-0x1f800000000LL));
398 EXPECT_EQ(6u, getSLEB128Size(-0x20000000000LL));
399 EXPECT_EQ(7u, getSLEB128Size(-0x207ffffffffLL));
400 EXPECT_EQ(7u, getSLEB128Size(-0x20800000000LL));
402 EXPECT_EQ(7u, getSLEB128Size(-0x3ffffffffffLL));
403 EXPECT_EQ(7u, getSLEB128Size(-0x40000000000LL));
404 EXPECT_EQ(7u, getSLEB128Size(-0xfc0000000000LL));
405 EXPECT_EQ(7u, getSLEB128Size(-0x1000000000000LL));
406 EXPECT_EQ(8u, getSLEB128Size(-0x103ffffffffffLL));
407 EXPECT_EQ(8u, getSLEB128Size(-0x1040000000000LL));
409 EXPECT_EQ(8u, getSLEB128Size(-0x1ffffffffffffLL));
410 EXPECT_EQ(8u, getSLEB128Size(-0x2000000000000LL));
411 EXPECT_EQ(8u, getSLEB128Size(-0x7e000000000000LL));
412 EXPECT_EQ(8u, getSLEB128Size(-0x80000000000000LL));
413 EXPECT_EQ(9u, getSLEB128Size(-0x81ffffffffffffLL));
414 EXPECT_EQ(9u, getSLEB128Size(-0x82000000000000LL));
416 EXPECT_EQ(9u, getSLEB128Size(-0xffffffffffffffLL));
417 EXPECT_EQ(9u, getSLEB128Size(-0x100000000000000LL));
418 EXPECT_EQ(9u, getSLEB128Size(-0x3f00000000000000LL));
419 EXPECT_EQ(9u, getSLEB128Size(-0x4000000000000000LL));
420 EXPECT_EQ(10u, getSLEB128Size(-0x40ffffffffffffffLL));
421 EXPECT_EQ(10u, getSLEB128Size(-0x4100000000000000LL));
423 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL));
424 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL - 1));
434 EXPECT_EQ(1u, getULEB128Size(0)); // special case
436 EXPECT_EQ(1u, getULEB128Size(0x1ULL));
437 EXPECT_EQ(1u, getULEB128Size(0x40ULL));
438 EXPECT_EQ(1u, getULEB128Size(0x7fULL));
440 EXPECT_EQ(2u, getULEB128Size(0x80ULL));
441 EXPECT_EQ(2u, getULEB128Size(0x2000ULL));
442 EXPECT_EQ(2u, getULEB128Size(0x3fffULL));
444 EXPECT_EQ(3u, getULEB128Size(0x4000ULL));
445 EXPECT_EQ(3u, getULEB128Size(0x100000ULL));
446 EXPECT_EQ(3u, getULEB128Size(0x1fffffULL));
448 EXPECT_EQ(4u, getULEB128Size(0x200000ULL));
449 EXPECT_EQ(4u, getULEB128Size(0x8000000ULL));
450 EXPECT_EQ(4u, getULEB128Size(0xfffffffULL));
452 EXPECT_EQ(5u, getULEB128Size(0x10000000ULL));
453 EXPECT_EQ(5u, getULEB128Size(0x400000000ULL));
454 EXPECT_EQ(5u, getULEB128Size(0x7ffffffffULL));
456 EXPECT_EQ(6u, getULEB128Size(0x800000000ULL));
457 EXPECT_EQ(6u, getULEB128Size(0x20000000000ULL));
458 EXPECT_EQ(6u, getULEB128Size(0x3ffffffffffULL));
460 EXPECT_EQ(7u, getULEB128Size(0x40000000000ULL));
461 EXPECT_EQ(7u, getULEB128Size(0x1000000000000ULL));
462 EXPECT_EQ(7u, getULEB128Size(0x1ffffffffffffULL));
464 EXPECT_EQ(8u, getULEB128Size(0x2000000000000ULL));
465 EXPECT_EQ(8u, getULEB128Size(0x80000000000000ULL));
466 EXPECT_EQ(8u, getULEB128Size(0xffffffffffffffULL));
468 EXPECT_EQ(9u, getULEB128Size(0x100000000000000ULL));
469 EXPECT_EQ(9u, getULEB128Size(0x4000000000000000ULL));
470 EXPECT_EQ(9u, getULEB128Size(0x7fffffffffffffffULL));
472 EXPECT_EQ(10u, getULEB128Size(0x8000000000000000ULL));