/*

 *    Stack-less Just-In-Time compiler

 *

 *    Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without modification, are

 * permitted provided that the following conditions are met:

 *

 *   1. Redistributions of source code must retain the above copyright notice, this list of

 *      conditions and the following disclaimer.

 *

 *   2. Redistributions in binary form must reproduce the above copyright notice, this list

 *      of conditions and the following disclaimer in the documentation and/or other materials

 *      provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT

 * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED

 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_jump_has_label(struct sljit_jump *jump)

{

  return !(jump->flags & JUMP_ADDR) && (jump->u.label != NULL);

}

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_jump_has_target(struct sljit_jump *jump)

{

  return (jump->flags & JUMP_ADDR) != 0;

}

SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_jump_is_mov_addr(struct sljit_jump *jump)

{

  return (jump->flags & JUMP_MOV_ADDR) != 0;

}

#define SLJIT_SERIALIZE_DEBUG ((sljit_u16)0x1)

struct sljit_serialized_compiler {

  sljit_u32 signature;

  sljit_u16 version;

  sljit_u16 cpu_type;

  sljit_uw buf_segment_count;

  sljit_uw label_count;

  sljit_uw jump_count;

  sljit_uw const_count;

  sljit_s32 options;

  sljit_s32 scratches;

  sljit_s32 saveds;

  sljit_s32 fscratches;

  sljit_s32 fsaveds;

  sljit_s32 local_size;

  sljit_uw size;

#if (defined SLJIT_HAS_STATUS_FLAGS_STATE && SLJIT_HAS_STATUS_FLAGS_STATE)

  sljit_s32 status_flags_state;

#endif /* SLJIT_HAS_STATUS_FLAGS_STATE */

#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32)

  sljit_s32 args_size;

#endif /* SLJIT_CONFIG_X86_32 */

#if ((defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32) && (defined __SOFTFP__)) \

    || (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)

  sljit_uw args_size;

#endif /* (SLJIT_CONFIG_ARM_32 && __SOFTFP__) || SLJIT_CONFIG_MIPS_32 */

#if (defined SLJIT_CONFIG_ARM_V6 && SLJIT_CONFIG_ARM_V6)

  sljit_uw cpool_diff;

  sljit_uw cpool_fill;

  sljit_uw patches;

#endif /* SLJIT_CONFIG_ARM_V6 */

#if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)

  sljit_s32 delay_slot;

#endif /* SLJIT_CONFIG_MIPS */

};

struct sljit_serialized_debug_info {

  sljit_sw last_flags;

  sljit_s32 last_return;

  sljit_s32 logical_local_size;

};

struct sljit_serialized_label {

  sljit_uw size;

};

struct sljit_serialized_jump {

  sljit_uw addr;

  sljit_uw flags;

  sljit_uw value;

};

struct sljit_serialized_const {

  sljit_uw addr;

};

#define SLJIT_SERIALIZE_ALIGN(v) (((v) + sizeof(sljit_uw) - 1) & ~(sljit_uw)(sizeof(sljit_uw) - 1))

#if (defined SLJIT_LITTLE_ENDIAN && SLJIT_LITTLE_ENDIAN)

#define SLJIT_SERIALIZE_SIGNATURE 0x534c4a54

#else /* !SLJIT_LITTLE_ENDIAN */

#define SLJIT_SERIALIZE_SIGNATURE 0x544a4c53

#endif /* SLJIT_LITTLE_ENDIAN */

#define SLJIT_SERIALIZE_VERSION 1

SLJIT_API_FUNC_ATTRIBUTE sljit_uw* sljit_serialize_compiler(struct sljit_compiler *compiler,

  sljit_s32 options, sljit_uw *size)

