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
19 typedef struct {
20 uint32_t prev_mask;
21 uint32_t prev_pos;
22 } lzma_simple_x86;
23
24
25 static size_t
x86_code(void * simple_ptr,uint32_t now_pos,bool is_encoder,uint8_t * buffer,size_t size)26 x86_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
120 static lzma_ret
x86_coder_init(lzma_next_coder * next,const lzma_allocator * allocator,const lzma_filter_info * filters,bool is_encoder)121 x86_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
139 extern lzma_ret
lzma_simple_x86_encoder_init(lzma_next_coder * next,const lzma_allocator * allocator,const lzma_filter_info * filters)140 lzma_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
150 extern lzma_ret
lzma_simple_x86_decoder_init(lzma_next_coder * next,const lzma_allocator * allocator,const lzma_filter_info * filters)151 lzma_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