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