{

  sljit_uw serialized_size = sizeof(struct sljit_serialized_compiler);

  struct sljit_memory_fragment *buf;

  struct sljit_label *label;

  struct sljit_jump *jump;

  struct sljit_const *const_;

  struct sljit_serialized_compiler *serialized_compiler;

  struct sljit_serialized_label *serialized_label;

  struct sljit_serialized_jump *serialized_jump;

  struct sljit_serialized_const *serialized_const;

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \

    || (defined SLJIT_DEBUG && SLJIT_DEBUG)

  struct sljit_serialized_debug_info *serialized_debug_info;

#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */

  sljit_uw counter, used_size;

  sljit_u8 *result;

  sljit_u8 *ptr;

  SLJIT_UNUSED_ARG(options);

  if (size != NULL)

    *size = 0;

  PTR_FAIL_IF(compiler->error);

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \

    || (defined SLJIT_DEBUG && SLJIT_DEBUG)

  if (!(options & SLJIT_SERIALIZE_IGNORE_DEBUG))

    serialized_size += sizeof(struct sljit_serialized_debug_info);

#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */

#if (defined SLJIT_CONFIG_ARM_V6 && SLJIT_CONFIG_ARM_V6)

  serialized_size += SLJIT_SERIALIZE_ALIGN(compiler->cpool_fill * (sizeof(sljit_uw) + 1));

#endif /* SLJIT_CONFIG_ARM_V6 */

  /* Compute the size of the data. */

  buf = compiler->buf;

  while (buf != NULL) {

    serialized_size += sizeof(sljit_uw) + SLJIT_SERIALIZE_ALIGN(buf->used_size);

    buf = buf->next;

  }

  serialized_size += compiler->label_count * sizeof(struct sljit_serialized_label);

  jump = compiler->jumps;

  while (jump != NULL) {

    serialized_size += sizeof(struct sljit_serialized_jump);

    jump = jump->next;

  }

  const_ = compiler->consts;

  while (const_ != NULL) {

    serialized_size += sizeof(struct sljit_serialized_const);

    const_ = const_->next;

  }

  result = (sljit_u8*)SLJIT_MALLOC(serialized_size, compiler->allocator_data);

  PTR_FAIL_IF_NULL(result);

  if (size != NULL)

    *size = serialized_size;

  ptr = result;

  serialized_compiler = (struct sljit_serialized_compiler*)ptr;

  ptr += sizeof(struct sljit_serialized_compiler);

  serialized_compiler->signature = SLJIT_SERIALIZE_SIGNATURE;

  serialized_compiler->version = SLJIT_SERIALIZE_VERSION;

  serialized_compiler->cpu_type = 0;

  serialized_compiler->label_count = compiler->label_count;

  serialized_compiler->options = compiler->options;

  serialized_compiler->scratches = compiler->scratches;

  serialized_compiler->saveds = compiler->saveds;

  serialized_compiler->fscratches = compiler->fscratches;

  serialized_compiler->fsaveds = compiler->fsaveds;

  serialized_compiler->local_size = compiler->local_size;

  serialized_compiler->size = compiler->size;

#if (defined SLJIT_HAS_STATUS_FLAGS_STATE && SLJIT_HAS_STATUS_FLAGS_STATE)

  serialized_compiler->status_flags_state = compiler->status_flags_state;

#endif /* SLJIT_HAS_STATUS_FLAGS_STATE */

#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \

    || ((defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32) && (defined __SOFTFP__)) \

    || (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)

  serialized_compiler->args_size = compiler->args_size;

#endif /* SLJIT_CONFIG_X86_32 || (SLJIT_CONFIG_ARM_32 && __SOFTFP__) || SLJIT_CONFIG_MIPS_32 */

#if (defined SLJIT_CONFIG_ARM_V6 && SLJIT_CONFIG_ARM_V6)

  serialized_compiler->cpool_diff = compiler->cpool_diff;

  serialized_compiler->cpool_fill = compiler->cpool_fill;

  serialized_compiler->patches = compiler->patches;

  SLJIT_MEMCPY(ptr, compiler->cpool, compiler->cpool_fill * sizeof(sljit_uw));

  SLJIT_MEMCPY(ptr + compiler->cpool_fill * sizeof(sljit_uw), compiler->cpool_unique, compiler->cpool_fill);

  ptr += SLJIT_SERIALIZE_ALIGN(compiler->cpool_fill * (sizeof(sljit_uw) + 1));

#endif /* SLJIT_CONFIG_ARM_V6 */

#if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)

  serialized_compiler->delay_slot = compiler->delay_slot;

#endif /* SLJIT_CONFIG_MIPS */

  buf = compiler->buf;

  counter = 0;

  while (buf != NULL) {

    used_size = buf->used_size;

    *(sljit_uw*)ptr = used_size;

    ptr += sizeof(sljit_uw);

    SLJIT_MEMCPY(ptr, buf->memory, used_size);

    ptr += SLJIT_SERIALIZE_ALIGN(used_size);

    buf = buf->next;

    counter++;

  }

  serialized_compiler->buf_segment_count = counter;

  label = compiler->labels;

  while (label != NULL) {

    serialized_label = (struct sljit_serialized_label*)ptr;

    serialized_label->size = label->size;

    ptr += sizeof(struct sljit_serialized_label);

    label = label->next;

  }

  jump = compiler->jumps;

  counter = 0;

  while (jump != NULL) {

    serialized_jump = (struct sljit_serialized_jump*)ptr;

    serialized_jump->addr = jump->addr;

    serialized_jump->flags = jump->flags;

    if (jump->flags & JUMP_ADDR)

      serialized_jump->value = jump->u.target;

    else if (jump->u.label != NULL)

      serialized_jump->value = jump->u.label->u.index;

    else

      serialized_jump->value = SLJIT_MAX_ADDRESS;

    ptr += sizeof(struct sljit_serialized_jump);

    jump = jump->next;

    counter++;

  }

  serialized_compiler->jump_count = counter;

  const_ = compiler->consts;

  counter = 0;

  while (const_ != NULL) {

    serialized_const = (struct sljit_serialized_const*)ptr;

    serialized_const->addr = const_->addr;

    ptr += sizeof(struct sljit_serialized_const);

    const_ = const_->next;

    counter++;

  }

  serialized_compiler->const_count = counter;

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \

    || (defined SLJIT_DEBUG && SLJIT_DEBUG)

  if (!(options & SLJIT_SERIALIZE_IGNORE_DEBUG)) {

    serialized_debug_info = (struct sljit_serialized_debug_info*)ptr;

    serialized_debug_info->last_flags = compiler->last_flags;

    serialized_debug_info->last_return = compiler->last_return;

    serialized_debug_info->logical_local_size = compiler->logical_local_size;

    serialized_compiler->cpu_type |= SLJIT_SERIALIZE_DEBUG;

#if (defined SLJIT_DEBUG && SLJIT_DEBUG)

    ptr += sizeof(struct sljit_serialized_debug_info);

#endif /* SLJIT_DEBUG */

  }

#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */

  SLJIT_ASSERT((sljit_uw)(ptr - result) == serialized_size);

  return (sljit_uw*)result;

}

