478 lines · cpp
1//===- llvm/unittest/Support/LEB128Test.cpp - LEB128 function tests -------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/Support/LEB128.h"10#include "llvm/Support/DataTypes.h"11#include "llvm/Support/raw_ostream.h"12#include "gtest/gtest.h"13#include <string>14using namespace llvm;15 16namespace {17 18TEST(LEB128Test, EncodeSLEB128) {19#define EXPECT_SLEB128_EQ(EXPECTED, VALUE, PAD) \20 do { \21 std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \22 \23 /* encodeSLEB128(uint64_t, raw_ostream &, unsigned) */ \24 std::string Actual1; \25 raw_string_ostream Stream(Actual1); \26 encodeSLEB128(VALUE, Stream, PAD); \27 EXPECT_EQ(Expected, Actual1); \28 \29 /* encodeSLEB128(uint64_t, uint8_t *, unsigned) */ \30 uint8_t Buffer[32]; \31 unsigned Size = encodeSLEB128(VALUE, Buffer, PAD); \32 std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \33 EXPECT_EQ(Expected, Actual2); \34 } while (0)35 36 // Encode SLEB12837 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);45 46 // Encode SLEB128 with some extra padding bytes47 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);54 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);58 59#undef EXPECT_SLEB128_EQ60}61 62TEST(LEB128Test, EncodeULEB128) {63#define EXPECT_ULEB128_EQ(EXPECTED, VALUE, PAD) \64 do { \65 std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \66 \67 /* encodeULEB128(uint64_t, raw_ostream &, unsigned) */ \68 std::string Actual1; \69 raw_string_ostream Stream(Actual1); \70 encodeULEB128(VALUE, Stream, PAD); \71 EXPECT_EQ(Expected, Actual1); \72 \73 /* encodeULEB128(uint64_t, uint8_t *, unsigned) */ \74 uint8_t Buffer[32]; \75 unsigned Size = encodeULEB128(VALUE, Buffer, PAD); \76 std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \77 EXPECT_EQ(Expected, Actual2); \78 } while (0)79 80 // Encode ULEB12881 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);92 93 // Encode ULEB128 with some extra padding bytes94 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);100 101#undef EXPECT_ULEB128_EQ102}103 104TEST(LEB128Test, DecodeULEB128) {105#define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \106 do { \107 unsigned ActualSize = 0; \108 uint64_t Actual = decodeULEB128(reinterpret_cast<const uint8_t *>(VALUE), \109 &ActualSize); \110 EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \111 EXPECT_EQ(EXPECTED, Actual); \112 } while (0)113 114 // Don't crash115 EXPECT_EQ(0u, decodeULEB128(nullptr, nullptr, nullptr));116 117 // Decode ULEB128118 EXPECT_DECODE_ULEB128_EQ(0u, "\x00");119 EXPECT_DECODE_ULEB128_EQ(1u, "\x01");120 EXPECT_DECODE_ULEB128_EQ(63u, "\x3f");121 EXPECT_DECODE_ULEB128_EQ(64u, "\x40");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");130 131 // Decode ULEB128 with extra padding bytes132 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");141 142#undef EXPECT_DECODE_ULEB128_EQ143}144 145TEST(LEB128Test, DecodeInvalidULEB128) {146#define EXPECT_INVALID_ULEB128(VALUE, ERROR_OFFSET) \147 do { \148 const char *DefaultValue = VALUE; \149 const uint8_t *Value = reinterpret_cast<const uint8_t *>(DefaultValue); \150 const char *Error = nullptr; \151 unsigned ErrorOffset = 0; \152 uint64_t Actual = \153 decodeULEB128(Value, &ErrorOffset, Value + strlen(VALUE), &Error); \154 EXPECT_NE(Error, nullptr); \155 EXPECT_EQ(0ul, Actual); \156 EXPECT_EQ(ERROR_OFFSET, ErrorOffset); \157 Value = reinterpret_cast<const uint8_t *>(DefaultValue); \158 Error = nullptr; \159 Actual = decodeULEB128AndInc(Value, Value + strlen(VALUE), &Error); \160 EXPECT_NE(Error, nullptr); \161 EXPECT_EQ(0ul, Actual); \162 EXPECT_EQ(ERROR_OFFSET, \163 Value - reinterpret_cast<const uint8_t *>(DefaultValue)); \164 } while (0)165 166 // Buffer overflow.167 EXPECT_INVALID_ULEB128("", 0u);168 EXPECT_INVALID_ULEB128("\x80", 1u);169 170 // Does not fit in 64 bits.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);173 174#undef EXPECT_INVALID_ULEB128175}176 177TEST(LEB128Test, DecodeSLEB128) {178#define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \179 do { \180 unsigned ActualSize = 0; \181 int64_t Actual = decodeSLEB128(reinterpret_cast<const uint8_t *>(VALUE), \182 &ActualSize); \183 EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \184 EXPECT_EQ(EXPECTED, Actual); \185 } while (0)186 187 // Don't crash188 EXPECT_EQ(0, decodeSLEB128(nullptr, nullptr, nullptr));189 190 // Decode SLEB128191 EXPECT_DECODE_SLEB128_EQ(0L, "\x00");192 EXPECT_DECODE_SLEB128_EQ(1L, "\x01");193 EXPECT_DECODE_SLEB128_EQ(63L, "\x3f");194 EXPECT_DECODE_SLEB128_EQ(-64L, "\x40");195 EXPECT_DECODE_SLEB128_EQ(-63L, "\x41");196 EXPECT_DECODE_SLEB128_EQ(-1L, "\x7f");197 EXPECT_DECODE_SLEB128_EQ(128L, "\x80\x01");198 EXPECT_DECODE_SLEB128_EQ(129L, "\x81\x01");199 EXPECT_DECODE_SLEB128_EQ(-129L, "\xff\x7e");200 EXPECT_DECODE_SLEB128_EQ(-128L, "\x80\x7f");201 EXPECT_DECODE_SLEB128_EQ(-127L, "\x81\x7f");202 EXPECT_DECODE_SLEB128_EQ(64L, "\xc0\x00");203 EXPECT_DECODE_SLEB128_EQ(-12345L, "\xc7\x9f\x7f");204 205 // Decode unnormalized SLEB128 with extra padding bytes.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");213 EXPECT_DECODE_SLEB128_EQ(-2L, "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F");214 EXPECT_DECODE_SLEB128_EQ(INT64_MIN,215 "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7F");216 EXPECT_DECODE_SLEB128_EQ(INT64_MAX,217 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00");218 219#undef EXPECT_DECODE_SLEB128_EQ220}221 222TEST(LEB128Test, DecodeInvalidSLEB128) {223#define EXPECT_INVALID_SLEB128(VALUE, ERROR_OFFSET) \224 do { \225 const char *DefaultValue = VALUE; \226 const uint8_t *Value = reinterpret_cast<const uint8_t *>(DefaultValue); \227 const char *Error = nullptr; \228 unsigned ErrorOffset = 0; \229 uint64_t Actual = \230 decodeSLEB128(Value, &ErrorOffset, Value + strlen(VALUE), &Error); \231 EXPECT_NE(Error, nullptr); \232 EXPECT_EQ(0ul, Actual); \233 EXPECT_EQ(ERROR_OFFSET, ErrorOffset); \234 Value = reinterpret_cast<const uint8_t *>(DefaultValue); \235 Error = nullptr; \236 Actual = decodeSLEB128AndInc(Value, Value + strlen(VALUE), &Error); \237 EXPECT_NE(Error, nullptr); \238 EXPECT_EQ(0ul, Actual); \239 EXPECT_EQ(ERROR_OFFSET, \240 Value - reinterpret_cast<const uint8_t *>(DefaultValue)); \241 } while (0)242 243 // Buffer overflow.244 EXPECT_INVALID_SLEB128("", 0u);245 EXPECT_INVALID_SLEB128("\x80", 1u);246 247 // Does not fit in 64 bits.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);251 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7E", 9u);252 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01", 9u);253 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7E", 10u);254 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00", 10u);255 256#undef EXPECT_INVALID_SLEB128257}258 259TEST(LEB128Test, DecodeAndInc) {260#define EXPECT_LEB128(FUN, VALUE, SIZE) \261 do { \262 const char *DefaultValue = VALUE; \263 const uint8_t *V = reinterpret_cast<const uint8_t *>(DefaultValue), \264 *P = V; \265 auto Expected = FUN(P), Actual = FUN##AndInc(P, P + strlen(VALUE)); \266 EXPECT_EQ(Actual, Expected); \267 EXPECT_EQ(P - V, SIZE); \268 } while (0)269 EXPECT_LEB128(decodeULEB128, "\x7f", 1);270 EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);271 EXPECT_LEB128(decodeSLEB128, "\x7f", 1);272 EXPECT_LEB128(decodeSLEB128, "\x80\x01", 2);273#undef EXPECT_LEB128274 275#define EXPECT_LEB128(FUN, VALUE, SIZE) \276 do { \277 const uint8_t *V = reinterpret_cast<const uint8_t *>(VALUE), *P = V; \278 auto Expected = FUN(P), Actual = FUN##AndIncUnsafe(P); \279 EXPECT_EQ(Actual, Expected); \280 EXPECT_EQ(P - V, SIZE); \281 } while (0)282 EXPECT_LEB128(decodeULEB128, "\x7f", 1);283 EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);284#undef EXPECT_LEB128285}286 287TEST(LEB128Test, SLEB128Size) {288 // Positive Value Testing Plan:289 // (1) 128 ^ n - 1 ........ need (n+1) bytes290 // (2) 128 ^ n ............ need (n+1) bytes291 // (3) 128 ^ n * 63 ....... need (n+1) bytes292 // (4) 128 ^ n * 64 - 1 ... need (n+1) bytes293 // (5) 128 ^ n * 64 ....... need (n+2) bytes294 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));300 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));306 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));312 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));318 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));324 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));330 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));336 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));342 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));348 349 EXPECT_EQ(10u, getSLEB128Size(0x7fffffffffffffffLL));350 EXPECT_EQ(10u, getSLEB128Size(INT64_MAX));351 352 // Negative Value Testing Plan:353 // (1) - 128 ^ n - 1 ........ need (n+1) bytes354 // (2) - 128 ^ n ............ need (n+1) bytes355 // (3) - 128 ^ n * 63 ....... need (n+1) bytes356 // (4) - 128 ^ n * 64 ....... need (n+1) bytes (different from positive one)357 // (5) - 128 ^ n * 65 - 1 ... need (n+2) bytes (if n > 0)358 // (6) - 128 ^ n * 65 ....... need (n+2) bytes359 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 case365 EXPECT_EQ(2u, getSLEB128Size(-0x41LL));366 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));373 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));380 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));387 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));394 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));401 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));408 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));415 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));422 423 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL));424 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL - 1));425 EXPECT_EQ(10u, getSLEB128Size(INT64_MIN));426}427 428TEST(LEB128Test, ULEB128Size) {429 // Testing Plan:430 // (1) 128 ^ n ............ need (n+1) bytes431 // (2) 128 ^ n * 64 ....... need (n+1) bytes432 // (3) 128 ^ (n+1) - 1 .... need (n+1) bytes433 434 EXPECT_EQ(1u, getULEB128Size(0)); // special case435 436 EXPECT_EQ(1u, getULEB128Size(0x1ULL));437 EXPECT_EQ(1u, getULEB128Size(0x40ULL));438 EXPECT_EQ(1u, getULEB128Size(0x7fULL));439 440 EXPECT_EQ(2u, getULEB128Size(0x80ULL));441 EXPECT_EQ(2u, getULEB128Size(0x2000ULL));442 EXPECT_EQ(2u, getULEB128Size(0x3fffULL));443 444 EXPECT_EQ(3u, getULEB128Size(0x4000ULL));445 EXPECT_EQ(3u, getULEB128Size(0x100000ULL));446 EXPECT_EQ(3u, getULEB128Size(0x1fffffULL));447 448 EXPECT_EQ(4u, getULEB128Size(0x200000ULL));449 EXPECT_EQ(4u, getULEB128Size(0x8000000ULL));450 EXPECT_EQ(4u, getULEB128Size(0xfffffffULL));451 452 EXPECT_EQ(5u, getULEB128Size(0x10000000ULL));453 EXPECT_EQ(5u, getULEB128Size(0x400000000ULL));454 EXPECT_EQ(5u, getULEB128Size(0x7ffffffffULL));455 456 EXPECT_EQ(6u, getULEB128Size(0x800000000ULL));457 EXPECT_EQ(6u, getULEB128Size(0x20000000000ULL));458 EXPECT_EQ(6u, getULEB128Size(0x3ffffffffffULL));459 460 EXPECT_EQ(7u, getULEB128Size(0x40000000000ULL));461 EXPECT_EQ(7u, getULEB128Size(0x1000000000000ULL));462 EXPECT_EQ(7u, getULEB128Size(0x1ffffffffffffULL));463 464 EXPECT_EQ(8u, getULEB128Size(0x2000000000000ULL));465 EXPECT_EQ(8u, getULEB128Size(0x80000000000000ULL));466 EXPECT_EQ(8u, getULEB128Size(0xffffffffffffffULL));467 468 EXPECT_EQ(9u, getULEB128Size(0x100000000000000ULL));469 EXPECT_EQ(9u, getULEB128Size(0x4000000000000000ULL));470 EXPECT_EQ(9u, getULEB128Size(0x7fffffffffffffffULL));471 472 EXPECT_EQ(10u, getULEB128Size(0x8000000000000000ULL));473 474 EXPECT_EQ(10u, getULEB128Size(UINT64_MAX));475}476 477} // anonymous namespace478