llvm/unittests/Support/LEB128Test.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-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