SLJIT_API_FUNC_ATTRIBUTE struct sljit_compiler *sljit_deserialize_compiler(sljit_uw* buffer, sljit_uw size,

  sljit_s32 options, void *allocator_data)

{

  struct sljit_compiler *compiler;

  struct sljit_serialized_compiler *serialized_compiler;

  struct sljit_serialized_label *serialized_label;

  struct sljit_serialized_jump *serialized_jump;

  struct sljit_serialized_const *serialized_const;

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \

    || (defined SLJIT_DEBUG && SLJIT_DEBUG)

  struct sljit_serialized_debug_info *serialized_debug_info;

#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */

  struct sljit_memory_fragment *buf;

  struct sljit_memory_fragment *last_buf;

  struct sljit_label *label;

  struct sljit_label *last_label;

  struct sljit_label **label_list = NULL;

  struct sljit_jump *jump;

  struct sljit_jump *last_jump;

  struct sljit_const *const_;

  struct sljit_const *last_const;

  sljit_u8 *ptr = (sljit_u8*)buffer;

  sljit_u8 *end = ptr + size;

  sljit_uw i, used_size, aligned_size, label_count;

  SLJIT_UNUSED_ARG(options);

  if (size < sizeof(struct sljit_serialized_compiler) || (size & (sizeof(sljit_uw) - 1)) != 0)

    return NULL;

  serialized_compiler = (struct sljit_serialized_compiler*)ptr;

  if (serialized_compiler->signature != SLJIT_SERIALIZE_SIGNATURE || serialized_compiler->version != SLJIT_SERIALIZE_VERSION)

    return NULL;

  compiler = sljit_create_compiler(allocator_data);

  PTR_FAIL_IF(compiler == NULL);

  compiler->label_count = serialized_compiler->label_count;

  compiler->options = serialized_compiler->options;

  compiler->scratches = serialized_compiler->scratches;

  compiler->saveds = serialized_compiler->saveds;

  compiler->fscratches = serialized_compiler->fscratches;

  compiler->fsaveds = serialized_compiler->fsaveds;

  compiler->local_size = serialized_compiler->local_size;

  compiler->size = serialized_compiler->size;

#if (defined SLJIT_HAS_STATUS_FLAGS_STATE && SLJIT_HAS_STATUS_FLAGS_STATE)

  compiler->status_flags_state = serialized_compiler->status_flags_state;

#endif /* SLJIT_HAS_STATUS_FLAGS_STATE */

#if (defined SLJIT_CONFIG_X86_32 && SLJIT_CONFIG_X86_32) \

    || ((defined SLJIT_CONFIG_ARM_32 && SLJIT_CONFIG_ARM_32) && (defined __SOFTFP__)) \

    || (defined SLJIT_CONFIG_MIPS_32 && SLJIT_CONFIG_MIPS_32)

  compiler->args_size = serialized_compiler->args_size;

#endif /* SLJIT_CONFIG_X86_32 || (SLJIT_CONFIG_ARM_32 && __SOFTFP__) || SLJIT_CONFIG_MIPS_32 */

#if (defined SLJIT_CONFIG_ARM_V6 && SLJIT_CONFIG_ARM_V6)

  used_size = serialized_compiler->cpool_fill;

  aligned_size = SLJIT_SERIALIZE_ALIGN(used_size * (sizeof(sljit_uw) + 1));

  compiler->cpool_diff = serialized_compiler->cpool_diff;

  compiler->cpool_fill = used_size;

  compiler->patches = serialized_compiler->patches;

  if ((sljit_uw)(end - ptr) < aligned_size)

    goto error;

  SLJIT_MEMCPY(compiler->cpool, ptr, used_size * sizeof(sljit_uw));

  SLJIT_MEMCPY(compiler->cpool_unique, ptr + used_size * sizeof(sljit_uw), used_size);

  ptr += aligned_size;

#endif /* SLJIT_CONFIG_ARM_V6 */

#if (defined SLJIT_CONFIG_MIPS && SLJIT_CONFIG_MIPS)

  compiler->delay_slot = serialized_compiler->delay_slot;

#endif /* SLJIT_CONFIG_MIPS */

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \

    || (defined SLJIT_DEBUG && SLJIT_DEBUG)

  if (!(serialized_compiler->cpu_type & SLJIT_SERIALIZE_DEBUG))

    goto error;

#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */

  ptr += sizeof(struct sljit_serialized_compiler);

  i = serialized_compiler->buf_segment_count;

  last_buf = NULL;

  while (i > 0) {

    if ((sljit_uw)(end - ptr) < sizeof(sljit_uw))

      goto error;

    used_size = *(sljit_uw*)ptr;

    aligned_size = SLJIT_SERIALIZE_ALIGN(used_size);

    ptr += sizeof(sljit_uw);

    if ((sljit_uw)(end - ptr) < aligned_size)

      goto error;

    if (last_buf == NULL) {

      SLJIT_ASSERT(compiler->buf != NULL && compiler->buf->next == NULL);

      buf = compiler->buf;

    } else {

      buf = (struct sljit_memory_fragment*)SLJIT_MALLOC(BUF_SIZE, allocator_data);

      if (!buf)

        goto error;

      buf->next = NULL;

    }

    buf->used_size = used_size;

    SLJIT_MEMCPY(buf->memory, ptr, used_size);

    if (last_buf != NULL)

      last_buf->next = buf;

    last_buf = buf;

    ptr += aligned_size;

    i--;

  }

  last_label = NULL;

  label_count = serialized_compiler->label_count;

  if ((sljit_uw)(end - ptr) < label_count * sizeof(struct sljit_serialized_label))

    goto error;

  label_list = (struct sljit_label **)SLJIT_MALLOC(label_count * sizeof(struct sljit_label*), allocator_data);

  if (label_list == NULL)

    goto error;

  for (i = 0; i < label_count; i++) {

    label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label));

    if (label == NULL)

      goto error;

    serialized_label = (struct sljit_serialized_label*)ptr;

    label->next = NULL;

    label->u.index = i;

    label->size = serialized_label->size;

    if (last_label != NULL)

      last_label->next = label;

    else

      compiler->labels = label;

    last_label = label;

    label_list[i] = label;

    ptr += sizeof(struct sljit_serialized_label);

  }

  compiler->last_label = last_label;

  last_jump = NULL;

  i = serialized_compiler->jump_count;

  if ((sljit_uw)(end - ptr) < i * sizeof(struct sljit_serialized_jump))

    goto error;

  while (i > 0) {

    jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));

    if (jump == NULL)

      goto error;

    serialized_jump = (struct sljit_serialized_jump*)ptr;

    jump->next = NULL;

    jump->addr = serialized_jump->addr;

    jump->flags = serialized_jump->flags;

    if (!(serialized_jump->flags & JUMP_ADDR)) {

      if (serialized_jump->value != SLJIT_MAX_ADDRESS) {

        if (serialized_jump->value >= label_count)

          goto error;

        jump->u.label = label_list[serialized_jump->value];

      } else

        jump->u.label = NULL;

    } else

      jump->u.target = serialized_jump->value;

    if (last_jump != NULL)

      last_jump->next = jump;

    else

      compiler->jumps = jump;

    last_jump = jump;

    ptr += sizeof(struct sljit_serialized_jump);

    i--;

  }

  compiler->last_jump = last_jump;

  SLJIT_FREE(label_list, allocator_data);

  label_list = NULL;

  last_const = NULL;

  i = serialized_compiler->const_count;

  if ((sljit_uw)(end - ptr) < i * sizeof(struct sljit_serialized_const))

    goto error;

  while (i > 0) {

    const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));

    if (const_ == NULL)

      goto error;

    serialized_const = (struct sljit_serialized_const*)ptr;

    const_->next = NULL;

    const_->addr = serialized_const->addr;

    if (last_const != NULL)

      last_const->next = const_;

    else

      compiler->consts = const_;

    last_const = const_;

    ptr += sizeof(struct sljit_serialized_const);

    i--;

  }

  compiler->last_const = last_const;

#if (defined SLJIT_ARGUMENT_CHECKS && SLJIT_ARGUMENT_CHECKS) \

    || (defined SLJIT_DEBUG && SLJIT_DEBUG)

  if ((sljit_uw)(end - ptr) < sizeof(struct sljit_serialized_debug_info))

    goto error;

  serialized_debug_info = (struct sljit_serialized_debug_info*)ptr;

  compiler->last_flags = (sljit_s32)serialized_debug_info->last_flags;

  compiler->last_return = serialized_debug_info->last_return;

  compiler->logical_local_size = serialized_debug_info->logical_local_size;

#endif /* SLJIT_ARGUMENT_CHECKS || SLJIT_DEBUG */

  return compiler;

error:

  sljit_free_compiler(compiler);

  if (label_list != NULL)

    SLJIT_FREE(label_list, allocator_data);

  return NULL;

}