// SPDX-License-Identifier: 0BSD

///////////////////////////////////////////////////////////////////////////////

//

/// \file       x86.c

/// \brief      Filter for x86 binaries (BCJ filter)

///

//  Authors:    Igor Pavlov

//              Lasse Collin

//

///////////////////////////////////////////////////////////////////////////////

#include "simple_private.h"

#define Test86MSByte(b) ((b) == 0 || (b) == 0xFF)

typedef struct {

  uint32_t prev_mask;

  uint32_t prev_pos;

} lzma_simple_x86;

static size_t

x86_code(void *simple_ptr, uint32_t now_pos, bool is_encoder,

    uint8_t *buffer, size_t size)

{

  static const uint32_t MASK_TO_BIT_NUMBER[5] = { 0, 1, 2, 2, 3 };

  lzma_simple_x86 *simple = simple_ptr;

  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) && (prev_mask >> 1) <= 4

      && (prev_mask >> 1) != 3) {

      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 ^ ((1ull << (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, const 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_x86), 5, 1, is_encoder);

  if (ret == LZMA_OK) {

    lzma_simple_coder *coder = next->coder;

    lzma_simple_x86 *simple = coder->simple;

    simple->prev_mask = 0;

    simple->prev_pos = (uint32_t)(-5);

  }

  return ret;

}

#ifdef HAVE_ENCODER_X86

extern lzma_ret

lzma_simple_x86_encoder_init(lzma_next_coder *next,

    const lzma_allocator *allocator,

    const lzma_filter_info *filters)

{

  return x86_coder_init(next, allocator, filters, true);

}

#endif

#ifdef HAVE_DECODER_X86

extern lzma_ret

lzma_simple_x86_decoder_init(lzma_next_coder *next,

    const lzma_allocator *allocator,

    const lzma_filter_info *filters)

{

  return x86_coder_init(next, allocator, filters, false);

}

#endif