/*
 *    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;
}
