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 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 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 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 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