Hugging Face's logo

Datasets:
meddyrat
/
dis-bench

Modalities:
Tabular
Text
Formats:
parquet
Size:
1K - 10K
Libraries:
Datasets
pandas
Polars
Dataset card Data Studio Files
xet
 Community
1
dis-bench / src /php /php-src /ext /pcre /pcre2lib /sljit /sljitSerialize.c
meddyrat's picture
meddyrat
Replace repository contents with the original corrected artifact
1e94262
Raw History Blame Contribute Delete
17.1 kB
/*
* 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;
}