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