#ifndef _LINUX_NTFS_LIB_DECOMPRESS_COMMON_H
#define _LINUX_NTFS_LIB_DECOMPRESS_COMMON_H
#include <linux/compiler.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/unaligned.h>
#define forceinline __always_inline
#define WORDBYTES sizeof(size_t)
#define WORDBITS (8 * WORDBYTES)
#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
# define UNALIGNED_ACCESS_IS_FAST 1
#else
# define UNALIGNED_ACCESS_IS_FAST 0
#endif
#define FAST_UNALIGNED_ACCESS UNALIGNED_ACCESS_IS_FAST
#define STATIC_ASSERT(expr) ((void)sizeof(char[1 - 2 * !(expr)]))
#define STATIC_ASSERT_ZERO(expr) ((int)sizeof(char[-!(expr)]))
static forceinline size_t load_word_unaligned(const void *p)
{
size_t v;
memcpy(&v, p, sizeof(v));
return v;
}
static forceinline void store_word_unaligned(size_t v, void *p)
{
memcpy(p, &v, sizeof(v));
}
static forceinline void copy_word_unaligned(const void *src, void *dst)
{
store_word_unaligned(load_word_unaligned(src), dst);
}
static forceinline size_t repeat_u16(u16 b)
{
size_t v = b;
STATIC_ASSERT(WORDBITS == 32 || WORDBITS == 64);
v |= v << 16;
v |= v << ((WORDBITS == 64) ? 32 : 0);
return v;
}
static forceinline size_t repeat_byte(u8 b)
{
return repeat_u16(((u16)b << 8) | b);
}
struct input_bitstream {
u32 bitbuf;
u32 bitsleft;
const u8 *next;
const u8 *end;
};
static forceinline void init_input_bitstream(struct input_bitstream *is,
const void *buffer, u32 size)
{
is->bitbuf = 0;
is->bitsleft = 0;
is->next = buffer;
is->end = is->next + size;
}
static forceinline void bitstream_ensure_bits(struct input_bitstream *is,
unsigned int num_bits)
{
if (is->bitsleft >= num_bits)
return;
if (unlikely(is->end - is->next < 2))
goto overflow;
is->bitbuf |= (u32)get_unaligned_le16(is->next) << (16 - is->bitsleft);
is->next += 2;
is->bitsleft += 16;
return;
overflow:
is->bitsleft = 32;
}
static forceinline u32 bitstream_peek_bits(const struct input_bitstream *is,
unsigned int num_bits)
{
return (is->bitbuf >> 1) >> (sizeof(is->bitbuf) * 8 - num_bits - 1);
}
static forceinline void bitstream_remove_bits(struct input_bitstream *is,
unsigned int num_bits)
{
is->bitbuf <<= num_bits;
is->bitsleft -= num_bits;
}
static forceinline u32 bitstream_pop_bits(struct input_bitstream *is,
unsigned int num_bits)
{
u32 bits = bitstream_peek_bits(is, num_bits);
bitstream_remove_bits(is, num_bits);
return bits;
}
static forceinline u32 bitstream_read_bits(struct input_bitstream *is,
unsigned int num_bits)
{
bitstream_ensure_bits(is, num_bits);
return bitstream_pop_bits(is, num_bits);
}
static forceinline u8 bitstream_read_byte(struct input_bitstream *is)
{
if (unlikely(is->end == is->next))
return 0;
return *is->next++;
}
static forceinline u16 bitstream_read_u16(struct input_bitstream *is)
{
u16 v;
if (unlikely(is->end - is->next < 2))
return 0;
v = get_unaligned_le16(is->next);
is->next += 2;
return v;
}
static forceinline u32 bitstream_read_u32(struct input_bitstream *is)
{
u32 v;
if (unlikely(is->end - is->next < 4))
return 0;
v = get_unaligned_le32(is->next);
is->next += 4;
return v;
}
static forceinline int bitstream_read_bytes(struct input_bitstream *is,
void *dst_buffer, size_t count)
{
if (unlikely((size_t)(is->end - is->next) < count))
return -1;
memcpy(dst_buffer, is->next, count);
is->next += count;
return 0;
}
static forceinline void bitstream_align(struct input_bitstream *is)
{
is->bitsleft = 0;
is->bitbuf = 0;
}
#define DECODE_TABLE_ALIGNMENT 16
#define DECODE_TABLE_SYMBOL_SHIFT 4
#define DECODE_TABLE_MAX_SYMBOL ((1 << (16 - DECODE_TABLE_SYMBOL_SHIFT)) - 1)
#define DECODE_TABLE_MAX_LENGTH ((1 << DECODE_TABLE_SYMBOL_SHIFT) - 1)
#define DECODE_TABLE_LENGTH_MASK DECODE_TABLE_MAX_LENGTH
#define MAKE_DECODE_TABLE_ENTRY(symbol, length) \
(((symbol) << DECODE_TABLE_SYMBOL_SHIFT) | (length))
static forceinline unsigned int read_huffsym(struct input_bitstream *is,
const u16 decode_table[],
unsigned int table_bits,
unsigned int max_codeword_len)
{
unsigned int entry;
unsigned int symbol;
unsigned int length;
bitstream_ensure_bits(is, max_codeword_len);
entry = decode_table[bitstream_peek_bits(is, table_bits)];
symbol = entry >> DECODE_TABLE_SYMBOL_SHIFT;
length = entry & DECODE_TABLE_LENGTH_MASK;
if (max_codeword_len > table_bits &&
entry >= (1U << (table_bits + DECODE_TABLE_SYMBOL_SHIFT))) {
bitstream_remove_bits(is, table_bits);
entry = decode_table[symbol + bitstream_peek_bits(is, length)];
symbol = entry >> DECODE_TABLE_SYMBOL_SHIFT;
length = entry & DECODE_TABLE_LENGTH_MASK;
}
bitstream_remove_bits(is, length);
return symbol;
}
#define DECODE_TABLE_ENOUGH(num_syms, table_bits, max_codeword_len) ( \
((num_syms) == 8 && (table_bits) == 5 && (max_codeword_len) == 7) ? 36 : \
((num_syms) == 8 && (table_bits) == 6 && (max_codeword_len) == 7) ? 66 : \
((num_syms) == 8 && (table_bits) == 7 && (max_codeword_len) == 7) ? 128 : \
((num_syms) == 20 && (table_bits) == 5 && (max_codeword_len) == 15) ? 1062 : \
((num_syms) == 20 && (table_bits) == 6 && (max_codeword_len) == 15) ? 582 : \
((num_syms) == 20 && (table_bits) == 7 && (max_codeword_len) == 15) ? 390 : \
((num_syms) == 54 && (table_bits) == 9 && (max_codeword_len) == 15) ? 618 : \
((num_syms) == 54 && (table_bits) == 10 && (max_codeword_len) == 15) ? 1098 : \
((num_syms) == 249 && (table_bits) == 9 && (max_codeword_len) == 16) ? 878 : \
((num_syms) == 249 && (table_bits) == 10 && (max_codeword_len) == 16) ? 1326 : \
((num_syms) == 249 && (table_bits) == 11 && (max_codeword_len) == 16) ? 2318 : \
((num_syms) == 496 && (table_bits) == 11 && (max_codeword_len) == 16) ? 2566 : \
((num_syms) == 256 && (table_bits) == 9 && (max_codeword_len) == 15) ? 822 : \
((num_syms) == 256 && (table_bits) == 10 && (max_codeword_len) == 15) ? 1302 : \
((num_syms) == 256 && (table_bits) == 11 && (max_codeword_len) == 15) ? 2310 : \
((num_syms) == 512 && (table_bits) == 10 && (max_codeword_len) == 15) ? 1558 : \
((num_syms) == 512 && (table_bits) == 11 && (max_codeword_len) == 15) ? 2566 : \
((num_syms) == 512 && (table_bits) == 12 && (max_codeword_len) == 15) ? 4606 : \
((num_syms) == 656 && (table_bits) == 10 && (max_codeword_len) == 16) ? 1734 : \
((num_syms) == 656 && (table_bits) == 11 && (max_codeword_len) == 16) ? 2726 : \
((num_syms) == 656 && (table_bits) == 12 && (max_codeword_len) == 16) ? 4758 : \
((num_syms) == 799 && (table_bits) == 9 && (max_codeword_len) == 15) ? 1366 : \
((num_syms) == 799 && (table_bits) == 10 && (max_codeword_len) == 15) ? 1846 : \
((num_syms) == 799 && (table_bits) == 11 && (max_codeword_len) == 15) ? 2854 : \
-1)
#define DECODE_TABLE_SIZE(num_syms, table_bits, max_codeword_len) ( \
STATIC_ASSERT_ZERO((num_syms) > 0) + \
STATIC_ASSERT_ZERO((table_bits) > 0) + \
STATIC_ASSERT_ZERO((max_codeword_len) > 0) + \
STATIC_ASSERT_ZERO((num_syms) <= 1U << (max_codeword_len)) + \
STATIC_ASSERT_ZERO((table_bits) <= (max_codeword_len)) + \
STATIC_ASSERT_ZERO((num_syms) - 1 <= DECODE_TABLE_MAX_SYMBOL) + \
STATIC_ASSERT_ZERO((table_bits) <= DECODE_TABLE_MAX_LENGTH) + \
STATIC_ASSERT_ZERO((max_codeword_len) - (table_bits) <= \
DECODE_TABLE_MAX_LENGTH) + \
STATIC_ASSERT_ZERO((1U << table_bits) > (num_syms) - 1) + \
STATIC_ASSERT_ZERO(DECODE_TABLE_ENOUGH( \
(num_syms), (table_bits), \
(max_codeword_len)) > 0) + \
STATIC_ASSERT_ZERO(DECODE_TABLE_ENOUGH( \
(num_syms), (table_bits), \
(max_codeword_len)) - 1 <= \
DECODE_TABLE_MAX_SYMBOL) + \
DECODE_TABLE_ENOUGH((num_syms), (table_bits), \
(max_codeword_len)) \
)
#define DECODE_TABLE(name, num_syms, table_bits, max_codeword_len) \
u16 name[DECODE_TABLE_SIZE((num_syms), (table_bits), \
(max_codeword_len))] \
__aligned(DECODE_TABLE_ALIGNMENT)
#define DECODE_TABLE_WORKING_SPACE(name, num_syms, max_codeword_len) \
u16 name[2 * ((max_codeword_len) + 1) + (num_syms)]
int make_huffman_decode_table(u16 decode_table[], u32 num_syms,
u32 table_bits, const u8 lens[],
u32 max_codeword_len, u16 working_space[],
u32 decode_table_size);
static forceinline int lz_copy(u32 length, u32 offset, u8 *out_begin,
u8 *out_next, u8 *out_end, u32 min_length)
{
const u8 *src;
u8 *end;
if (unlikely(offset > (u32)(out_next - out_begin)))
return -1;
src = out_next - offset;
if (UNALIGNED_ACCESS_IS_FAST && length <= 3 * WORDBYTES &&
offset >= WORDBYTES && out_end - out_next >= 3 * WORDBYTES) {
copy_word_unaligned(src + WORDBYTES * 0, out_next + WORDBYTES * 0);
copy_word_unaligned(src + WORDBYTES * 1, out_next + WORDBYTES * 1);
copy_word_unaligned(src + WORDBYTES * 2, out_next + WORDBYTES * 2);
return 0;
}
if (unlikely(length > (u32)(out_end - out_next)))
return -1;
end = out_next + length;
if (UNALIGNED_ACCESS_IS_FAST && likely(out_end - end >= WORDBYTES - 1)) {
if (offset >= WORDBYTES) {
do {
copy_word_unaligned(src, out_next);
src += WORDBYTES;
out_next += WORDBYTES;
} while (out_next < end);
return 0;
} else if (offset == 1) {
size_t v = repeat_byte(*(out_next - 1));
do {
store_word_unaligned(v, out_next);
src += WORDBYTES;
out_next += WORDBYTES;
} while (out_next < end);
return 0;
}
}
if (min_length >= 2)
*out_next++ = *src++;
if (min_length >= 3)
*out_next++ = *src++;
do {
*out_next++ = *src++;
} while (out_next != end);
return 0;
}
#endif /* _LINUX_NTFS_LIB_DECOMPRESS_COMMON_H */