X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-psi;a=blobdiff_plain;f=src%2Fmodule.c;h=469fb4d6f72498ea7f5ecf9c70e0c87b66e5941f;hp=8ab22ae1b2133e847c9d43866beb8f195ec3cc14;hb=ea0162a1698563a49de50456cd3f2cc18b83a05e;hpb=6a8a77b52b636041de54d1022016b4f2aa510c05 diff --git a/src/module.c b/src/module.c index 8ab22ae..469fb4d 100644 --- a/src/module.c +++ b/src/module.c @@ -10,14 +10,22 @@ #include "php_psi.h" #include "parser.h" -#include "libjit.h" -#include "libffi.h" +#if HAVE_LIBJIT +# include "libjit.h" +# ifndef HAVE_LIBFFI +# define PSI_ENGINE "jit" +# endif +#endif +#if HAVE_LIBFFI +# include "libffi.h" +# define PSI_ENGINE "ffi" +#endif ZEND_DECLARE_MODULE_GLOBALS(psi); PHP_INI_BEGIN() - STD_PHP_INI_ENTRY("psi.engine", "ffi", PHP_INI_SYSTEM, OnUpdateString, engine, zend_psi_globals, psi_globals) - STD_PHP_INI_ENTRY("psi.directory", "psis", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals) + STD_PHP_INI_ENTRY("psi.engine", PSI_ENGINE, PHP_INI_SYSTEM, OnUpdateString, engine, zend_psi_globals, psi_globals) + STD_PHP_INI_ENTRY("psi.directory", "psi.d", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals) PHP_INI_END(); void psi_error(int type, const char *msg, ...) @@ -34,99 +42,46 @@ void psi_error(int type, const char *msg, ...) size_t psi_t_alignment(token_t t) { - size_t align; -#define PSI_TAS_D(T) struct PSI_TAS_ ##T { \ - char c; \ - T x; \ -} -#define PSI_TAS_P(T) struct PSI_TAS_ ## T ## _pointer { \ - char c; \ - T *x; \ -} -#define PSI_TAS_C(T) align = offsetof(struct PSI_TAS_ ##T, x) -#define PSI_TAS_CASE(T) { \ - PSI_TAS_D(T); \ - PSI_TAS_C(T); \ -} +#define PSI_ALIGNOF(T) case PSI_T_## T: return ALIGNOF_## T ##_T; switch (t) { - case PSI_T_INT8: - PSI_TAS_CASE(int8_t); - break; - case PSI_T_UINT8: - PSI_TAS_CASE(uint8_t); - break; - case PSI_T_INT16: - PSI_TAS_CASE(int16_t); - break; - case PSI_T_UINT16: - PSI_TAS_CASE(uint16_t); - break; - case PSI_T_INT32: - PSI_TAS_CASE(int32_t); - break; - case PSI_T_UINT32: - PSI_TAS_CASE(uint32_t); - break; - case PSI_T_INT64: - PSI_TAS_CASE(int64_t); - break; - case PSI_T_UINT64: - PSI_TAS_CASE(uint64_t); - break; + PSI_ALIGNOF(INT8); + PSI_ALIGNOF(UINT8); + PSI_ALIGNOF(INT16); + PSI_ALIGNOF(UINT16); + PSI_ALIGNOF(INT32); + PSI_ALIGNOF(UINT32); + PSI_ALIGNOF(INT64); + PSI_ALIGNOF(UINT64); case PSI_T_FLOAT: - PSI_TAS_CASE(float); - break; + return ALIGNOF_FLOAT; case PSI_T_DOUBLE: - PSI_TAS_CASE(double); - break; + return ALIGNOF_DOUBLE; case PSI_T_POINTER: - { - PSI_TAS_P(char); - PSI_TAS_C(char_pointer); - } - break; + return ALIGNOF_VOID_P; EMPTY_SWITCH_DEFAULT_CASE(); } - - return align; } size_t psi_t_size(token_t t) { - size_t size; - +#define PSI_SIZEOF(T) case PSI_T_## T : return SIZEOF_## T ##_T; switch (t) { - case PSI_T_INT8: - case PSI_T_UINT8: - size = 1; - break; - case PSI_T_INT16: - case PSI_T_UINT16: - size = 2; - break; - case PSI_T_INT: - size = sizeof(int); - break; - case PSI_T_INT32: - case PSI_T_UINT32: - size = 4; - break; - case PSI_T_INT64: - case PSI_T_UINT64: - size = 8; - break; + PSI_SIZEOF(INT8); + PSI_SIZEOF(UINT8); + PSI_SIZEOF(INT16); + PSI_SIZEOF(UINT16); + PSI_SIZEOF(INT32); + PSI_SIZEOF(UINT32); + PSI_SIZEOF(INT64); + PSI_SIZEOF(UINT64); case PSI_T_FLOAT: - size = sizeof(float); - break; + return SIZEOF_FLOAT; case PSI_T_DOUBLE: - size = sizeof(double); - break; + return SIZEOF_DOUBLE; case PSI_T_POINTER: - size = sizeof(char *); - break; + return SIZEOF_VOID_P; EMPTY_SWITCH_DEFAULT_CASE(); } - return size; } size_t psi_t_align(token_t t, size_t s) @@ -196,44 +151,75 @@ size_t psi_num_min_args(impl *impl) return n; } -void psi_to_bool(zval *return_value, token_t t, impl_val *ret_val, set_value *set, decl_var *var) +void psi_to_bool(zval *return_value, set_value *set, impl_val *ret_val) { - impl_val *v = deref_impl_val(ret_val, var); - - switch (t) { - case PSI_T_FLOAT: - RETVAL_DOUBLE((double) v->fval); - break; - case PSI_T_DOUBLE: - RETVAL_DOUBLE(v->dval); - break; - default: - RETVAL_LONG(v->lval); - break; - } + psi_to_int(return_value, set, ret_val); convert_to_boolean(return_value); } -void psi_to_int(zval *return_value, token_t t, impl_val *ret_val, set_value *set, decl_var *var) +void psi_to_int(zval *return_value, set_value *set, impl_val *ret_val) { + decl_var *var = set->vars->vars[0]; + token_t t = real_decl_type(var->arg->type)->type; impl_val *v = deref_impl_val(ret_val, var); switch (t) { case PSI_T_FLOAT: RETVAL_DOUBLE((double) v->fval); + convert_to_long(return_value); break; case PSI_T_DOUBLE: RETVAL_DOUBLE(v->dval); + convert_to_long(return_value); break; - default: - RETVAL_LONG(v->lval); - return; + case PSI_T_INT8: + RETVAL_LONG(v->i8); + break; + case PSI_T_UINT8: + RETVAL_LONG(v->u8); + break; + case PSI_T_INT16: + RETVAL_LONG(v->i16); + break; + case PSI_T_UINT16: + RETVAL_LONG(v->u16); + break; + case PSI_T_INT32: + RETVAL_LONG(v->i32); + break; + case PSI_T_UINT32: +#if UINT32_MAX >= ZEND_LONG_MAX + if (v->u32 > ZEND_LONG_MAX) { + char d[12] = {0}; + + RETVAL_STRING(zend_print_ulong_to_buf(&d[10], v->u32)); + } else { +#endif + RETVAL_LONG(v->u32); +#if UINT32_MAX >= ZEND_LONG_MAX + } +#endif + break; + case PSI_T_INT64: + RETVAL_LONG(v->i64); + break; + case PSI_T_UINT64: + if (v->u64 > ZEND_LONG_MAX) { + char d[24] = {0}; + + RETVAL_STRING(zend_print_ulong_to_buf(&d[22], v->u64)); + } else { + RETVAL_LONG(v->u64); + } + break; + EMPTY_SWITCH_DEFAULT_CASE(); } - convert_to_long(return_value); } -void psi_to_double(zval *return_value, token_t t, impl_val *ret_val, set_value *set, decl_var *var) +void psi_to_double(zval *return_value, set_value *set, impl_val *ret_val) { + decl_var *var = set->vars->vars[0]; + token_t t = real_decl_type(var->arg->type)->type; impl_val *v = deref_impl_val(ret_val, var); switch (t) { @@ -243,14 +229,39 @@ void psi_to_double(zval *return_value, token_t t, impl_val *ret_val, set_value * case PSI_T_DOUBLE: RETVAL_DOUBLE(v->dval); break; - default: - RETVAL_DOUBLE((double) v->lval); + case PSI_T_INT8: + RETVAL_DOUBLE((double) v->i8); break; + case PSI_T_UINT8: + RETVAL_DOUBLE((double) v->u8); + break; + case PSI_T_INT16: + RETVAL_DOUBLE((double) v->i16); + break; + case PSI_T_UINT16: + RETVAL_DOUBLE((double) v->u16); + break; + case PSI_T_INT32: + RETVAL_DOUBLE((double) v->i32); + break; + case PSI_T_UINT32: + RETVAL_DOUBLE((double) v->u32); + break; + case PSI_T_INT64: + RETVAL_DOUBLE((double) v->i64); + break; + case PSI_T_UINT64: + RETVAL_DOUBLE((double) v->u64); + break; + EMPTY_SWITCH_DEFAULT_CASE(); } } -void psi_to_string(zval *return_value, token_t t, impl_val *ret_val, set_value *set, decl_var *var) +void psi_to_string(zval *return_value, set_value *set, impl_val *ret_val) { + decl_var *var = set->vars->vars[0]; + token_t t = real_decl_type(var->arg->type)->type; + switch (t) { case PSI_T_INT8: case PSI_T_UINT8: @@ -272,19 +283,17 @@ void psi_to_string(zval *return_value, token_t t, impl_val *ret_val, set_value * RETVAL_DOUBLE(deref_impl_val(ret_val, var)->dval); break; default: - RETVAL_LONG(deref_impl_val(ret_val, var)->lval); + psi_to_int(return_value, set, ret_val); break; } convert_to_string(return_value); } -static impl_val *iterate(impl_val *val, token_t t, unsigned i, impl_val *tmp) +static impl_val *iterate(impl_val *val, size_t size, unsigned i, impl_val *tmp) { - size_t size = psi_t_size(t); - memset(tmp, 0, sizeof(*tmp)); - memcpy(tmp, val->ptr + size * i, size); + memcpy(tmp, ((void*) val->ptr) + size * i, size); return tmp; } @@ -338,105 +347,110 @@ void *psi_array_to_struct(decl_struct *s, HashTable *arr) return mem; } -void psi_to_array(zval *return_value, token_t t, impl_val *ret_val, set_value *set, decl_var *var) +static inline impl_val *struct_member_ref(decl_arg *set_arg, impl_val *struct_ptr, impl_val **to_free) { + void *ptr = (char *) struct_ptr->ptr + set_arg->layout->pos; + impl_val *val = enref_impl_val(ptr, set_arg->var); + + if (val != ptr) { + *to_free = val; + } + + return val; +} +void psi_to_array(zval *return_value, set_value *set, impl_val *r_val) { - zval ele; - unsigned i; - impl_val tmp; + size_t i; + decl_var *var = set->vars->vars[0]; + token_t t = real_decl_type(var->arg->type)->type; + impl_val tmp, *ret_val = deref_impl_val(r_val, var); array_init(return_value); if (t == PSI_T_STRUCT) { - decl_struct *s = real_decl_type(var->arg->type)->strct; - ret_val = deref_impl_val(ret_val, var); - - ZEND_ASSERT(s); + // decl_struct *s = real_decl_type(var->arg->type)->strct; if (set->count) { /* explicit member casts */ for (i = 0; i < set->count; ++i) { - zval ztmp; - impl_val *tmp_ptr; set_value *sub_set = set->inner[i]; decl_var *sub_var = sub_set->vars->vars[0]; - decl_arg *sub_arg = sub_var->arg; - if (sub_arg) { - token_t t = real_decl_type(sub_arg->type)->type; - void *ptr = malloc(sub_arg->layout->len); + sub_set->outer.val = r_val; + + if (sub_var->arg) { + impl_val *tmp = NULL, *val; + zval ztmp; - memcpy(ptr, (char *) ret_val->ptr + sub_arg->layout->pos, - sub_arg->layout->len); - tmp_ptr = enref_impl_val(ptr, sub_arg->var); - sub_set->func->handler(&ztmp, t, tmp_ptr, sub_set, sub_var); + val = deref_impl_val(struct_member_ref(sub_var->arg, ret_val, &tmp), sub_var); + sub_set->func->handler(&ztmp, sub_set, val); add_assoc_zval(return_value, sub_var->name, &ztmp); - free(tmp_ptr); - if (tmp_ptr != ptr) { - free(ptr); + + if (tmp) { + free(tmp); } } } } return; + } -// for (i = 0; i < s->args->count; ++i) { -// decl_arg *darg = s->args->args[i]; -// impl_val tmp, tmp_ptr; -// zval ztmp; -// char *ptr = (char *) ret_val->ptr + darg->layout->pos; -// -// tmp_ptr.ptr = &tmp; -// memset(&tmp, 0, sizeof(tmp)); -// memcpy(&tmp, ptr, darg->layout->len); -// switch (real_decl_type(darg->type)->type) { -// case PSI_T_FLOAT: -// case PSI_T_DOUBLE: -// psi_to_double(&ztmp, real_decl_type(darg->type)->type, &tmp, darg->var); -// break; -// case PSI_T_INT8: -// case PSI_T_UINT8: -// if (darg->var->pointer_level) { -// psi_to_string(&ztmp, real_decl_type(darg->type)->type, &tmp_ptr, darg->var); -// break; -// } -// /* no break */ -// case PSI_T_INT16: -// case PSI_T_UINT16: -// case PSI_T_INT32: -// case PSI_T_UINT32: -// case PSI_T_INT64: -// case PSI_T_UINT64: -// psi_to_int(&ztmp, real_decl_type(darg->type)->type, &tmp, darg->var); -// break; -// case PSI_T_STRUCT: -// psi_to_array(&ztmp, real_decl_type(darg->type)->type, &tmp_ptr, darg->var); -// break; -// default: -// printf("t=%d\n", real_decl_type(darg->type)->type); -// abort(); -// } -// add_assoc_zval(return_value, darg->var->name, &ztmp); -// } + if (var->arg->var->array_size) { + /* to_array(foo[NUMBER]) */ + for (i = 0; i < var->arg->var->array_size; ++i) { + size_t size = psi_t_size(var->arg->var->pointer_level > 1 ? PSI_T_POINTER : t); + impl_val *ptr = iterate(ret_val, size, i, &tmp); + zval ele; + + switch (t) { + case PSI_T_FLOAT: + ZVAL_DOUBLE(&ele, (double) ptr->fval); + break; + case PSI_T_DOUBLE: + ZVAL_DOUBLE(&ele, ptr->dval); + break; + default: + ZVAL_LONG(&ele, ptr->lval); + break; + } + + add_next_index_zval(return_value, &ele); + } return; - } - ret_val = deref_impl_val(ret_val, var); - for (i = 0; i < var->arg->var->array_size; ++i) { - impl_val *ptr = iterate(ret_val, t, i, &tmp); + } else if (set->vars->count > 1) { + /* to_array(arr_var, cnt_var[, cnt_var...], to_int(*arr_var)) + * check for length in second var + */ + size_t count = 0; + zval ele; - switch (t) { - case PSI_T_FLOAT: - ZVAL_DOUBLE(&ele, (double) ptr->fval); - break; - case PSI_T_DOUBLE: - ZVAL_DOUBLE(&ele, ptr->dval); - break; - default: - ZVAL_LONG(&ele, ptr->lval); - break; + if (set->outer.set) { + /* struct */ + for (i = 1; i < set->vars->count; ++i) { + impl_val *tmp = NULL, *cnt_val; + decl_var *cnt_var = set->vars->vars[i]; + + cnt_val = struct_member_ref(cnt_var->arg, set->outer.val, &tmp); + count += deref_impl_val(cnt_val, cnt_var)->lval; + + if (tmp) { + free(tmp); + } + } + } else { + ZEND_ASSERT(0); } - add_next_index_zval(return_value, &ele); + for (i = 0; i < count; ++i) { + size_t size = psi_t_size(var->arg->var->pointer_level ? PSI_T_POINTER : t); + impl_val *ptr = iterate(ret_val, size, i, &tmp); + + set->inner[0]->func->handler(&ele, set->inner[0], ptr); + add_next_index_zval(return_value, &ele); + } + } else { + ZEND_ASSERT(0); } + } static inline ZEND_RESULT_CODE psi_parse_args(zend_execute_data *execute_data, impl *impl) @@ -598,20 +612,15 @@ static inline void *psi_do_let(decl_arg *darg) static inline void psi_do_set(zval *return_value, set_value *set) { - impl_val *val = (impl_val *) &set->vars->vars[0]->arg->let->ptr; - token_t t = real_decl_type(set->vars->vars[0]->arg->type)->type; - ZVAL_DEREF(return_value); zval_dtor(return_value); - set->func->handler(return_value, t, val, set, set->vars->vars[0]); + set->func->handler(return_value, set, set->vars->vars[0]->arg->let->ptr); } static inline void psi_do_return(zval *return_value, return_stmt *ret, impl_val *ret_val) { - token_t t = real_decl_type(ret->decl->type)->type; - - ret->set->func->handler(return_value, t, ret_val, ret->set, ret->decl->var); + ret->set->func->handler(return_value, ret->set, ret_val); } static inline void psi_do_free(free_stmt *fre) @@ -629,6 +638,7 @@ static inline void psi_do_free(free_stmt *fre) f->decl->call.args[j] = &darg->let->out; } + /* FIXME: check in validate_* that free functions return scalar */ PSI_ContextCall(&PSI_G(context), &dummy, f->decl); } } @@ -685,6 +695,7 @@ void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl) } } + memset(&ret_val, 0, sizeof(ret_val)); PSI_ContextCall(&PSI_G(context), &ret_val, impl->decl); psi_do_return(return_value, impl->stmts->ret.list[0], &ret_val); @@ -708,19 +719,31 @@ void psi_call(zend_execute_data *execute_data, zval *return_value, impl *impl) PHP_MINIT_FUNCTION(psi) { - PSI_ContextOps *ops; + PSI_ContextOps *ops = NULL; REGISTER_INI_ENTRIES(); +#ifdef HAVE_LIBJIT if (!strcasecmp(PSI_G(engine), "jit")) { ops = PSI_Libjit(); - } else { + } else +#endif +#ifdef HAVE_LIBFFI ops = PSI_Libffi(); +#endif + + if (!ops) { + php_error(E_WARNING, "No PSI engine found"); + return FAILURE; } PSI_ContextInit(&PSI_G(context), ops, psi_error); PSI_ContextBuild(&PSI_G(context), PSI_G(directory)); + if (psi_check_env("PSI_DUMP")) { + PSI_ContextDump(&PSI_G(context), STDOUT_FILENO); + } + return SUCCESS; } PHP_MSHUTDOWN_FUNCTION(psi)