[Support] Add APInt support for LEB128 encoding/decoding

[nlguillemot]

Summary

This specializes the LEB128CodecInfo template for APInt, which allows
the input/output iterators used for LEB128 encoding/decoding to be used
with APInt. As a convenience, the encode[U|S]LEB128() functions in
LEB128.h have been overloaded for APInt. The decode[U|S]LEB128()
functions were not customized for APInt. If one wants to decode an
APInt, they can do so with the more general decodeLEB128<T> function.

For testing, new unit tests were created based on the existing LEB128
tests. These tests run the previously existing test inputs, and they
also run a "big" version of the previous inputs. The "big" versions are
created by adding a "big prefix" to the previous "small" inputs. These
"big" versions of the tests exercise the ability of APInt to be usable
to encode and decode values bigger than 64 bits.

llvm/include/llvm/Support/LEB128.h

 }
 
 /// Utility function to encode a ULEB128 value to a buffer. Returns
 /// the length in bytes of the encoded value.
 inline unsigned encodeULEB128(uint64_t Value, uint8_t *p, unsigned PadTo = 0) {
   return encodeLEB128(Value, /* IsSigned */ false, p, PadTo);
 }
 
+/// Utility function to encode a SLEB128 value to an output stream. Returns
+/// the length in bytes of the encoded value.
+inline unsigned encodeSLEB128(const APInt &Value, raw_ostream &OS,
+                              unsigned PadTo = 0) {
+  return encodeLEB128(Value, /* IsSigned */ true, OS, PadTo);
+}
+
+/// Utility function to encode a SLEB128 value to a buffer. Returns
+/// the length in bytes of the encoded value.
+inline unsigned encodeSLEB128(const APInt &Value, uint8_t *p,
+                              unsigned PadTo = 0) {
+  return encodeLEB128(Value, /* IsSigned */ true, p, PadTo);
+}
+
+/// Utility function to encode a ULEB128 value to an output stream. Returns
+/// the length in bytes of the encoded value.
+inline unsigned encodeULEB128(const APInt &Value, raw_ostream &OS,
+                              unsigned PadTo = 0) {
+  return encodeLEB128(Value, /* IsSigned */ false, OS, PadTo);
+}
+
+/// Utility function to encode a ULEB128 value to a buffer. Returns
+/// the length in bytes of the encoded value.
+inline unsigned encodeULEB128(const APInt &Value, uint8_t *p,
+                              unsigned PadTo = 0) {
+  return encodeLEB128(Value, /* IsSigned */ false, p, PadTo);
+}
+
 /// Utility function to decode a ULEB128/SLEB128 value, where the signedness is
 /// defined by \p IsSigned.
 template <class ValueT>
 ValueT decodeLEB128(const uint8_t *p, bool IsSigned, unsigned *n = nullptr,
                     const uint8_t *end = nullptr,
                     const char **error = nullptr) {
   ValueT Value;
   LEB128OutputIterator<ValueT> Decoder(Value, IsSigned);

llvm/include/llvm/Support/LEB128CodecInfo.h

 //===- llvm/Support/LEB128CodecInfo.h - Type traits for LEB128 --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines LEB128CodecInfo traits for [SU]LEB128 encoding/decoding.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_LEB128CODECINFO_H
 #define LLVM_SUPPORT_LEB128CODECINFO_H
 
+#include "llvm/ADT/APInt.h"
+#include <algorithm>
 #include <cstdint>
 #include <type_traits>
 
 namespace llvm {
 
 /// The basic operations required to be supported by a type in order to be used
 /// as the source of LEB128 encoding or the destination of LEB128 decoding.
 ///
static void insertLo7InPlace(ValueT &Value, uint8_t Lo7, unsigned Shift) {
     Value |= static_cast<ValueT>(Lo7) << Shift;
   }
 
   static void negSExtInPlace(ValueT &Value, unsigned NumUnextendedBits) {
     Value |= ~static_cast<ValueT>(0) << NumUnextendedBits;
   }
 };
 
+/// Specialization of LEB128CodecInfo for APInt.
+template <> struct LEB128CodecInfo<APInt> {
+  static uint8_t getLo7Bits(const APInt &Value) {
+    return Value.extractBitsAsZExtValue(getNumLoBits(Value), 0);
+  }
+
+  static void lshr7InPlace(APInt &Value) {
+    Value.lshrInPlace(getNumLoBits(Value));
+  }
+
+  static void ashr7InPlace(APInt &Value) {
+    Value.ashrInPlace(getNumLoBits(Value));
+  }
+
+  static bool isAllOnesValue(const APInt &Value) {
+    return Value.isAllOnesValue();
+  }
+
+  static unsigned getMaxNumBits() {
+    // In practice, APInt has an unbounded number of bits.
+    return ~0U;
+  }
+
+  static void insertLo7InPlace(APInt &Value, uint8_t Lo7, unsigned Shift) {
+    // Resize to have room to put the new bits.
+    Value = Value.zext(Shift + 7);
+    // Copy the bits into the new room.
+    Value.insertBits(Lo7, Shift, 7);
+  }
+
+  static void negSExtInPlace(APInt &Value, unsigned NumUnextendedBits) {
+    // Don't need to do anything. APInts don't need any more than one signed
+    // bit, and we know that Value is a negative number as a precondition to
+    // this function, so any further sign extension would be redundant.
+    // Extending it any further would only be useful if we wanted to match a
+    // specific bit width, which is not required here.
+  }
+
+private:
+  /// If an APInt has fewer than 7 bits, trying to do operations on its 7 lowest
+  /// bits will fail due to constraints of the API of APInt. To counter this, do
+  /// operations on fewer than 7 bits when necessary, using this function to
+  /// count the number of bits to use.
+  static unsigned getNumLoBits(const APInt &Value) {
+    return std::min(7U, Value.getBitWidth());
+  }
+};
+
 } // namespace llvm
 
 #endif // LLVM_SUPPORT_LEB128CODECINFO_H

