src/liblzma/simple/x86.c

   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