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-exception 6 // 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> 14 using namespace llvm; 15 16 namespace { 17 18 TEST(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 SLEB128 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); 45 46 // Encode SLEB128 with some extra padding bytes 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); 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_EQ 60 } 61 62 TEST(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 ULEB128 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); 92 93 // Encode ULEB128 with some extra padding bytes 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); 100 101 #undef EXPECT_ULEB128_EQ 102 } 103 104 TEST(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 crash 115 EXPECT_EQ(0u, decodeULEB128(nullptr, nullptr, nullptr)); 116 117 // Decode ULEB128 118 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 bytes 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"); 141 142 #undef EXPECT_DECODE_ULEB128_EQ 143 } 144 145 TEST(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_ULEB128 175 } 176 177 TEST(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 crash 188 EXPECT_EQ(0, decodeSLEB128(nullptr, nullptr, nullptr)); 189 190 // Decode SLEB128 191 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_EQ 220 } 221 222 TEST(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_SLEB128 257 } 258 259 TEST(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_LEB128 274 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_LEB128 285 } 286 287 TEST(LEB128Test, SLEB128Size) { 288 // Positive Value Testing Plan: 289 // (1) 128 ^ n - 1 ........ need (n+1) bytes 290 // (2) 128 ^ n ............ need (n+1) bytes 291 // (3) 128 ^ n * 63 ....... need (n+1) bytes 292 // (4) 128 ^ n * 64 - 1 ... need (n+1) bytes 293 // (5) 128 ^ n * 64 ....... need (n+2) bytes 294 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) bytes 354 // (2) - 128 ^ n ............ need (n+1) bytes 355 // (3) - 128 ^ n * 63 ....... need (n+1) bytes 356 // (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) bytes 359 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)); 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 428 TEST(LEB128Test, ULEB128Size) { 429 // Testing Plan: 430 // (1) 128 ^ n ............ need (n+1) bytes 431 // (2) 128 ^ n * 64 ....... need (n+1) bytes 432 // (3) 128 ^ (n+1) - 1 .... need (n+1) bytes 433 434 EXPECT_EQ(1u, getULEB128Size(0)); // special case 435 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 namespace 478