llvm/unittests/Support/LEB128Test.cpp

 #include "llvm/Support/DataTypes.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 #include <string>
 using namespace llvm;
 
 namespace {
 
+// To test encoding/decoding with APInts, the previously existing tests are
+// reused but prepended with a "big prefix" that turns the number into something
+// too big for an ordinary 64-bit integer.
+const unsigned BigPrefixWordSizeInBits = 16;
+const unsigned BigPrefixNumWords = 8;
+const unsigned BigPrefixNumBytes = BigPrefixNumWords * 2;
+
+// Adds the "big prefix" to a string that represents an encoded test case.
+std::string addBigPrefix(const std::string &Base) {
+  const char *BigPrefixWord = "\xff\x81";
+  std::string BigPrefix;
+  for (unsigned i = 0; i < BigPrefixNumWords; i++)
+    BigPrefix += BigPrefixWord;
+  return BigPrefix + Base;
+}
+
+// Takes a value used for a normal unit tests, and shifts in a big number before
+// it to turn it into something that wouldn't fit in a 64-bit integer.
+APInt makeBigValue(int64_t BaseValue) {
+  // This function deals with values that aren't yet LEB128 encoded. Therefore,
+  // the continuation bits are not necessary. The -2 here and the difference in
+  // the BigPrefixWord from addBigPrefix comes from these continuation bits
+  // being removed.
+  const unsigned BigPrefixWordSizeInBitsWithoutCont =
+      BigPrefixWordSizeInBits - 2;
+  const uint16_t BigPrefixWord = 0x00ff;
+  // Allocate enough for the prefix and the original value afterwards.
+  APInt Big(BigPrefixNumWords * BigPrefixWordSizeInBitsWithoutCont + 64, 0);
+  // Fill in the prefix bits.
+  for (unsigned i = 0; i < BigPrefixNumWords; i++)
+    Big.insertBits(BigPrefixWord, i * BigPrefixWordSizeInBitsWithoutCont,
+                   BigPrefixWordSizeInBitsWithoutCont);
+  // Put the original value in the last 64 bits.
+  Big.insertBits(BaseValue,
+                 BigPrefixNumWords * BigPrefixWordSizeInBitsWithoutCont, 64);
+  return Big;
+}
+
 TEST(LEB128Test, EncodeSLEB128) {
 #define EXPECT_SLEB128_EQ(EXPECTED, VALUE, PAD) \
   do { \
     std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \
     \
     /* encodeSLEB128(uint64_t, raw_ostream &, unsigned) */ \
     std::string Actual1; \
     raw_string_ostream Stream(Actual1); \
#define EXPECT_SLEB128_EQ(EXPECTED, VALUE, PAD) \
 
   EXPECT_SLEB128_EQ("\xc0\xff\x7f", -0x40, 3);
   EXPECT_SLEB128_EQ("\x80\xff\x7f", -0x80, 3);
   EXPECT_SLEB128_EQ("\x80\xff\xff\x7f", -0x80, 4);
 
 #undef EXPECT_SLEB128_EQ
 }
 
+TEST(LEB128Test, EncodeSLEB128APInt) {
+#define EXPECT_SLEB128_EQ(EXPECTED, VALUE, PAD) \
+  do { \
+    std::string ShortExpected(EXPECTED, sizeof(EXPECTED) - 1); \
+    std::string BigExpected = addBigPrefix(ShortExpected); \
+    APInt ShortValue = APInt(64, VALUE); \
+    APInt BigValue = makeBigValue(VALUE); \
+    unsigned ShortPad = PAD; \
+    unsigned BigPad = PAD ? PAD + BigPrefixNumBytes : 0; \
+    for (int Big = 0; Big <= 1; Big++) { \
+    \
+    /* Prefixing zero doesn't give a canonical representation */ \
+    /* (unless it's padding), so skip. */ \
+    if (Big && VALUE == 0 && PAD == 0) \
+      continue; \
+    const std::string &Expected = Big ? BigExpected : ShortExpected; \
+    const APInt& Value = Big ? BigValue : ShortValue; \
+    unsigned Pad = Big ? BigPad : ShortPad; \
+    \
+    /* encodeSLEB128(APInt, raw_ostream &, unsigned) */ \
+    std::string Actual1; \
+    raw_string_ostream Stream(Actual1); \
+    encodeSLEB128(Value, Stream, Pad); \
+    Stream.flush(); \
+    EXPECT_EQ(Expected, Actual1); \
+    \
+    /* encodeSLEB128(APInt, uint8_t *, unsigned) */ \
+    uint8_t Buffer[32]; \
+    unsigned Size = encodeSLEB128(Value, Buffer, Pad); \
+    std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
+    EXPECT_EQ(Expected, Actual2); \
+    \
+    } /* end "Big" loop */ \
+  } while (0)
+
+  // Encode SLEB128
+  EXPECT_SLEB128_EQ("\x00", 0, 0);
+  EXPECT_SLEB128_EQ("\x01", 1, 0);
+  EXPECT_SLEB128_EQ("\x7f", -1, 0);
+  EXPECT_SLEB128_EQ("\x3f", 63, 0);
+  EXPECT_SLEB128_EQ("\x41", -63, 0);
+  EXPECT_SLEB128_EQ("\x40", -64, 0);
+  EXPECT_SLEB128_EQ("\xbf\x7f", -65, 0);
+  EXPECT_SLEB128_EQ("\xc0\x00", 64, 0);
+
+  // Encode SLEB128 with some extra padding bytes
+  EXPECT_SLEB128_EQ("\x80\x00", 0, 2);
+  EXPECT_SLEB128_EQ("\x80\x80\x00", 0, 3);
+  EXPECT_SLEB128_EQ("\xff\x80\x00", 0x7f, 3);
+  EXPECT_SLEB128_EQ("\xff\x80\x80\x00", 0x7f, 4);
+  EXPECT_SLEB128_EQ("\x80\x81\x00", 0x80, 3);
+  EXPECT_SLEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
+  EXPECT_SLEB128_EQ("\xc0\x7f", -0x40, 2);
+
+  EXPECT_SLEB128_EQ("\xc0\xff\x7f", -0x40, 3);
+  EXPECT_SLEB128_EQ("\x80\xff\x7f", -0x80, 3);
+  EXPECT_SLEB128_EQ("\x80\xff\xff\x7f", -0x80, 4);
+
+#undef EXPECT_SLEB128_EQ
+}
+
 TEST(LEB128Test, EncodeULEB128) {
 #define EXPECT_ULEB128_EQ(EXPECTED, VALUE, PAD) \
   do { \
     std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \
     \
     /* encodeULEB128(uint64_t, raw_ostream &, unsigned) */ \
     std::string Actual1; \
     raw_string_ostream Stream(Actual1); \
#define EXPECT_ULEB128_EQ(EXPECTED, VALUE, PAD) \
   EXPECT_ULEB128_EQ("\xff\x00", 0x7f, 2);
   EXPECT_ULEB128_EQ("\xff\x80\x00", 0x7f, 3);
   EXPECT_ULEB128_EQ("\x80\x81\x00", 0x80, 3);
   EXPECT_ULEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
 
 #undef EXPECT_ULEB128_EQ
 }
 
+TEST(LEB128Test, EncodeULEB128APInt) {
+#define EXPECT_ULEB128_EQ(EXPECTED, VALUE, PAD) \
+  do { \
+    std::string ShortExpected(EXPECTED, sizeof(EXPECTED) - 1); \
+    std::string BigExpected = addBigPrefix(ShortExpected); \
+    APInt ShortValue = APInt(64, VALUE); \
+    APInt BigValue = makeBigValue(VALUE); \
+    unsigned ShortPad = PAD; \
+    unsigned BigPad = PAD ? PAD + BigPrefixNumBytes : 0; \
+    for (int Big = 0; Big <= 1; Big++) { \
+    \
+    /* Prefixing zero doesn't give a canonical representation */ \
+    /* (unless it's padding), so skip. */ \
+    if (Big && VALUE == 0 && PAD == 0) \
+      continue; \
+    const std::string &Expected = Big ? BigExpected : ShortExpected; \
+    const APInt& Value = Big ? BigValue : ShortValue; \
+    unsigned Pad = Big ? BigPad : ShortPad; \
+    \
+    /* encodeULEB128(APInt, raw_ostream &, unsigned) */ \
+    std::string Actual1; \
+    raw_string_ostream Stream(Actual1); \
+    encodeULEB128(Value, Stream, Pad); \
+    Stream.flush(); \
+    EXPECT_EQ(Expected, Actual1); \
+    \
+    /* encodeULEB128(APInt, uint8_t *, unsigned) */ \
+    uint8_t Buffer[32]; \
+    unsigned Size = encodeULEB128(Value, Buffer, Pad); \
+    std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
+    EXPECT_EQ(Expected, Actual2); \
+    \
+    } /* end "Big" loop */ \
+  } while (0)
+
+  // Encode ULEB128
+  EXPECT_ULEB128_EQ("\x00", 0, 0);
+  EXPECT_ULEB128_EQ("\x01", 1, 0);
+  EXPECT_ULEB128_EQ("\x3f", 63, 0);
+  EXPECT_ULEB128_EQ("\x40", 64, 0);
+  EXPECT_ULEB128_EQ("\x7f", 0x7f, 0);
+  EXPECT_ULEB128_EQ("\x80\x01", 0x80, 0);
+  EXPECT_ULEB128_EQ("\x81\x01", 0x81, 0);
+  EXPECT_ULEB128_EQ("\x90\x01", 0x90, 0);
+  EXPECT_ULEB128_EQ("\xff\x01", 0xff, 0);
+  EXPECT_ULEB128_EQ("\x80\x02", 0x100, 0);
+  EXPECT_ULEB128_EQ("\x81\x02", 0x101, 0);
+
+  // Encode ULEB128 with some extra padding bytes
+  EXPECT_ULEB128_EQ("\x80\x00", 0, 2);
+  EXPECT_ULEB128_EQ("\x80\x80\x00", 0, 3);
+  EXPECT_ULEB128_EQ("\xff\x00", 0x7f, 2);
+  EXPECT_ULEB128_EQ("\xff\x80\x00", 0x7f, 3);
+  EXPECT_ULEB128_EQ("\x80\x81\x00", 0x80, 3);
+  EXPECT_ULEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
+
+#undef EXPECT_ULEB128_EQ
+}
+
 TEST(LEB128Test, DecodeULEB128) {
 #define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \
   do { \
     unsigned ActualSize = 0; \
     uint64_t Actual = decodeULEB128(reinterpret_cast<const uint8_t *>(VALUE), \
                                     &ActualSize); \
     EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
     EXPECT_EQ(EXPECTED, Actual); \
#define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \
   EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x00");
   EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x80\x00");
   EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x00");
   EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x00");
 
 #undef EXPECT_DECODE_ULEB128_EQ
 }
 
+TEST(LEB128Test, DecodeULEB128APInt) {
+#define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \
+  do { \
+    std::string ShortValue(VALUE, sizeof(VALUE) - 1); \
+    std::string BigValue = addBigPrefix(ShortValue); \
+    APInt ShortExpected = APInt(64, EXPECTED); \
+    APInt BigExpected = makeBigValue(EXPECTED); \
+    for (int Big = 0; Big <= 1; Big++) { \
+    \
+    const std::string &Value = Big ? BigValue : ShortValue; \
+    const APInt& Expected = Big ? BigExpected : ShortExpected; \
+    unsigned ExpectedSize = sizeof(VALUE) - 1 + (Big ? BigPrefixNumBytes : 0); \
+    \
+    unsigned ActualSize = 0; \
+    APInt Actual = \
+        decodeLEB128<APInt>(reinterpret_cast<const uint8_t *>(Value.data()), \
+                            /* IsSigned */ false, &ActualSize); \
+    EXPECT_EQ(ExpectedSize, ActualSize); \
+    EXPECT_EQ(Expected, Actual.zextOrSelf(Expected.getBitWidth())); \
+    \
+    } /* end "Big" loop */ \
+  } while (0)
+
+  // Don't crash
+  EXPECT_EQ(0u, decodeULEB128(nullptr, nullptr, nullptr));
+
+  // Decode ULEB128
+  EXPECT_DECODE_ULEB128_EQ(0u, "\x00");
+  EXPECT_DECODE_ULEB128_EQ(1u, "\x01");
+  EXPECT_DECODE_ULEB128_EQ(63u, "\x3f");
+  EXPECT_DECODE_ULEB128_EQ(64u, "\x40");
+  EXPECT_DECODE_ULEB128_EQ(0x7fu, "\x7f");
+  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x01");
+  EXPECT_DECODE_ULEB128_EQ(0x81u, "\x81\x01");
+  EXPECT_DECODE_ULEB128_EQ(0x90u, "\x90\x01");
+  EXPECT_DECODE_ULEB128_EQ(0xffu, "\xff\x01");
+  EXPECT_DECODE_ULEB128_EQ(0x100u, "\x80\x02");
+  EXPECT_DECODE_ULEB128_EQ(0x101u, "\x81\x02");
+  EXPECT_DECODE_ULEB128_EQ(4294975616ULL, "\x80\xc1\x80\x80\x10");
+
+  // Decode ULEB128 with extra padding bytes
+  EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x00");
+  EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x80\x00");
+  EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x00");
+  EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x80\x00");
+  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x00");
+  EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x00");
+
+#undef EXPECT_DECODE_ULEB128_EQ
+}
+
 TEST(LEB128Test, DecodeSLEB128) {
 #define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \
   do { \
     unsigned ActualSize = 0; \
     int64_t Actual = decodeSLEB128(reinterpret_cast<const uint8_t *>(VALUE), \
                                     &ActualSize); \
     EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
     EXPECT_EQ(EXPECTED, Actual); \
#define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \
   EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x00");
   EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x80\x00");
   EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x00");
   EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x00");
 
 #undef EXPECT_DECODE_SLEB128_EQ
 }
 
+TEST(LEB128Test, DecodeSLEB128APInt) {
+#define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \
+  do { \
+    std::string ShortValue(VALUE, sizeof(VALUE) - 1); \
+    std::string BigValue = addBigPrefix(ShortValue); \
+    APInt ShortExpected = APInt(64, EXPECTED); \
+    APInt BigExpected = makeBigValue(EXPECTED); \
+    for (int Big = 0; Big <= 1; Big++) { \
+    \
+    const std::string &Value = Big ? BigValue : ShortValue; \
+    const APInt& Expected = Big ? BigExpected : ShortExpected; \
+    unsigned ExpectedSize = sizeof(VALUE) - 1 + (Big ? BigPrefixNumBytes : 0); \
+    \
+    unsigned ActualSize = 0; \
+    APInt Actual = \
+        decodeLEB128<APInt>(reinterpret_cast<const uint8_t *>(Value.data()), \
+                            /* IsSigned */ true, &ActualSize); \
+    EXPECT_EQ(ExpectedSize, ActualSize); \
+    EXPECT_EQ(Expected, Actual.sextOrSelf(Expected.getBitWidth())); \
+    \
+    } /* end "Big" loop */ \
+  } while (0)
+
+  // Don't crash
+  EXPECT_EQ(0, decodeSLEB128(nullptr, nullptr, nullptr));
+
+  // Decode SLEB128
+  EXPECT_DECODE_SLEB128_EQ(0L, "\x00");
+  EXPECT_DECODE_SLEB128_EQ(1L, "\x01");
+  EXPECT_DECODE_SLEB128_EQ(63L, "\x3f");
+  EXPECT_DECODE_SLEB128_EQ(-64L, "\x40");
+  EXPECT_DECODE_SLEB128_EQ(-63L, "\x41");
+  EXPECT_DECODE_SLEB128_EQ(-1L, "\x7f");
+  EXPECT_DECODE_SLEB128_EQ(128L, "\x80\x01");
+  EXPECT_DECODE_SLEB128_EQ(129L, "\x81\x01");
+  EXPECT_DECODE_SLEB128_EQ(-129L, "\xff\x7e");
+  EXPECT_DECODE_SLEB128_EQ(-128L, "\x80\x7f");
+  EXPECT_DECODE_SLEB128_EQ(-127L, "\x81\x7f");
+  EXPECT_DECODE_SLEB128_EQ(64L, "\xc0\x00");
+  EXPECT_DECODE_SLEB128_EQ(-12345L, "\xc7\x9f\x7f");
+
+  // Decode unnormalized SLEB128 with extra padding bytes.
+  EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x00");
+  EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x80\x00");
+  EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x00");
+  EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x80\x00");
+  EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x00");
+  EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x00");
+
+#undef EXPECT_DECODE_SLEB128_EQ
+}
+
 TEST(LEB128Test, SLEB128Size) {
   // Positive Value Testing Plan:
   // (1) 128 ^ n - 1 ........ need (n+1) bytes
   // (2) 128 ^ n ............ need (n+1) bytes
   // (3) 128 ^ n * 63 ....... need (n+1) bytes
   // (4) 128 ^ n * 64 - 1 ... need (n+1) bytes
   // (5) 128 ^ n * 64 ....... need (n+2) bytes