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
|
///////////////////////////////////////////////////////////////////////////////
//
/// \file x86.c
/// \brief Filter for x86 binaries (BCJ filter)
//
// Copyright (C) 1999-2006 Igor Pavlov
// Copyright (C) 2007 Lasse Collin
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
///////////////////////////////////////////////////////////////////////////////
#include "simple_private.h"
#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)
struct lzma_simple_s {
uint32_t prev_mask;
uint32_t prev_pos;
};
static size_t
x86_code(lzma_simple *simple, 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 };
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 ^ ((1 << (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, 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), 5, is_encoder);
if (ret == LZMA_OK) {
next->coder->simple->prev_mask = 0;
next->coder->simple->prev_pos = (uint32_t)(-5);
}
return ret;
}
extern lzma_ret
lzma_simple_x86_encoder_init(lzma_next_coder *next, lzma_allocator *allocator,
const lzma_filter_info *filters)
{
return x86_coder_init(next, allocator, filters, true);
}
extern lzma_ret
lzma_simple_x86_decoder_init(lzma_next_coder *next, lzma_allocator *allocator,
const lzma_filter_info *filters)
{
return x86_coder_init(next, allocator, filters, false);
}
|
