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>
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 Stream.flush(); \
28 EXPECT_EQ(Expected, Actual1); \
29 \
30 /* encodeSLEB128(uint64_t, uint8_t *, unsigned) */ \
31 uint8_t Buffer[32]; \
32 unsigned Size = encodeSLEB128(VALUE, Buffer, PAD); \
33 std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
34 EXPECT_EQ(Expected, Actual2); \
35 } while (0)
36
37 // Encode SLEB128
38 EXPECT_SLEB128_EQ("\x00", 0, 0);
39 EXPECT_SLEB128_EQ("\x01", 1, 0);
40 EXPECT_SLEB128_EQ("\x7f", -1, 0);
41 EXPECT_SLEB128_EQ("\x3f", 63, 0);
42 EXPECT_SLEB128_EQ("\x41", -63, 0);
43 EXPECT_SLEB128_EQ("\x40", -64, 0);
44 EXPECT_SLEB128_EQ("\xbf\x7f", -65, 0);
45 EXPECT_SLEB128_EQ("\xc0\x00", 64, 0);
46
47 // Encode SLEB128 with some extra padding bytes
48 EXPECT_SLEB128_EQ("\x80\x00", 0, 2);
49 EXPECT_SLEB128_EQ("\x80\x80\x00", 0, 3);
50 EXPECT_SLEB128_EQ("\xff\x80\x00", 0x7f, 3);
51 EXPECT_SLEB128_EQ("\xff\x80\x80\x00", 0x7f, 4);
52 EXPECT_SLEB128_EQ("\x80\x81\x00", 0x80, 3);
53 EXPECT_SLEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
54 EXPECT_SLEB128_EQ("\xc0\x7f", -0x40, 2);
55
56 EXPECT_SLEB128_EQ("\xc0\xff\x7f", -0x40, 3);
57 EXPECT_SLEB128_EQ("\x80\xff\x7f", -0x80, 3);
58 EXPECT_SLEB128_EQ("\x80\xff\xff\x7f", -0x80, 4);
59
60#undef EXPECT_SLEB128_EQ
61}
62
63TEST(LEB128Test, EncodeULEB128) {
64#define EXPECT_ULEB128_EQ(EXPECTED, VALUE, PAD) \
65 do { \
66 std::string Expected(EXPECTED, sizeof(EXPECTED) - 1); \
67 \
68 /* encodeULEB128(uint64_t, raw_ostream &, unsigned) */ \
69 std::string Actual1; \
70 raw_string_ostream Stream(Actual1); \
71 encodeULEB128(VALUE, Stream, PAD); \
72 Stream.flush(); \
73 EXPECT_EQ(Expected, Actual1); \
74 \
75 /* encodeULEB128(uint64_t, uint8_t *, unsigned) */ \
76 uint8_t Buffer[32]; \
77 unsigned Size = encodeULEB128(VALUE, Buffer, PAD); \
78 std::string Actual2(reinterpret_cast<const char *>(Buffer), Size); \
79 EXPECT_EQ(Expected, Actual2); \
80 } while (0)
81
82 // Encode ULEB128
83 EXPECT_ULEB128_EQ("\x00", 0, 0);
84 EXPECT_ULEB128_EQ("\x01", 1, 0);
85 EXPECT_ULEB128_EQ("\x3f", 63, 0);
86 EXPECT_ULEB128_EQ("\x40", 64, 0);
87 EXPECT_ULEB128_EQ("\x7f", 0x7f, 0);
88 EXPECT_ULEB128_EQ("\x80\x01", 0x80, 0);
89 EXPECT_ULEB128_EQ("\x81\x01", 0x81, 0);
90 EXPECT_ULEB128_EQ("\x90\x01", 0x90, 0);
91 EXPECT_ULEB128_EQ("\xff\x01", 0xff, 0);
92 EXPECT_ULEB128_EQ("\x80\x02", 0x100, 0);
93 EXPECT_ULEB128_EQ("\x81\x02", 0x101, 0);
94
95 // Encode ULEB128 with some extra padding bytes
96 EXPECT_ULEB128_EQ("\x80\x00", 0, 2);
97 EXPECT_ULEB128_EQ("\x80\x80\x00", 0, 3);
98 EXPECT_ULEB128_EQ("\xff\x00", 0x7f, 2);
99 EXPECT_ULEB128_EQ("\xff\x80\x00", 0x7f, 3);
100 EXPECT_ULEB128_EQ("\x80\x81\x00", 0x80, 3);
101 EXPECT_ULEB128_EQ("\x80\x81\x80\x00", 0x80, 4);
102
103#undef EXPECT_ULEB128_EQ
104}
105
106TEST(LEB128Test, DecodeULEB128) {
107#define EXPECT_DECODE_ULEB128_EQ(EXPECTED, VALUE) \
108 do { \
109 unsigned ActualSize = 0; \
110 uint64_t Actual = decodeULEB128(reinterpret_cast<const uint8_t *>(VALUE), \
111 &ActualSize); \
112 EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
113 EXPECT_EQ(EXPECTED, Actual); \
114 } while (0)
115
116 // Don't crash
117 EXPECT_EQ(0u, decodeULEB128(nullptr, nullptr, nullptr));
118
119 // Decode ULEB128
120 EXPECT_DECODE_ULEB128_EQ(0u, "\x00");
121 EXPECT_DECODE_ULEB128_EQ(1u, "\x01");
122 EXPECT_DECODE_ULEB128_EQ(63u, "\x3f");
123 EXPECT_DECODE_ULEB128_EQ(64u, "\x40");
124 EXPECT_DECODE_ULEB128_EQ(0x7fu, "\x7f");
125 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x01");
126 EXPECT_DECODE_ULEB128_EQ(0x81u, "\x81\x01");
127 EXPECT_DECODE_ULEB128_EQ(0x90u, "\x90\x01");
128 EXPECT_DECODE_ULEB128_EQ(0xffu, "\xff\x01");
129 EXPECT_DECODE_ULEB128_EQ(0x100u, "\x80\x02");
130 EXPECT_DECODE_ULEB128_EQ(0x101u, "\x81\x02");
131 EXPECT_DECODE_ULEB128_EQ(4294975616ULL, "\x80\xc1\x80\x80\x10");
132
133 // Decode ULEB128 with extra padding bytes
134 EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x00");
135 EXPECT_DECODE_ULEB128_EQ(0u, "\x80\x80\x00");
136 EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x00");
137 EXPECT_DECODE_ULEB128_EQ(0x7fu, "\xff\x80\x00");
138 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x00");
139 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x00");
140 EXPECT_DECODE_ULEB128_EQ(0x80u, "\x80\x81\x80\x80\x80\x80\x80\x80\x80\x00");
141 EXPECT_DECODE_ULEB128_EQ(0x80000000'00000000ul,
142 "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01");
143
144#undef EXPECT_DECODE_ULEB128_EQ
145}
146
147TEST(LEB128Test, DecodeInvalidULEB128) {
148#define EXPECT_INVALID_ULEB128(VALUE, ERROR_OFFSET) \
149 do { \
150 const uint8_t *Value = reinterpret_cast<const uint8_t *>(VALUE); \
151 const char *Error = nullptr; \
152 unsigned ErrorOffset = 0; \
153 uint64_t Actual = \
154 decodeULEB128(Value, &ErrorOffset, Value + strlen(VALUE), &Error); \
155 EXPECT_NE(Error, nullptr); \
156 EXPECT_EQ(0ul, Actual); \
157 EXPECT_EQ(ERROR_OFFSET, ErrorOffset); \
158 } while (0)
159
160 // Buffer overflow.
161 EXPECT_INVALID_ULEB128("", 0u);
162 EXPECT_INVALID_ULEB128("\x80", 1u);
163
164 // Does not fit in 64 bits.
165 EXPECT_INVALID_ULEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 9u);
166 EXPECT_INVALID_ULEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 10u);
167
168#undef EXPECT_INVALID_ULEB128
169}
170
171TEST(LEB128Test, DecodeSLEB128) {
172#define EXPECT_DECODE_SLEB128_EQ(EXPECTED, VALUE) \
173 do { \
174 unsigned ActualSize = 0; \
175 int64_t Actual = decodeSLEB128(reinterpret_cast<const uint8_t *>(VALUE), \
176 &ActualSize); \
177 EXPECT_EQ(sizeof(VALUE) - 1, ActualSize); \
178 EXPECT_EQ(EXPECTED, Actual); \
179 } while (0)
180
181 // Don't crash
182 EXPECT_EQ(0, decodeSLEB128(nullptr, nullptr, nullptr));
183
184 // Decode SLEB128
185 EXPECT_DECODE_SLEB128_EQ(0L, "\x00");
186 EXPECT_DECODE_SLEB128_EQ(1L, "\x01");
187 EXPECT_DECODE_SLEB128_EQ(63L, "\x3f");
188 EXPECT_DECODE_SLEB128_EQ(-64L, "\x40");
189 EXPECT_DECODE_SLEB128_EQ(-63L, "\x41");
190 EXPECT_DECODE_SLEB128_EQ(-1L, "\x7f");
191 EXPECT_DECODE_SLEB128_EQ(128L, "\x80\x01");
192 EXPECT_DECODE_SLEB128_EQ(129L, "\x81\x01");
193 EXPECT_DECODE_SLEB128_EQ(-129L, "\xff\x7e");
194 EXPECT_DECODE_SLEB128_EQ(-128L, "\x80\x7f");
195 EXPECT_DECODE_SLEB128_EQ(-127L, "\x81\x7f");
196 EXPECT_DECODE_SLEB128_EQ(64L, "\xc0\x00");
197 EXPECT_DECODE_SLEB128_EQ(-12345L, "\xc7\x9f\x7f");
198
199 // Decode unnormalized SLEB128 with extra padding bytes.
200 EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x00");
201 EXPECT_DECODE_SLEB128_EQ(0L, "\x80\x80\x00");
202 EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x00");
203 EXPECT_DECODE_SLEB128_EQ(0x7fL, "\xff\x80\x00");
204 EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x00");
205 EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x00");
206 EXPECT_DECODE_SLEB128_EQ(0x80L, "\x80\x81\x80\x80\x80\x80\x80\x80\x80\x00");
207 EXPECT_DECODE_SLEB128_EQ(-2L, "\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7F");
208 EXPECT_DECODE_SLEB128_EQ(INT64_MIN,
209 "\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7F");
210 EXPECT_DECODE_SLEB128_EQ(INT64_MAX,
211 "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00");
212
213#undef EXPECT_DECODE_SLEB128_EQ
214}
215
216TEST(LEB128Test, DecodeInvalidSLEB128) {
217#define EXPECT_INVALID_SLEB128(VALUE, ERROR_OFFSET) \
218 do { \
219 const uint8_t *Value = reinterpret_cast<const uint8_t *>(VALUE); \
220 const char *Error = nullptr; \
221 unsigned ErrorOffset = 0; \
222 uint64_t Actual = \
223 decodeSLEB128(Value, &ErrorOffset, Value + strlen(VALUE), &Error); \
224 EXPECT_NE(Error, nullptr); \
225 EXPECT_EQ(0ul, Actual); \
226 EXPECT_EQ(ERROR_OFFSET, ErrorOffset); \
227 } while (0)
228
229 // Buffer overflow.
230 EXPECT_INVALID_SLEB128("", 0u);
231 EXPECT_INVALID_SLEB128("\x80", 1u);
232
233 // Does not fit in 64 bits.
234 EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 9u);
235 EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x7E", 9u);
236 EXPECT_INVALID_SLEB128("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x80\x02", 10u);
237 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7E", 9u);
238 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x01", 9u);
239 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x7E", 10u);
240 EXPECT_INVALID_SLEB128("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x00", 10u);
241
242#undef EXPECT_INVALID_SLEB128
243}
244
245TEST(LEB128Test, DecodeAndInc) {
246#define EXPECT_LEB128(FUN, VALUE, SIZE) \
247 do { \
248 const uint8_t *V = reinterpret_cast<const uint8_t *>(VALUE), *P = V; \
249 auto Expected = FUN(P), Actual = FUN##AndInc(P); \
250 EXPECT_EQ(Actual, Expected); \
251 EXPECT_EQ(P - V, SIZE); \
252 } while (0)
253 EXPECT_LEB128(decodeULEB128, "\x7f", 1);
254 EXPECT_LEB128(decodeULEB128, "\x80\x01", 2);
255 EXPECT_LEB128(decodeSLEB128, "\x7f", 1);
256 EXPECT_LEB128(decodeSLEB128, "\x80\x01", 2);
257#undef EXPECT_LEB128
258}
259
260TEST(LEB128Test, SLEB128Size) {
261 // Positive Value Testing Plan:
262 // (1) 128 ^ n - 1 ........ need (n+1) bytes
263 // (2) 128 ^ n ............ need (n+1) bytes
264 // (3) 128 ^ n * 63 ....... need (n+1) bytes
265 // (4) 128 ^ n * 64 - 1 ... need (n+1) bytes
266 // (5) 128 ^ n * 64 ....... need (n+2) bytes
267
268 EXPECT_EQ(1u, getSLEB128Size(0x0LL));
269 EXPECT_EQ(1u, getSLEB128Size(0x1LL));
270 EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
271 EXPECT_EQ(1u, getSLEB128Size(0x3fLL));
272 EXPECT_EQ(2u, getSLEB128Size(0x40LL));
273
274 EXPECT_EQ(2u, getSLEB128Size(0x7fLL));
275 EXPECT_EQ(2u, getSLEB128Size(0x80LL));
276 EXPECT_EQ(2u, getSLEB128Size(0x1f80LL));
277 EXPECT_EQ(2u, getSLEB128Size(0x1fffLL));
278 EXPECT_EQ(3u, getSLEB128Size(0x2000LL));
279
280 EXPECT_EQ(3u, getSLEB128Size(0x3fffLL));
281 EXPECT_EQ(3u, getSLEB128Size(0x4000LL));
282 EXPECT_EQ(3u, getSLEB128Size(0xfc000LL));
283 EXPECT_EQ(3u, getSLEB128Size(0xfffffLL));
284 EXPECT_EQ(4u, getSLEB128Size(0x100000LL));
285
286 EXPECT_EQ(4u, getSLEB128Size(0x1fffffLL));
287 EXPECT_EQ(4u, getSLEB128Size(0x200000LL));
288 EXPECT_EQ(4u, getSLEB128Size(0x7e00000LL));
289 EXPECT_EQ(4u, getSLEB128Size(0x7ffffffLL));
290 EXPECT_EQ(5u, getSLEB128Size(0x8000000LL));
291
292 EXPECT_EQ(5u, getSLEB128Size(0xfffffffLL));
293 EXPECT_EQ(5u, getSLEB128Size(0x10000000LL));
294 EXPECT_EQ(5u, getSLEB128Size(0x3f0000000LL));
295 EXPECT_EQ(5u, getSLEB128Size(0x3ffffffffLL));
296 EXPECT_EQ(6u, getSLEB128Size(0x400000000LL));
297
298 EXPECT_EQ(6u, getSLEB128Size(0x7ffffffffLL));
299 EXPECT_EQ(6u, getSLEB128Size(0x800000000LL));
300 EXPECT_EQ(6u, getSLEB128Size(0x1f800000000LL));
301 EXPECT_EQ(6u, getSLEB128Size(0x1ffffffffffLL));
302 EXPECT_EQ(7u, getSLEB128Size(0x20000000000LL));
303
304 EXPECT_EQ(7u, getSLEB128Size(0x3ffffffffffLL));
305 EXPECT_EQ(7u, getSLEB128Size(0x40000000000LL));
306 EXPECT_EQ(7u, getSLEB128Size(0xfc0000000000LL));
307 EXPECT_EQ(7u, getSLEB128Size(0xffffffffffffLL));
308 EXPECT_EQ(8u, getSLEB128Size(0x1000000000000LL));
309
310 EXPECT_EQ(8u, getSLEB128Size(0x1ffffffffffffLL));
311 EXPECT_EQ(8u, getSLEB128Size(0x2000000000000LL));
312 EXPECT_EQ(8u, getSLEB128Size(0x7e000000000000LL));
313 EXPECT_EQ(8u, getSLEB128Size(0x7fffffffffffffLL));
314 EXPECT_EQ(9u, getSLEB128Size(0x80000000000000LL));
315
316 EXPECT_EQ(9u, getSLEB128Size(0xffffffffffffffLL));
317 EXPECT_EQ(9u, getSLEB128Size(0x100000000000000LL));
318 EXPECT_EQ(9u, getSLEB128Size(0x3f00000000000000LL));
319 EXPECT_EQ(9u, getSLEB128Size(0x3fffffffffffffffLL));
320 EXPECT_EQ(10u, getSLEB128Size(0x4000000000000000LL));
321
322 EXPECT_EQ(10u, getSLEB128Size(0x7fffffffffffffffLL));
323 EXPECT_EQ(10u, getSLEB128Size(INT64_MAX));
324
325 // Negative Value Testing Plan:
326 // (1) - 128 ^ n - 1 ........ need (n+1) bytes
327 // (2) - 128 ^ n ............ need (n+1) bytes
328 // (3) - 128 ^ n * 63 ....... need (n+1) bytes
329 // (4) - 128 ^ n * 64 ....... need (n+1) bytes (different from positive one)
330 // (5) - 128 ^ n * 65 - 1 ... need (n+2) bytes (if n > 0)
331 // (6) - 128 ^ n * 65 ....... need (n+2) bytes
332
333 EXPECT_EQ(1u, getSLEB128Size(0x0LL));
334 EXPECT_EQ(1u, getSLEB128Size(-0x1LL));
335 EXPECT_EQ(1u, getSLEB128Size(-0x3fLL));
336 EXPECT_EQ(1u, getSLEB128Size(-0x40LL));
337 EXPECT_EQ(1u, getSLEB128Size(-0x40LL)); // special case
338 EXPECT_EQ(2u, getSLEB128Size(-0x41LL));
339
340 EXPECT_EQ(2u, getSLEB128Size(-0x7fLL));
341 EXPECT_EQ(2u, getSLEB128Size(-0x80LL));
342 EXPECT_EQ(2u, getSLEB128Size(-0x1f80LL));
343 EXPECT_EQ(2u, getSLEB128Size(-0x2000LL));
344 EXPECT_EQ(3u, getSLEB128Size(-0x207fLL));
345 EXPECT_EQ(3u, getSLEB128Size(-0x2080LL));
346
347 EXPECT_EQ(3u, getSLEB128Size(-0x3fffLL));
348 EXPECT_EQ(3u, getSLEB128Size(-0x4000LL));
349 EXPECT_EQ(3u, getSLEB128Size(-0xfc000LL));
350 EXPECT_EQ(3u, getSLEB128Size(-0x100000LL));
351 EXPECT_EQ(4u, getSLEB128Size(-0x103fffLL));
352 EXPECT_EQ(4u, getSLEB128Size(-0x104000LL));
353
354 EXPECT_EQ(4u, getSLEB128Size(-0x1fffffLL));
355 EXPECT_EQ(4u, getSLEB128Size(-0x200000LL));
356 EXPECT_EQ(4u, getSLEB128Size(-0x7e00000LL));
357 EXPECT_EQ(4u, getSLEB128Size(-0x8000000LL));
358 EXPECT_EQ(5u, getSLEB128Size(-0x81fffffLL));
359 EXPECT_EQ(5u, getSLEB128Size(-0x8200000LL));
360
361 EXPECT_EQ(5u, getSLEB128Size(-0xfffffffLL));
362 EXPECT_EQ(5u, getSLEB128Size(-0x10000000LL));
363 EXPECT_EQ(5u, getSLEB128Size(-0x3f0000000LL));
364 EXPECT_EQ(5u, getSLEB128Size(-0x400000000LL));
365 EXPECT_EQ(6u, getSLEB128Size(-0x40fffffffLL));
366 EXPECT_EQ(6u, getSLEB128Size(-0x410000000LL));
367
368 EXPECT_EQ(6u, getSLEB128Size(-0x7ffffffffLL));
369 EXPECT_EQ(6u, getSLEB128Size(-0x800000000LL));
370 EXPECT_EQ(6u, getSLEB128Size(-0x1f800000000LL));
371 EXPECT_EQ(6u, getSLEB128Size(-0x20000000000LL));
372 EXPECT_EQ(7u, getSLEB128Size(-0x207ffffffffLL));
373 EXPECT_EQ(7u, getSLEB128Size(-0x20800000000LL));
374
375 EXPECT_EQ(7u, getSLEB128Size(-0x3ffffffffffLL));
376 EXPECT_EQ(7u, getSLEB128Size(-0x40000000000LL));
377 EXPECT_EQ(7u, getSLEB128Size(-0xfc0000000000LL));
378 EXPECT_EQ(7u, getSLEB128Size(-0x1000000000000LL));
379 EXPECT_EQ(8u, getSLEB128Size(-0x103ffffffffffLL));
380 EXPECT_EQ(8u, getSLEB128Size(-0x1040000000000LL));
381
382 EXPECT_EQ(8u, getSLEB128Size(-0x1ffffffffffffLL));
383 EXPECT_EQ(8u, getSLEB128Size(-0x2000000000000LL));
384 EXPECT_EQ(8u, getSLEB128Size(-0x7e000000000000LL));
385 EXPECT_EQ(8u, getSLEB128Size(-0x80000000000000LL));
386 EXPECT_EQ(9u, getSLEB128Size(-0x81ffffffffffffLL));
387 EXPECT_EQ(9u, getSLEB128Size(-0x82000000000000LL));
388
389 EXPECT_EQ(9u, getSLEB128Size(-0xffffffffffffffLL));
390 EXPECT_EQ(9u, getSLEB128Size(-0x100000000000000LL));
391 EXPECT_EQ(9u, getSLEB128Size(-0x3f00000000000000LL));
392 EXPECT_EQ(9u, getSLEB128Size(-0x4000000000000000LL));
393 EXPECT_EQ(10u, getSLEB128Size(-0x40ffffffffffffffLL));
394 EXPECT_EQ(10u, getSLEB128Size(-0x4100000000000000LL));
395
396 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL));
397 EXPECT_EQ(10u, getSLEB128Size(-0x7fffffffffffffffLL - 1));
398 EXPECT_EQ(10u, getSLEB128Size(INT64_MIN));
399}
400
401TEST(LEB128Test, ULEB128Size) {
402 // Testing Plan:
403 // (1) 128 ^ n ............ need (n+1) bytes
404 // (2) 128 ^ n * 64 ....... need (n+1) bytes
405 // (3) 128 ^ (n+1) - 1 .... need (n+1) bytes
406
407 EXPECT_EQ(1u, getULEB128Size(0)); // special case
408
409 EXPECT_EQ(1u, getULEB128Size(0x1ULL));
410 EXPECT_EQ(1u, getULEB128Size(0x40ULL));
411 EXPECT_EQ(1u, getULEB128Size(0x7fULL));
412
413 EXPECT_EQ(2u, getULEB128Size(0x80ULL));
414 EXPECT_EQ(2u, getULEB128Size(0x2000ULL));
415 EXPECT_EQ(2u, getULEB128Size(0x3fffULL));
416
417 EXPECT_EQ(3u, getULEB128Size(0x4000ULL));
418 EXPECT_EQ(3u, getULEB128Size(0x100000ULL));
419 EXPECT_EQ(3u, getULEB128Size(0x1fffffULL));
420
421 EXPECT_EQ(4u, getULEB128Size(0x200000ULL));
422 EXPECT_EQ(4u, getULEB128Size(0x8000000ULL));
423 EXPECT_EQ(4u, getULEB128Size(0xfffffffULL));
424
425 EXPECT_EQ(5u, getULEB128Size(0x10000000ULL));
426 EXPECT_EQ(5u, getULEB128Size(0x400000000ULL));
427 EXPECT_EQ(5u, getULEB128Size(0x7ffffffffULL));
428
429 EXPECT_EQ(6u, getULEB128Size(0x800000000ULL));
430 EXPECT_EQ(6u, getULEB128Size(0x20000000000ULL));
431 EXPECT_EQ(6u, getULEB128Size(0x3ffffffffffULL));
432
433 EXPECT_EQ(7u, getULEB128Size(0x40000000000ULL));
434 EXPECT_EQ(7u, getULEB128Size(0x1000000000000ULL));
435 EXPECT_EQ(7u, getULEB128Size(0x1ffffffffffffULL));
436
437 EXPECT_EQ(8u, getULEB128Size(0x2000000000000ULL));
438 EXPECT_EQ(8u, getULEB128Size(0x80000000000000ULL));
439 EXPECT_EQ(8u, getULEB128Size(0xffffffffffffffULL));
440
441 EXPECT_EQ(9u, getULEB128Size(0x100000000000000ULL));
442 EXPECT_EQ(9u, getULEB128Size(0x4000000000000000ULL));
443 EXPECT_EQ(9u, getULEB128Size(0x7fffffffffffffffULL));
444
445 EXPECT_EQ(10u, getULEB128Size(0x8000000000000000ULL));
446
447 EXPECT_EQ(10u, getULEB128Size(UINT64_MAX));
448}
449
450} // anonymous namespace
451

source code of llvm/unittests/Support/LEB128Test.cpp