1// SPDX-License-Identifier: 0BSD
2
3///////////////////////////////////////////////////////////////////////////////
4//
5/// \file       x86.c
6/// \brief      Filter for x86 binaries (BCJ filter)
7///
8//  Authors:    Igor Pavlov
9//              Lasse Collin
10//
11///////////////////////////////////////////////////////////////////////////////
12
13#include "simple_private.h"
14
15
16#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
17
18
19typedef struct {
20	uint32_t prev_mask;
21	uint32_t prev_pos;
22} lzma_simple_x86;
23
24
25static size_t
26x86_code(void *simple_ptr, uint32_t now_pos, bool is_encoder,
27		uint8_t *buffer, size_t size)
28{
29	static const uint32_t MASK_TO_BIT_NUMBER[5] = { 0, 1, 2, 2, 3 };
30
31	lzma_simple_x86 *simple = simple_ptr;
32	uint32_t prev_mask = simple->prev_mask;
33	uint32_t prev_pos = simple->prev_pos;
34
35	if (size < 5)
36		return 0;
37
38	if (now_pos - prev_pos > 5)
39		prev_pos = now_pos - 5;
40
41	const size_t limit = size - 5;
42	size_t buffer_pos = 0;
43
44	while (buffer_pos <= limit) {
45		uint8_t b = buffer[buffer_pos];
46		if (b != 0xE8 && b != 0xE9) {
47			++buffer_pos;
48			continue;
49		}
50
51		const uint32_t offset = now_pos + (uint32_t)(buffer_pos)
52				- prev_pos;
53		prev_pos = now_pos + (uint32_t)(buffer_pos);
54
55		if (offset > 5) {
56			prev_mask = 0;
57		} else {
58			for (uint32_t i = 0; i < offset; ++i) {
59				prev_mask &= 0x77;
60				prev_mask <<= 1;
61			}
62		}
63
64		b = buffer[buffer_pos + 4];
65
66		if (Test86MSByte(b) && (prev_mask >> 1) <= 4
67			&& (prev_mask >> 1) != 3) {
68
69			uint32_t src = ((uint32_t)(b) << 24)
70				| ((uint32_t)(buffer[buffer_pos + 3]) << 16)
71				| ((uint32_t)(buffer[buffer_pos + 2]) << 8)
72				| (buffer[buffer_pos + 1]);
73
74			uint32_t dest;
75			while (true) {
76				if (is_encoder)
77					dest = src + (now_pos + (uint32_t)(
78							buffer_pos) + 5);
79				else
80					dest = src - (now_pos + (uint32_t)(
81							buffer_pos) + 5);
82
83				if (prev_mask == 0)
84					break;
85
86				const uint32_t i = MASK_TO_BIT_NUMBER[
87						prev_mask >> 1];
88
89				b = (uint8_t)(dest >> (24 - i * 8));
90
91				if (!Test86MSByte(b))
92					break;
93
94				src = dest ^ ((1U << (32 - i * 8)) - 1);
95			}
96
97			buffer[buffer_pos + 4]
98					= (uint8_t)(~(((dest >> 24) & 1) - 1));
99			buffer[buffer_pos + 3] = (uint8_t)(dest >> 16);
100			buffer[buffer_pos + 2] = (uint8_t)(dest >> 8);
101			buffer[buffer_pos + 1] = (uint8_t)(dest);
102			buffer_pos += 5;
103			prev_mask = 0;
104
105		} else {
106			++buffer_pos;
107			prev_mask |= 1;
108			if (Test86MSByte(b))
109				prev_mask |= 0x10;
110		}
111	}
112
113	simple->prev_mask = prev_mask;
114	simple->prev_pos = prev_pos;
115
116	return buffer_pos;
117}
118
119
120static lzma_ret
121x86_coder_init(lzma_next_coder *next, const lzma_allocator *allocator,
122		const lzma_filter_info *filters, bool is_encoder)
123{
124	const lzma_ret ret = lzma_simple_coder_init(next, allocator, filters,
125			&x86_code, sizeof(lzma_simple_x86), 5, 1, is_encoder);
126
127	if (ret == LZMA_OK) {
128		lzma_simple_coder *coder = next->coder;
129		lzma_simple_x86 *simple = coder->simple;
130		simple->prev_mask = 0;
131		simple->prev_pos = (uint32_t)(-5);
132	}
133
134	return ret;
135}
136
137
138#ifdef HAVE_ENCODER_X86
139extern lzma_ret
140lzma_simple_x86_encoder_init(lzma_next_coder *next,
141		const lzma_allocator *allocator,
142		const lzma_filter_info *filters)
143{
144	return x86_coder_init(next, allocator, filters, true);
145}
146#endif
147
148
149#ifdef HAVE_DECODER_X86
150extern lzma_ret
151lzma_simple_x86_decoder_init(lzma_next_coder *next,
152		const lzma_allocator *allocator,
153		const lzma_filter_info *filters)
154{
155	return x86_coder_init(next, allocator, filters, false);
156}
157#endif
158