x86.c File Reference

Filter for x86 binaries (BCJ filter) More...

#include "simple_private.h"

Go to the source code of this file.

Classes
struct	lzma_simple_x86

Macros
#define	Test86MSByte(b)   ((b) == 0 || (b) == 0xFF)

Functions
static size_t	x86_code (void *simple_ptr, uint32_t now_pos, bool is_encoder, uint8_t *buffer, size_t size)
static lzma_ret	x86_coder_init (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter_info *filters, bool is_encoder)
lzma_ret	lzma_simple_x86_encoder_init (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter_info *filters)
lzma_ret	lzma_simple_x86_decoder_init (lzma_next_coder *next, const lzma_allocator *allocator, const lzma_filter_info *filters)

Detailed Description

Filter for x86 binaries (BCJ filter)

Definition in file x86.c.

Macro Definition Documentation

Test86MSByte

#define Test86MSByte

(

b

)

((b) == 0 || (b) == 0xFF)

Definition at line 17 of file x86.c.

Function Documentation

lzma_simple_x86_decoder_init()

lzma_ret lzma_simple_x86_decoder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter_info *	filters
	)

Definition at line 154 of file x86.c.

{
    return x86_coder_init(next, allocator, filters, false);
}

References allocator, filters, and x86_coder_init().

lzma_simple_x86_encoder_init()

lzma_ret lzma_simple_x86_encoder_init	(	lzma_next_coder *	next,
		const lzma_allocator *	allocator,
		const lzma_filter_info *	filters
	)

Definition at line 145 of file x86.c.

{
    return x86_coder_init(next, allocator, filters, true);
}

References allocator, filters, and x86_coder_init().

x86_code()

static size_t x86_code ( void *  simple_ptr, uint32_t  now_pos, bool  is_encoder, uint8_t *  buffer, size_t  size  )

static

Definition at line 27 of file x86.c.

{
    static const bool MASK_TO_ALLOWED_STATUS[8]
        = { true, true, true, false, true, false, false, false };
 
    static const uint32_t MASK_TO_BIT_NUMBER[8]
            = { 0, 1, 2, 2, 3, 3, 3, 3 };
 
    lzma_simple_x86 *simple = simple_ptr;
    uint32_t prev_mask = simple->prev_mask;
    uint32_t prev_pos = simple->prev_pos;
 
    if (size < 5)
        return 0;
 
    if (now_pos - prev_pos > 5)
        prev_pos = now_pos - 5;
 
    const size_t limit = size - 5;
    size_t buffer_pos = 0;
 
    while (buffer_pos <= limit) {
        uint8_t b = buffer[buffer_pos];
        if (b != 0xE8 && b != 0xE9) {
            ++buffer_pos;
            continue;
        }
 
        const uint32_t offset = now_pos + (uint32_t)(buffer_pos)
                - prev_pos;
        prev_pos = now_pos + (uint32_t)(buffer_pos);
 
        if (offset > 5) {
            prev_mask = 0;
        } else {
            for (uint32_t i = 0; i < offset; ++i) {
                prev_mask &= 0x77;
                prev_mask <<= 1;
            }
        }
 
        b = buffer[buffer_pos + 4];
 
        if (Test86MSByte(b)
            && MASK_TO_ALLOWED_STATUS[(prev_mask >> 1) & 0x7]
                && (prev_mask >> 1) < 0x10) {
 
            uint32_t src = ((uint32_t)(b) << 24)
                | ((uint32_t)(buffer[buffer_pos + 3]) << 16)
                | ((uint32_t)(buffer[buffer_pos + 2]) << 8)
                | (buffer[buffer_pos + 1]);
 
            uint32_t dest;
            while (true) {
                if (is_encoder)
                    dest = src + (now_pos + (uint32_t)(
                            buffer_pos) + 5);
                else
                    dest = src - (now_pos + (uint32_t)(
                            buffer_pos) + 5);
 
                if (prev_mask == 0)
                    break;
 
                const uint32_t i = MASK_TO_BIT_NUMBER[
                        prev_mask >> 1];
 
                b = (uint8_t)(dest >> (24 - i * 8));
 
                if (!Test86MSByte(b))
                    break;
 
                src = dest ^ ((1U << (32 - i * 8)) - 1);
            }
 
            buffer[buffer_pos + 4]
                    = (uint8_t)(~(((dest >> 24) & 1) - 1));
            buffer[buffer_pos + 3] = (uint8_t)(dest >> 16);
            buffer[buffer_pos + 2] = (uint8_t)(dest >> 8);
            buffer[buffer_pos + 1] = (uint8_t)(dest);
            buffer_pos += 5;
            prev_mask = 0;
 
        } else {
            ++buffer_pos;
            prev_mask |= 1;
            if (Test86MSByte(b))
                prev_mask |= 0x10;
        }
    }
 
    simple->prev_mask = prev_mask;
    simple->prev_pos = prev_pos;
 
    return buffer_pos;
}

References b, dest, i, limit, lzma_simple_x86::prev_mask, lzma_simple_x86::prev_pos, src, and Test86MSByte.

Referenced by x86_coder_init().

x86_coder_init()

static lzma_ret x86_coder_init ( lzma_next_coder *  next, const lzma_allocator *  allocator, const lzma_filter_info *  filters, bool  is_encoder  )

static

Definition at line 127 of file x86.c.

{
    const lzma_ret ret = lzma_simple_coder_init(next, allocator, filters,
            &x86_code, sizeof(lzma_simple_x86), 5, 1, is_encoder);
 
    if (ret == LZMA_OK) {
        lzma_simple_coder *coder = next->coder;
        lzma_simple_x86 *simple = coder->simple;
        simple->prev_mask = 0;
        simple->prev_pos = (uint32_t)(-5);
    }
 
    return ret;
}

References allocator, lzma_next_coder_s::coder, filters, LZMA_OK, lzma_simple_coder_init(), lzma_simple_x86::prev_mask, lzma_simple_x86::prev_pos, lzma_simple_coder::simple, and x86_code().

Referenced by lzma_simple_x86_decoder_init(), and lzma_simple_x86_encoder_init().