fix: remove some unused libs

Signed-off-by: DioEgizio <83089242+DioEgizio@users.noreply.github.com>

12 files changed, 0 insertions, 3818 deletions

diff --git a/libraries/xz-embedded/CMakeLists.txt b/libraries/xz-embedded/CMakeLists.txt
deleted file mode 100644
index 4ce46102..00000000
--- a/libraries/xz-embedded/CMakeLists.txt
+++ /dev/null
@@ -1,26 +0,0 @@
-cmake_minimum_required(VERSION 3.9.4)
-project(xz-embedded LANGUAGES C)
-
-option(XZ_BUILD_BCJ "Build xz-embedded with BCJ support (native binary optimization)" OFF)
-option(XZ_BUILD_CRC64 "Build xz-embedded with CRC64 checksum support" ON)
-option(XZ_BUILD_MINIDEC "Build a tiny utility that decompresses xz streams" OFF)
-
-# See include/xz.h for manual feature configuration
-# tweak this list and xz.h to fit your needs
-
-set(XZ_SOURCES
-    src/xz_crc32.c
-    src/xz_crc64.c
-    src/xz_dec_lzma2.c
-    src/xz_dec_stream.c
-#    src/xz_dec_bcj.c
-)
-add_library(xz-embedded STATIC ${XZ_SOURCES})
-target_include_directories(xz-embedded PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
-set_property(TARGET xz-embedded PROPERTY C_STANDARD 99)
-
-if(${XZ_BUILD_MINIDEC})
-    add_executable(xzminidec xzminidec.c)
-    target_link_libraries(xzminidec xz-embedded)
-    set_property(TARGET xzminidec PROPERTY C_STANDARD 99)
-endif()
diff --git a/libraries/xz-embedded/include/xz.h b/libraries/xz-embedded/include/xz.h
deleted file mode 100644
index 3779124c..00000000
--- a/libraries/xz-embedded/include/xz.h
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
- * XZ decompressor
- *
- * Authors: Lasse Collin <lasse.collin@tukaani.org>
- *          Igor Pavlov <http://7-zip.org/>
- *
- * This file has been put into the public domain.
- * You can do whatever you want with this file.
- */
-
-#ifndef XZ_H
-#define XZ_H
-
-#ifdef __KERNEL__
-#include <linux/stddef.h>
-#include <linux/types.h>
-#else
-#include <stddef.h>
-#include <stdint.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Definitions that determine available features */
-#define XZ_DEC_ANY_CHECK 1
-#define XZ_USE_CRC64 1
-
-// native machine code compression stuff
-/*
-#define XZ_DEC_X86
-#define XZ_DEC_POWERPC
-#define XZ_DEC_IA64
-#define XZ_DEC_ARM
-#define XZ_DEC_ARMTHUMB
-#define XZ_DEC_SPARC
-*/
-
-/* In Linux, this is used to make extern functions static when needed. */
-#ifndef XZ_EXTERN
-#define XZ_EXTERN extern
-#endif
-
-/**
- * enum xz_mode - Operation mode
- *
- * @XZ_SINGLE:              Single-call mode. This uses less RAM than
- *                          than multi-call modes, because the LZMA2
- *                          dictionary doesn't need to be allocated as
- *                          part of the decoder state. All required data
- *                          structures are allocated at initialization,
- *                          so xz_dec_run() cannot return XZ_MEM_ERROR.
- * @XZ_PREALLOC:            Multi-call mode with preallocated LZMA2
- *                          dictionary buffer. All data structures are
- *                          allocated at initialization, so xz_dec_run()
- *                          cannot return XZ_MEM_ERROR.
- * @XZ_DYNALLOC:            Multi-call mode. The LZMA2 dictionary is
- *                          allocated once the required size has been
- *                          parsed from the stream headers. If the
- *                          allocation fails, xz_dec_run() will return
- *                          XZ_MEM_ERROR.
- *
- * It is possible to enable support only for a subset of the above
- * modes at compile time by defining XZ_DEC_SINGLE, XZ_DEC_PREALLOC,
- * or XZ_DEC_DYNALLOC. The xz_dec kernel module is always compiled
- * with support for all operation modes, but the preboot code may
- * be built with fewer features to minimize code size.
- */
-enum xz_mode
-{
-    XZ_SINGLE,
-    XZ_PREALLOC,
-    XZ_DYNALLOC
-};
-
-/**
- * enum xz_ret - Return codes
- * @XZ_OK:                  Everything is OK so far. More input or more
- *                          output space is required to continue. This
- *                          return code is possible only in multi-call mode
- *                          (XZ_PREALLOC or XZ_DYNALLOC).
- * @XZ_STREAM_END:          Operation finished successfully.
- * @XZ_UNSUPPORTED_CHECK:   Integrity check type is not supported. Decoding
- *                          is still possible in multi-call mode by simply
- *                          calling xz_dec_run() again.
- *                          Note that this return value is used only if
- *                          XZ_DEC_ANY_CHECK was defined at build time,
- *                          which is not used in the kernel. Unsupported
- *                          check types return XZ_OPTIONS_ERROR if
- *                          XZ_DEC_ANY_CHECK was not defined at build time.
- * @XZ_MEM_ERROR:           Allocating memory failed. This return code is
- *                          possible only if the decoder was initialized
- *                          with XZ_DYNALLOC. The amount of memory that was
- *                          tried to be allocated was no more than the
- *                          dict_max argument given to xz_dec_init().
- * @XZ_MEMLIMIT_ERROR:      A bigger LZMA2 dictionary would be needed than
- *                          allowed by the dict_max argument given to
- *                          xz_dec_init(). This return value is possible
- *                          only in multi-call mode (XZ_PREALLOC or
- *                          XZ_DYNALLOC); the single-call mode (XZ_SINGLE)
- *                          ignores the dict_max argument.
- * @XZ_FORMAT_ERROR:        File format was not recognized (wrong magic
- *                          bytes).
- * @XZ_OPTIONS_ERROR:       This implementation doesn't support the requested
- *                          compression options. In the decoder this means
- *                          that the header CRC32 matches, but the header
- *                          itself specifies something that we don't support.
- * @XZ_DATA_ERROR:          Compressed data is corrupt.
- * @XZ_BUF_ERROR:           Cannot make any progress. Details are slightly
- *                          different between multi-call and single-call
- *                          mode; more information below.
- *
- * In multi-call mode, XZ_BUF_ERROR is returned when two consecutive calls
- * to XZ code cannot consume any input and cannot produce any new output.
- * This happens when there is no new input available, or the output buffer
- * is full while at least one output byte is still pending. Assuming your
- * code is not buggy, you can get this error only when decoding a compressed
- * stream that is truncated or otherwise corrupt.
- *
- * In single-call mode, XZ_BUF_ERROR is returned only when the output buffer
- * is too small or the compressed input is corrupt in a way that makes the
- * decoder produce more output than the caller expected. When it is
- * (relatively) clear that the compressed input is truncated, XZ_DATA_ERROR
- * is used instead of XZ_BUF_ERROR.
- */
-enum xz_ret
-{
-    XZ_OK,
-    XZ_STREAM_END,
-    XZ_UNSUPPORTED_CHECK,
-    XZ_MEM_ERROR,
-    XZ_MEMLIMIT_ERROR,
-    XZ_FORMAT_ERROR,
-    XZ_OPTIONS_ERROR,
-    XZ_DATA_ERROR,
-    XZ_BUF_ERROR
-};
-
-/**
- * struct xz_buf - Passing input and output buffers to XZ code
- * @in:         Beginning of the input buffer. This may be NULL if and only
- *              if in_pos is equal to in_size.
- * @in_pos:     Current position in the input buffer. This must not exceed
- *              in_size.
- * @in_size:    Size of the input buffer
- * @out:        Beginning of the output buffer. This may be NULL if and only
- *              if out_pos is equal to out_size.
- * @out_pos:    Current position in the output buffer. This must not exceed
- *              out_size.
- * @out_size:   Size of the output buffer
- *
- * Only the contents of the output buffer from out[out_pos] onward, and
- * the variables in_pos and out_pos are modified by the XZ code.
- */
-struct xz_buf
-{
-    const uint8_t *in;
-    size_t in_pos;
-    size_t in_size;
-
-    uint8_t *out;
-    size_t out_pos;
-    size_t out_size;
-};
-
-/**
- * struct xz_dec - Opaque type to hold the XZ decoder state
- */
-struct xz_dec;
-
-/**
- * xz_dec_init() - Allocate and initialize a XZ decoder state
- * @mode:       Operation mode
- * @dict_max:   Maximum size of the LZMA2 dictionary (history buffer) for
- *              multi-call decoding. This is ignored in single-call mode
- *              (mode == XZ_SINGLE). LZMA2 dictionary is always 2^n bytes
- *              or 2^n + 2^(n-1) bytes (the latter sizes are less common
- *              in practice), so other values for dict_max don't make sense.
- *              In the kernel, dictionary sizes of 64 KiB, 128 KiB, 256 KiB,
- *              512 KiB, and 1 MiB are probably the only reasonable values,
- *              except for kernel and initramfs images where a bigger
- *              dictionary can be fine and useful.
- *
- * Single-call mode (XZ_SINGLE): xz_dec_run() decodes the whole stream at
- * once. The caller must provide enough output space or the decoding will
- * fail. The output space is used as the dictionary buffer, which is why
- * there is no need to allocate the dictionary as part of the decoder's
- * internal state.
- *
- * Because the output buffer is used as the workspace, streams encoded using
- * a big dictionary are not a problem in single-call mode. It is enough that
- * the output buffer is big enough to hold the actual uncompressed data; it
- * can be smaller than the dictionary size stored in the stream headers.
- *
- * Multi-call mode with preallocated dictionary (XZ_PREALLOC): dict_max bytes
- * of memory is preallocated for the LZMA2 dictionary. This way there is no
- * risk that xz_dec_run() could run out of memory, since xz_dec_run() will
- * never allocate any memory. Instead, if the preallocated dictionary is too
- * small for decoding the given input stream, xz_dec_run() will return
- * XZ_MEMLIMIT_ERROR. Thus, it is important to know what kind of data will be
- * decoded to avoid allocating excessive amount of memory for the dictionary.
- *
- * Multi-call mode with dynamically allocated dictionary (XZ_DYNALLOC):
- * dict_max specifies the maximum allowed dictionary size that xz_dec_run()
- * may allocate once it has parsed the dictionary size from the stream
- * headers. This way excessive allocations can be avoided while still
- * limiting the maximum memory usage to a sane value to prevent running the
- * system out of memory when decompressing streams from untrusted sources.
- *
- * On success, xz_dec_init() returns a pointer to struct xz_dec, which is
- * ready to be used with xz_dec_run(). If memory allocation fails,
- * xz_dec_init() returns NULL.
- */
-XZ_EXTERN struct xz_dec *xz_dec_init(enum xz_mode mode, uint32_t dict_max);
-
-/**
- * xz_dec_run() - Run the XZ decoder
- * @s:          Decoder state allocated using xz_dec_init()
- * @b:          Input and output buffers
- *
- * The possible return values depend on build options and operation mode.
- * See enum xz_ret for details.
- *
- * Note that if an error occurs in single-call mode (return value is not
- * XZ_STREAM_END), b->in_pos and b->out_pos are not modified and the
- * contents of the output buffer from b->out[b->out_pos] onward are
- * undefined. This is true even after XZ_BUF_ERROR, because with some filter
- * chains, there may be a second pass over the output buffer, and this pass
- * cannot be properly done if the output buffer is truncated. Thus, you
- * cannot give the single-call decoder a too small buffer and then expect to
- * get that amount valid data from the beginning of the stream. You must use
- * the multi-call decoder if you don't want to uncompress the whole stream.
- */
-XZ_EXTERN enum xz_ret xz_dec_run(struct xz_dec *s, struct xz_buf *b);
-
-/**
- * xz_dec_reset() - Reset an already allocated decoder state
- * @s:          Decoder state allocated using xz_dec_init()
- *
- * This function can be used to reset the multi-call decoder state without
- * freeing and reallocating memory with xz_dec_end() and xz_dec_init().
- *
- * In single-call mode, xz_dec_reset() is always called in the beginning of
- * xz_dec_run(). Thus, explicit call to xz_dec_reset() is useful only in
- * multi-call mode.
- */
-XZ_EXTERN void xz_dec_reset(struct xz_dec *s);
-
-/**
- * xz_dec_end() - Free the memory allocated for the decoder state
- * @s:          Decoder state allocated using xz_dec_init(). If s is NULL,
- *              this function does nothing.
- */
-XZ_EXTERN void xz_dec_end(struct xz_dec *s);
-
-/*
- * Standalone build (userspace build or in-kernel build for boot time use)
- * needs a CRC32 implementation. For normal in-kernel use, kernel's own
- * CRC32 module is used instead, and users of this module don't need to
- * care about the functions below.
- */
-#ifndef XZ_INTERNAL_CRC32
-#ifdef __KERNEL__
-#define XZ_INTERNAL_CRC32 0
-#else
-#define XZ_INTERNAL_CRC32 1
-#endif
-#endif
-
-/*
- * If CRC64 support has been enabled with XZ_USE_CRC64, a CRC64
- * implementation is needed too.
- */
-#ifndef XZ_USE_CRC64
-#undef XZ_INTERNAL_CRC64
-#define XZ_INTERNAL_CRC64 0
-#endif
-#ifndef XZ_INTERNAL_CRC64
-#ifdef __KERNEL__
-#error Using CRC64 in the kernel has not been implemented.
-#else
-#define XZ_INTERNAL_CRC64 1
-#endif
-#endif
-
-#if XZ_INTERNAL_CRC32
-/*
- * This must be called before any other xz_* function to initialize
- * the CRC32 lookup table.
- */
-XZ_EXTERN void xz_crc32_init(void);
-
-/*
- * Update CRC32 value using the polynomial from IEEE-802.3. To start a new
- * calculation, the third argument must be zero. To continue the calculation,
- * the previously returned value is passed as the third argument.
- */
-XZ_EXTERN uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc);
-#endif
-
-#if XZ_INTERNAL_CRC64
-/*
- * This must be called before any other xz_* function (except xz_crc32_init())
- * to initialize the CRC64 lookup table.
- */
-XZ_EXTERN void xz_crc64_init(void);
-
-/*
- * Update CRC64 value using the polynomial from ECMA-182. To start a new
- * calculation, the third argument must be zero. To continue the calculation,
- * the previously returned value is passed as the third argument.
- */
-XZ_EXTERN uint64_t xz_crc64(const uint8_t *buf, size_t size, uint64_t crc);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
diff --git a/libraries/xz-embedded/src/xz_config.h b/libraries/xz-embedded/src/xz_config.h
deleted file mode 100644
index effdb1bd..00000000
--- a/libraries/xz-embedded/src/xz_config.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Private includes and definitions for userspace use of XZ Embedded
- *
- * Author: Lasse Collin <lasse.collin@tukaani.org>
- *
- * This file has been put into the public domain.
- * You can do whatever you want with this file.
- */
-
-#ifndef XZ_CONFIG_H
-#define XZ_CONFIG_H
-
-/* Uncomment to enable CRC64 support. */
-/* #define XZ_USE_CRC64 */
-
-/* Uncomment as needed to enable BCJ filter decoders. */
-/* #define XZ_DEC_X86 */
-/* #define XZ_DEC_POWERPC */
-/* #define XZ_DEC_IA64 */
-/* #define XZ_DEC_ARM */
-/* #define XZ_DEC_ARMTHUMB */
-/* #define XZ_DEC_SPARC */
-
-/*
- * MSVC doesn't support modern C but XZ Embedded is mostly C89
- * so these are enough.
- */
-#ifdef _MSC_VER
-typedef unsigned char bool;
-#define true 1
-#define false 0
-#define inline __inline
-#else
-#include <stdbool.h>
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "xz.h"
-
-#define kmalloc(size, flags) malloc(size)
-#define kfree(ptr) free(ptr)
-#define vmalloc(size) malloc(size)
-#define vfree(ptr) free(ptr)
-
-#define memeq(a, b, size) (memcmp(a, b, size) == 0)
-#define memzero(buf, size) memset(buf, 0, size)
-
-#ifndef min
-#define min(x, y) ((x) < (y) ? (x) : (y))
-#endif
-#define min_t(type, x, y) min(x, y)
-
-/*
- * Some functions have been marked with __always_inline to keep the
- * performance reasonable even when the compiler is optimizing for
- * small code size. You may be able to save a few bytes by #defining
- * __always_inline to plain inline, but don't complain if the code
- * becomes slow.
- *
- * NOTE: System headers on GNU/Linux may #define this macro already,
- * so if you want to change it, you need to #undef it first.
- */
-#ifndef __always_inline
-#ifdef __GNUC__
-#define __always_inline inline __attribute__((__always_inline__))
-#else
-#define __always_inline inline
-#endif
-#endif
-
-/* Inline functions to access unaligned unsigned 32-bit integers */
-#ifndef get_unaligned_le32
-static inline uint32_t get_unaligned_le32(const uint8_t *buf)
-{
-    return (uint32_t)buf[0] | ((uint32_t)buf[1] << 8) | ((uint32_t)buf[2] << 16) |
-           ((uint32_t)buf[3] << 24);
-}
-#endif
-
-#ifndef get_unaligned_be32
-static inline uint32_t get_unaligned_be32(const uint8_t *buf)
-{
-    return (uint32_t)(buf[0] << 24) | ((uint32_t)buf[1] << 16) | ((uint32_t)buf[2] << 8) |
-           (uint32_t)buf[3];
-}
-#endif
-
-#ifndef put_unaligned_le32
-static inline void put_unaligned_le32(uint32_t val, uint8_t *buf)
-{
-    buf[0] = (uint8_t)val;
-    buf[1] = (uint8_t)(val >> 8);
-    buf[2] = (uint8_t)(val >> 16);
-    buf[3] = (uint8_t)(val >> 24);
-}
-#endif
-
-#ifndef put_unaligned_be32
-static inline void put_unaligned_be32(uint32_t val, uint8_t *buf)
-{
-    buf[0] = (uint8_t)(val >> 24);
-    buf[1] = (uint8_t)(val >> 16);
-    buf[2] = (uint8_t)(val >> 8);
-    buf[3] = (uint8_t)val;
-}
-#endif
-
-/*
- * Use get_unaligned_le32() also for aligned access for simplicity. On
- * little endian systems, #define get_le32(ptr) (*(const uint32_t *)(ptr))
- * could save a few bytes in code size.
- */
-#ifndef get_le32
-#define get_le32 get_unaligned_le32
-#endif
-
-#endif
diff --git a/libraries/xz-embedded/src/xz_crc32.c b/libraries/xz-embedded/src/xz_crc32.c
deleted file mode 100644
index 65d9d5b8..00000000
--- a/libraries/xz-embedded/src/xz_crc32.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * CRC32 using the polynomial from IEEE-802.3
- *
- * Authors: Lasse Collin <lasse.collin@tukaani.org>
- *          Igor Pavlov <http://7-zip.org/>
- *
- * This file has been put into the public domain.
- * You can do whatever you want with this file.
- */
-
-/*
- * This is not the fastest implementation, but it is pretty compact.
- * The fastest versions of xz_crc32() on modern CPUs without hardware
- * accelerated CRC instruction are 3-5 times as fast as this version,
- * but they are bigger and use more memory for the lookup table.
- */
-
-#include "xz_private.h"
-
-/*
- * STATIC_RW_DATA is used in the pre-boot environment on some architectures.
- * See <linux/decompress/mm.h> for details.
- */
-#ifndef STATIC_RW_DATA
-#define STATIC_RW_DATA static
-#endif
-
-STATIC_RW_DATA uint32_t xz_crc32_table[256];
-
-XZ_EXTERN void xz_crc32_init(void)
-{
-    const uint32_t poly = 0xEDB88320;
-
-    uint32_t i;
-    uint32_t j;
-    uint32_t r;
-
-    for (i = 0; i < 256; ++i)
-    {
-        r = i;
-        for (j = 0; j < 8; ++j)
-            r = (r >> 1) ^ (poly & ~((r & 1) - 1));
-
-        xz_crc32_table[i] = r;
-    }
-
-    return;
-}
-
-XZ_EXTERN uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc)
-{
-    crc = ~crc;
-
-    while (size != 0)
-    {
-        crc = xz_crc32_table[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8);
-        --size;
-    }
-
-    return ~crc;
-}
diff --git a/libraries/xz-embedded/src/xz_crc64.c b/libraries/xz-embedded/src/xz_crc64.c
deleted file mode 100644
index 0f711d8d..00000000
--- a/libraries/xz-embedded/src/xz_crc64.c
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * CRC64 using the polynomial from ECMA-182
- *
- * This file is similar to xz_crc32.c. See the comments there.
- *
- * Authors: Lasse Collin <lasse.collin@tukaani.org>
- *          Igor Pavlov <http://7-zip.org/>
- *
- * This file has been put into the public domain.
- * You can do whatever you want with this file.
- */
-
-#include "xz_private.h"
-
-#ifndef STATIC_RW_DATA
-#define STATIC_RW_DATA static
-#endif
-
-STATIC_RW_DATA uint64_t xz_crc64_table[256];
-
-XZ_EXTERN void xz_crc64_init(void)
-{
-    const uint64_t poly = 0xC96C5795D7870F42;
-
-    uint32_t i;
-    uint32_t j;
-    uint64_t r;
-
-    for (i = 0; i < 256; ++i)
-    {
-        r = i;
-        for (j = 0; j < 8; ++j)
-            r = (r >> 1) ^ (poly & ~((r & 1) - 1));
-
-        xz_crc64_table[i] = r;
-    }
-
-    return;
-}
-
-XZ_EXTERN uint64_t xz_crc64(const uint8_t *buf, size_t size, uint64_t crc)
-{
-    crc = ~crc;
-
-    while (size != 0)
-    {
-        crc = xz_crc64_table[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8);
-        --size;
-    }
-
-    return ~crc;
-}
diff --git a/libraries/xz-embedded/src/xz_dec_bcj.c b/libraries/xz-embedded/src/xz_dec_bcj.c
deleted file mode 100644
index a79fa76d..00000000
--- a/libraries/xz-embedded/src/xz_dec_bcj.c
+++ /dev/null
@@ -1,588 +0,0 @@
-/*
- * Branch/Call/Jump (BCJ) filter decoders
- *
- * Authors: Lasse Collin <lasse.collin@tukaani.org>
- *          Igor Pavlov <http://7-zip.org/>
- *
- * This file has been put into the public domain.
- * You can do whatever you want with this file.
- */
-
-#include "xz_private.h"
-
-/*
- * The rest of the file is inside this ifdef. It makes things a little more
- * convenient when building without support for any BCJ filters.
- */
-#ifdef XZ_DEC_BCJ
-
-struct xz_dec_bcj
-{
-    /* Type of the BCJ filter being used */
-    enum
-    {
-        BCJ_X86 = 4,      /* x86 or x86-64 */
-        BCJ_POWERPC = 5,  /* Big endian only */
-        BCJ_IA64 = 6,     /* Big or little endian */
-        BCJ_ARM = 7,      /* Little endian only */
-        BCJ_ARMTHUMB = 8, /* Little endian only */
-        BCJ_SPARC = 9     /* Big or little endian */
-    } type;
-
-    /*
-     * Return value of the next filter in the chain. We need to preserve
-     * this information across calls, because we must not call the next
-     * filter anymore once it has returned XZ_STREAM_END.
-     */
-    enum xz_ret ret;
-
-    /* True if we are operating in single-call mode. */
-    bool single_call;
-
-    /*
-     * Absolute position relative to the beginning of the uncompressed
-     * data (in a single .xz Block). We care only about the lowest 32
-     * bits so this doesn't need to be uint64_t even with big files.
-     */
-    uint32_t pos;
-
-    /* x86 filter state */
-    uint32_t x86_prev_mask;
-
-    /* Temporary space to hold the variables from struct xz_buf */
-    uint8_t *out;
-    size_t out_pos;
-    size_t out_size;
-
-    struct
-    {
-        /* Amount of already filtered data in the beginning of buf */
-        size_t filtered;
-
-        /* Total amount of data currently stored in buf  */
-        size_t size;
-
-        /*
-         * Buffer to hold a mix of filtered and unfiltered data. This
-         * needs to be big enough to hold Alignment + 2 * Look-ahead:
-         *
-         * Type         Alignment   Look-ahead
-         * x86              1           4
-         * PowerPC          4           0
-         * IA-64           16           0
-         * ARM              4           0
-         * ARM-Thumb        2           2
-         * SPARC            4           0
-         */
-        uint8_t buf[16];
-    } temp;
-};
-
-#ifdef XZ_DEC_X86
-/*
- * This is used to test the most significant byte of a memory address
- * in an x86 instruction.
- */
-static inline int bcj_x86_test_msbyte(uint8_t b)
-{
-    return b == 0x00 || b == 0xFF;
-}
-
-static size_t bcj_x86(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
-{
-    static const bool mask_to_allowed_status[8] = {true, true,  true,  false,
-                                                   true, false, false, false};
-
-    static const uint8_t mask_to_bit_num[8] = {0, 1, 2, 2, 3, 3, 3, 3};
-
-    size_t i;
-    size_t prev_pos = (size_t) - 1;
-    uint32_t prev_mask = s->x86_prev_mask;
-    uint32_t src;
-    uint32_t dest;
-    uint32_t j;
-    uint8_t b;
-
-    if (size <= 4)
-        return 0;
-
-    size -= 4;
-    for (i = 0; i < size; ++i)
-    {
-        if ((buf[i] & 0xFE) != 0xE8)
-            continue;
-
-        prev_pos = i - prev_pos;
-        if (prev_pos > 3)
-        {
-            prev_mask = 0;
-        }
-        else
-        {
-            prev_mask = (prev_mask << (prev_pos - 1)) & 7;
-            if (prev_mask != 0)
-            {
-                b = buf[i + 4 - mask_to_bit_num[prev_mask]];
-                if (!mask_to_allowed_status[prev_mask] || bcj_x86_test_msbyte(b))
-                {
-                    prev_pos = i;
-                    prev_mask = (prev_mask << 1) | 1;
-                    continue;
-                }
-            }
-        }
-
-        prev_pos = i;
-
-        if (bcj_x86_test_msbyte(buf[i + 4]))
-        {
-            src = get_unaligned_le32(buf + i + 1);
-            while (true)
-            {
-                dest = src - (s->pos + (uint32_t)i + 5);
-                if (prev_mask == 0)
-                    break;
-
-                j = mask_to_bit_num[prev_mask] * 8;
-                b = (uint8_t)(dest >> (24 - j));
-                if (!bcj_x86_test_msbyte(b))
-                    break;
-
-                src = dest ^ (((uint32_t)1 << (32 - j)) - 1);
-            }
-
-            dest &= 0x01FFFFFF;
-            dest |= (uint32_t)0 - (dest & 0x01000000);
-            put_unaligned_le32(dest, buf + i + 1);
-            i += 4;
-        }
-        else
-        {
-            prev_mask = (prev_mask << 1) | 1;
-        }
-    }
-
-    prev_pos = i - prev_pos;
-    s->x86_prev_mask = prev_pos > 3 ? 0 : prev_mask << (prev_pos - 1);
-    return i;
-}
-#endif
-
-#ifdef XZ_DEC_POWERPC
-static size_t bcj_powerpc(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
-{
-    size_t i;
-    uint32_t instr;
-
-    for (i = 0; i + 4 <= size; i += 4)
-    {
-        instr = get_unaligned_be32(buf + i);
-        if ((instr & 0xFC000003) == 0x48000001)
-        {
-            instr &= 0x03FFFFFC;
-            instr -= s->pos + (uint32_t)i;
-            instr &= 0x03FFFFFC;
-            instr |= 0x48000001;
-            put_unaligned_be32(instr, buf + i);
-        }
-    }
-
-    return i;
-}
-#endif
-
-#ifdef XZ_DEC_IA64
-static size_t bcj_ia64(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
-{
-    static const uint8_t branch_table[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                                             4, 4, 6, 6, 0, 0, 7, 7, 4, 4, 0, 0, 4, 4, 0, 0};
-
-    /*
-     * The local variables take a little bit stack space, but it's less
-     * than what LZMA2 decoder takes, so it doesn't make sense to reduce
-     * stack usage here without doing that for the LZMA2 decoder too.
-     */
-
-    /* Loop counters */
-    size_t i;
-    size_t j;
-
-    /* Instruction slot (0, 1, or 2) in the 128-bit instruction word */
-    uint32_t slot;
-
-    /* Bitwise offset of the instruction indicated by slot */
-    uint32_t bit_pos;
-
-    /* bit_pos split into byte and bit parts */
-    uint32_t byte_pos;
-    uint32_t bit_res;
-
-    /* Address part of an instruction */
-    uint32_t addr;
-
-    /* Mask used to detect which instructions to convert */
-    uint32_t mask;
-
-    /* 41-bit instruction stored somewhere in the lowest 48 bits */
-    uint64_t instr;
-
-    /* Instruction normalized with bit_res for easier manipulation */
-    uint64_t norm;
-
-    for (i = 0; i + 16 <= size; i += 16)
-    {
-        mask = branch_table[buf[i] & 0x1F];
-        for (slot = 0, bit_pos = 5; slot < 3; ++slot, bit_pos += 41)
-        {
-            if (((mask >> slot) & 1) == 0)
-                continue;
-
-            byte_pos = bit_pos >> 3;
-            bit_res = bit_pos & 7;
-            instr = 0;
-            for (j = 0; j < 6; ++j)
-                instr |= (uint64_t)(buf[i + j + byte_pos]) << (8 * j);
-
-            norm = instr >> bit_res;
-
-            if (((norm >> 37) & 0x0F) == 0x05 && ((norm >> 9) & 0x07) == 0)
-            {
-                addr = (norm >> 13) & 0x0FFFFF;
-                addr |= ((uint32_t)(norm >> 36) & 1) << 20;
-                addr <<= 4;
-                addr -= s->pos + (uint32_t)i;
-                addr >>= 4;
-
-                norm &= ~((uint64_t)0x8FFFFF << 13);
-                norm |= (uint64_t)(addr & 0x0FFFFF) << 13;
-                norm |= (uint64_t)(addr & 0x100000) << (36 - 20);
-
-                instr &= (1 << bit_res) - 1;
-                instr |= norm << bit_res;
-
-                for (j = 0; j < 6; j++)
-                    buf[i + j + byte_pos] = (uint8_t)(instr >> (8 * j));
-            }
-        }
-    }
-
-    return i;
-}
-#endif
-
-#ifdef XZ_DEC_ARM
-static size_t bcj_arm(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
-{
-    size_t i;
-    uint32_t addr;
-
-    for (i = 0; i + 4 <= size; i += 4)
-    {
-        if (buf[i + 3] == 0xEB)
-        {
-            addr =
-                (uint32_t)buf[i] | ((uint32_t)buf[i + 1] << 8) | ((uint32_t)buf[i + 2] << 16);
-            addr <<= 2;
-            addr -= s->pos + (uint32_t)i + 8;
-            addr >>= 2;
-            buf[i] = (uint8_t)addr;
-            buf[i + 1] = (uint8_t)(addr >> 8);
-            buf[i + 2] = (uint8_t)(addr >> 16);
-        }
-    }
-
-    return i;
-}
-#endif
-
-#ifdef XZ_DEC_ARMTHUMB
-static size_t bcj_armthumb(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
-{
-    size_t i;
-    uint32_t addr;
-
-    for (i = 0; i + 4 <= size; i += 2)
-    {
-        if ((buf[i + 1] & 0xF8) == 0xF0 && (buf[i + 3] & 0xF8) == 0xF8)
-        {
-            addr = (((uint32_t)buf[i + 1] & 0x07) << 19) | ((uint32_t)buf[i] << 11) |
-                   (((uint32_t)buf[i + 3] & 0x07) << 8) | (uint32_t)buf[i + 2];
-            addr <<= 1;
-            addr -= s->pos + (uint32_t)i + 4;
-            addr >>= 1;
-            buf[i + 1] = (uint8_t)(0xF0 | ((addr >> 19) & 0x07));
-            buf[i] = (uint8_t)(addr >> 11);
-            buf[i + 3] = (uint8_t)(0xF8 | ((addr >> 8) & 0x07));
-            buf[i + 2] = (uint8_t)addr;
-            i += 2;
-        }
-    }
-
-    return i;
-}
-#endif
-
-#ifdef XZ_DEC_SPARC
-static size_t bcj_sparc(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
-{
-    size_t i;
-    uint32_t instr;
-
-    for (i = 0; i + 4 <= size; i += 4)
-    {
-        instr = get_unaligned_be32(buf + i);
-        if ((instr >> 22) == 0x100 || (instr >> 22) == 0x1FF)
-        {
-            instr <<= 2;
-            instr -= s->pos + (uint32_t)i;
-            instr >>= 2;
-            instr =
-                ((uint32_t)0x40000000 - (instr & 0x400000)) | 0x40000000 | (instr & 0x3FFFFF);
-            put_unaligned_be32(instr, buf + i);
-        }
-    }
-
-    return i;
-}
-#endif
-
-/*
- * Apply the selected BCJ filter. Update *pos and s->pos to match the amount
- * of data that got filtered.
- *
- * NOTE: This is implemented as a switch statement to avoid using function
- * pointers, which could be problematic in the kernel boot code, which must
- * avoid pointers to static data (at least