From 207ff7bc85e967235f0ad1ffbf47c0f85f375063 Mon Sep 17 00:00:00 2001 From: Michael Wallner Date: Tue, 10 Nov 2015 15:04:42 +0100 Subject: [PATCH] flush --- config.m4 | 52 +++- src/context.c | 589 +++++++++++++++++++++++++++++++++++++++++--- src/context.h | 11 +- src/libffi.c | 19 +- src/libjit.c | 19 +- src/module.c | 21 +- src/parser.h | 117 ++++++--- src/parser.re | 2 +- src/parser_proc.y | 8 +- tests/idn/idn.psi | 4 +- tests/time/time.psi | 32 --- 11 files changed, 722 insertions(+), 152 deletions(-) diff --git a/config.m4 b/config.m4 index 338fcd3..ee54dac 100644 --- a/config.m4 +++ b/config.m4 @@ -119,7 +119,6 @@ if test "$PHP_PSI" != "no"; then ]) - PSI_CONSTS="" dnl PSI_COMPUTE_STR(variable, string or expression, includes) AC_DEFUN(PSI_COMPUTE_STR, [ AC_TRY_RUN([ @@ -132,6 +131,7 @@ if test "$PHP_PSI" != "no"; then ]) ]) + PSI_CONSTS="" dnl PSI_CONST(const name, type, headers to include) AC_DEFUN(PSI_CONST, [ AC_CACHE_CHECK(value of $1, psi_cv_const_$1, [ @@ -155,10 +155,10 @@ if test "$PHP_PSI" != "no"; then then case $2 in str*|quoted_str*) - PSI_CONSTS="{PSI_T_STRING, \"string\", \"$1\", $psi_cv_const_$1, PSI_T_QUOTED_STRING}, $PSI_CONSTS" + PSI_CONSTS="{PSI_T_STRING, \"string\", \"psi\\\\$1\", $psi_cv_const_$1, PSI_T_QUOTED_STRING}, $PSI_CONSTS" ;; *) - PSI_CONSTS="{PSI_T_INT, \"int\", \"$1\", \"$psi_cv_const_$1\", PSI_T_NUMBER}, $PSI_CONSTS" + PSI_CONSTS="{PSI_T_INT, \"int\", \"psi\\\\$1\", \"$psi_cv_const_$1\", PSI_T_NUMBER}, $PSI_CONSTS" ;; esac fi @@ -218,7 +218,13 @@ if test "$PHP_PSI" != "no"; then then psi_struct_member_pl=`expr $psi_struct_member_pl + 1` fi - psi_struct_members="{`psi_type_pair $psi_member_type $ac_cv_sizeof_struct_$1[]_[]member`, \"[]member[]\", $ac_cv_offsetof_struct_$1[]_[]member, $ac_cv_sizeof_struct_$1[]_[]member, $psi_struct_member_pl, $psi_struct_member_as}, $psi_struct_members" + psi_struct_member="{`psi_type_pair $psi_member_type $ac_cv_sizeof_struct_$1[]_[]member`, \"[]member[]\", $ac_cv_offsetof_struct_$1[]_[]member, $ac_cv_sizeof_struct_$1[]_[]member, $psi_struct_member_pl, $psi_struct_member_as}" + if test "$psi_struct_members" + then + psi_struct_members="$psi_struct_members, $psi_struct_member" + else + psi_struct_members="$psi_struct_member" + fi ], [], PSI_INCLUDES_DEFAULT($4)) ]) PSI_STRUCTS="{\"$1\", {$psi_struct_members}}, $PSI_STRUCTS" @@ -395,6 +401,19 @@ if test "$PHP_PSI" != "no"; then PSI_CONST(UTIME_NOW, int, sys/stat.h) PSI_CONST(UTIME_OMIT, int, sys/stat.h) dnl sys/time.h + PSI_STRUCT(timeval, [ + [tv_sec], + [tv_usec]], [ + ], sys/time.h) + PSI_STRUCT(itimerval, [ + [it_interval], + [it_value]], [ + it_*) psi_member_type="struct timeval" ;; + ], sys/time.h) + PSI_STRUCT(timezone, [ + [tz_minuteswest], + [tz_dsttime]], [ + ], sys/time.h) PSI_CONST(ITIMER_REAL, int, sys/time.h) PSI_CONST(ITIMER_VIRTUAL, int, sys/time.h) PSI_CONST(ITIMER_PROF, int, sys/time.h) @@ -419,7 +438,28 @@ if test "$PHP_PSI" != "no"; then PSI_TYPE(time_t, int) PSI_TYPE(timer_t, int) PSI_TYPE(uid_t) - + dnl time.h + PSI_STRUCT(tm, [ + [tm_sec], + [tm_min], + [tm_hour], + [tm_mday], + [tm_mon], + [tm_year], + [tm_wday], + [tm_yday], + [tm_isdst]], [ + ], time.h) + PSI_STRUCT(timespec, [ + [tv_sec], + [tv_nsec]], [ + ], time.h) + PSI_CONST(CLOCKS_PER_SEC, int, time.h) + PSI_CONST(CLOCK_MONOTONIC, int, time.h) + PSI_CONST(CLOCK_PROCESS_CPUTIME_ID, int, time.h) + PSI_CONST(CLOCK_REALTIME, int, time.h) + PSI_CONST(CLOCK_THREAD_CPUTIME_ID, int, time.h) + PSI_CONST(TIMER_ABSTIME, int, time.h) dnl wchar.h AC_CHECK_TYPE(wint_t, [ AX_CHECK_SIGN(wint_t, psi_wint_t=int, psi_wint_t=uint) @@ -444,7 +484,7 @@ if test "$PHP_PSI" != "no"; then PHP_ADD_BUILD_DIR($PHP_PSI_BUILDDIR/src) PHP_PSI_HEADERS=`(cd $PHP_PSI_SRCDIR/src && echo *.h)` - PHP_PSI_SOURCES="src/parser_proc.c src/parser.c src/validator.c src/module.c src/context.c" + PHP_PSI_SOURCES="src/parser_proc.c src/parser.c src/module.c src/context.c" PHP_PSI_SOURCES="$PHP_PSI_SOURCES src/libjit.c src/libffi.c" PHP_NEW_EXTENSION(psi, $PHP_PSI_SOURCES, $ext_shared) diff --git a/src/context.c b/src/context.c index 2d821ad..f0080f7 100644 --- a/src/context.c +++ b/src/context.c @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -9,9 +10,9 @@ #include "php.h" #include "php_scandir.h" +#include "php_psi.h" #include "context.h" #include "parser.h" -#include "validator.h" #define psi_predef_count(of) ((sizeof(psi_predef ##of## s)/sizeof(psi_predef ##of))-1) typedef struct psi_predef_type { @@ -55,10 +56,403 @@ static const psi_predef_struct psi_predef_structs[] = { }; #define psi_predef_struct_count() psi_predef_count(_struct) +static int validate_lib(PSI_Data *data, void **dlopened) { + char lib[MAXPATHLEN]; + const char *ptr = data->psi.file.ln; + size_t len; + + if (!ptr) { + /* FIXME: assume stdlib */ + return 1; + } else if (!strchr(ptr, '/')) { +#ifdef DARWIN + len = snprintf(lib, MAXPATHLEN, "lib%s.dylib", ptr); +#else + len = snprintf(lib, MAXPATHLEN, "lib%s.so", ptr); +#endif + if (MAXPATHLEN == len) { + data->error(PSI_WARNING, "Library name too long: '%s'", ptr); + } + lib[len] = 0; + ptr = lib; + } + if (!(*dlopened = dlopen(ptr, RTLD_LAZY|RTLD_LOCAL))) { + data->error(PSI_WARNING, "Could not open library '%s': %s.", + data->psi.file.fn, dlerror()); + return 0; + } + return 1; +} + +static inline int locate_decl_type_alias(decl_typedefs *defs, decl_type *type) { + size_t i; + + if (type->real) { + return 1; + } + for (i = 0; i < defs->count; ++i) { + if (!strcmp(defs->list[i]->alias, type->name)) { + type->real = defs->list[i]->type; + return 1; + } + } + return 0; +} +static inline int locate_decl_type_struct(decl_structs *structs, decl_type *type) { + size_t i; + + if (type->strct) { + return 1; + } + for (i = 0; i < structs->count; ++i) { + if (!strcmp(structs->list[i]->name, type->name)) { + type->strct = structs->list[i]; + return 1; + } + } + return 0; +} + +static inline int validate_decl_type(PSI_Data *data, decl_type *type) { + switch (type->type) { + case PSI_T_NAME: + if (!data->defs || !locate_decl_type_alias(data->defs, type)) { + return 0; + } + return validate_decl_type(data, type->real); + case PSI_T_STRUCT: + if (!data->structs || !locate_decl_type_struct(data->structs, type)) { + return 0; + } + break; + } + return 1; +} +static inline int validate_decl_typedef(PSI_Data *data, decl_typedef *def) { + if (!validate_decl_type(data, def->type)) { + data->error(PSI_WARNING, "Type '%s' cannot be aliased to '%s'", + def->type->name, def->alias); + return 0; + } + /* FIXME: check def->alias */ + return 1; +} + +static inline int validate_constant(PSI_Data *data, constant *c) { + /* FIXME */ + return 1; +} + +static inline int validate_decl_arg(PSI_Data *data, decl_arg *arg) { + if (!validate_decl_type(data, arg->type)) { + data->error(PSI_WARNING, "Cannot use '%s' as type for '%s'", + arg->type->name, arg->var->name); + return 0; + } + return 1; +} + +static inline int validate_decl_struct(PSI_Data *data, decl_struct *s) { + size_t i; + + for (i = 0; i < s->args->count; ++i) { + if (!validate_decl_arg(data, s->args->args[i])) { + return 0; + } + } + + for (i = 0; i < s->args->count; ++i) { + decl_arg *darg = s->args->args[i]; + + if (!validate_decl_arg(data, darg)) { + return 0; + } + + ZEND_ASSERT(!darg->var->arg); + darg->var->arg = darg; + + if (!darg->layout) { + token_t t; + + if (darg->var->pointer_level && (!darg->var->array_size || darg->var->pointer_level == 1)) { + t = PSI_T_POINTER; + } else { + t = real_decl_type(darg->type)->type; + } + + if (i) { + decl_arg *last = s->args->args[i-1]; + darg->layout = init_decl_struct_layout( + psi_t_align(t, last->layout->pos + last->layout->len), + psi_t_size(t) * darg->var->array_size); + } else { + darg->layout = init_decl_struct_layout(0, psi_t_size(t)); + } + } + if (s->size < darg->layout->pos + darg->layout->len) { + s->size = darg->layout->pos + darg->layout->len; + } + } + return 1; +} + +static const char * const abi_ccs[] = { + "default", /* \ */ + "extern", /* > - all the same */ + "cdecl", /* / */ + "stdcall", + "fastcall", +}; +static inline int validate_decl_abi(PSI_Data *data, decl_abi *abi) { + size_t i; + + for (i = 0; i < sizeof(abi_ccs)/sizeof(char*); ++i) { + if (strcasecmp(abi->convention, abi_ccs[i])) { + return 1; + } + } + data->error(PSI_WARNING, "Invalid calling convention: '%s'", abi->convention); + return 0; +} +static inline int validate_decl_func(PSI_Data *data, void *dl, decl *decl, decl_arg *func) +{ + if (!strcmp(func->var->name, "dlsym")) { + data->error(PSI_WARNING, "Cannot dlsym dlsym (sic!)"); + return 0; + } + + if (!validate_decl_arg(data, func)) { + return 0; + } +#ifndef RTLD_NEXT +# define RTLD_NEXT ((void *) -1l) +#endif + decl->dlptr = dlsym(dl ?: RTLD_NEXT, func->var->name); + if (!decl->dlptr) { + data->error(PSI_WARNING, "Failed to located symbol '%s': %s", + func->var->name, dlerror()); + } + return 1; +} + +static inline int validate_decl(PSI_Data *data, void *dl, decl *decl) { + if (!validate_decl_abi(data, decl->abi)) { + return 0; + } + if (!validate_decl_func(data, dl, decl, decl->func)) { + return 0; + } + if (decl->args) { + size_t i; + + for (i = 0; i < decl->args->count; ++i) { + if (!validate_decl_arg(data, decl->args->args[i])) { + return 0; + } + } + } + return 1; +} + +static inline decl *locate_impl_decl(decls *decls, return_stmt *ret) { + size_t i; + + for (i = 0; i < decls->count; ++i) { + if (!strcmp(decls->list[i]->func->var->name, ret->decl->name)) { + ret->decl->arg = decls->list[i]->func; + return decls->list[i]; + } + } + return NULL; +} +static inline int validate_impl_ret_stmt(PSI_Data *data, impl *impl) { + /* we must have exactly one ret stmt delcaring the native func to call */ + /* and which type cast to apply */ + if (impl->stmts->ret.count != 1) { + if (impl->stmts->ret.count > 1) { + data->error(PSI_WARNING, "Too many `return` statements for implmentation %s;" + " found %zu, exactly one is needed", + impl->func->name, impl->stmts->ret.count); + } else { + data->error(PSI_WARNING, "Missing `return` statement for implementation %s", + impl->func->name); + } + return 0; + } + if (!(impl->decl = locate_impl_decl(data->decls, impl->stmts->ret.list[0]))) { + data->error(PSI_WARNING, "Missing declaration for implementation %s", + impl->func->name); + return 0; + } + + return 1; +} +static inline int validate_impl_let_stmts(PSI_Data *data, impl *impl) { + size_t i, j; + /* we can have multiple let stmts */ + /* check that we have a let stmt for every decl arg */ + if (impl->decl->args) for (i = 0; i < impl->decl->args->count; ++i) { + decl_arg *darg = impl->decl->args->args[i]; + int check = 0; + + for (j = 0; j < impl->stmts->let.count; ++j) { + let_stmt *let = impl->stmts->let.list[j]; + + if (!strcmp(let->var->name, darg->var->name)) { + darg->let = let; + check = 1; + break; + } + } + if (!check) { + data->error(PSI_WARNING, "Missing `let` statement for arg '%s %.*s%s'" + " of declaration '%s' for implementation '%s'", + darg->type->name, (int) darg->var->pointer_level, "*****", + darg->var->name, impl->decl->func->var->name, impl->func->name); + return 0; + } + } + /* check that the let_value references a known variable or NULL */ + for (i = 0; i < impl->stmts->let.count; ++i) { + let_stmt *let = impl->stmts->let.list[i]; + int check = 0; + + if (let->val && let->val->func && let->val->func->alloc) { + if (!validate_decl_type(data, let->val->func->alloc->type)) { + data->error(PSI_WARNING, "Cannot use '%s' as type for calloc in `let` statement", + let->val->func->alloc->type->name); + return 0; + } + } + if (let->val && let->val->var) { + if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) { + impl_arg *iarg = impl->func->args->args[j]; + + if (!strcmp(let->val->var->name, iarg->var->name)) { + let->arg = iarg; + check = 1; + break; + } + } + if (!check) { + data->error(PSI_WARNING, "Unknown value '$%s' of `let` statement" + " for variable '%s' of implementation '%s'", + let->val->var->name, let->var->name, impl->func->name); + return 0; + } + } + } + return 1; +} +static inline int validate_impl_set_stmts(PSI_Data *data, impl *impl) { + size_t i, j, k; + /* we can have any count of set stmts; processing out vars */ + /* check that set stmts reference known variables */ + for (i = 0; i < impl->stmts->set.count; ++i) { + set_stmt *set = impl->stmts->set.list[i]; + int check = 0; + + if (impl->func->args) for (j = 0; j < impl->func->args->count; ++j) { + impl_arg *iarg = impl->func->args->args[j]; + + if (!strcmp(set->var->name, iarg->var->name)) { + set->arg = iarg; + check = 1; + break; + } + } + if (!check) { + data->error(PSI_WARNING, "Unknown variable '$%s' of `set` statement" + " of implementation '%s'", + set->var->name, impl->func->name); + return 0; + } + + for (j = 0; j < set->val->vars->count; ++j) { + decl_var *set_var = set->val->vars->vars[j]; + + check = 0; + if (impl->decl->args) for (k = 0; k < impl->decl->args->count; ++k) { + decl_arg *set_arg = impl->decl->args->args[k]; + + if (!strcmp(set_var->name, set_arg->var->name)) { + check = 1; + set_var->arg = set_arg; + break; + } + } + + if (!check) { + data->error(PSI_WARNING, "Unknown value '%s' of `set` statement" + " for variable '$%s' of implementation '%s'", + set_var->name, set->arg->var->name, impl->func->name); + return 0; + } + } + } + return 1; +} +static inline int validate_impl_free_stmts(PSI_Data *data, impl *impl) { + size_t i, j, k; + /* we can have any count of free stmts; freeing any out vars */ + for (i = 0; i < impl->stmts->fre.count; ++i) { + free_stmt *fre = impl->stmts->fre.list[i]; + + for (j = 0; j < fre->vars->count; ++j) { + decl_var *free_var = fre->vars->vars[j]; + int check = 0; + + if (!strcmp(free_var->name, impl->decl->func->var->name)) { + continue; + } + if (impl->decl->args) for (k = 0; k < impl->decl->args->count; ++k) { + decl_arg *free_arg = impl->decl->args->args[k]; + + if (!strcmp(free_var->name, free_arg->var->name)) { + check = 1; + free_var->arg = free_arg; + break; + } + } + + if (!check) { + data->error(PSI_WARNING, "Unknown variable '%s' of `free` statement" + " of implementation '%s'", + free_var->name, impl->func->name); + return 0; + } + } + } + return 1; +} +static inline int validate_impl_stmts(PSI_Data *data, impl *impl) { + if (!impl->stmts) { + data->error(PSI_WARNING, "Missing body for implementation %s!", + impl->func->name); + return 0; + } + + if (!validate_impl_ret_stmt(data, impl)) { + return 0; + } + + if (!validate_impl_let_stmts(data, impl)) { + return 0; + } + if (!validate_impl_set_stmts(data, impl)) { + return 0; + } + if (!validate_impl_free_stmts(data, impl)) { + return 0; + } + + return 1; +} + PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error) { size_t i, j; - PSI_Data data; + PSI_Data T; if (!C) { C = malloc(sizeof(*C)); @@ -69,13 +463,16 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr C->ops = ops; ops->init(C); - memset(&data, 0, sizeof(data)); + /* build up predefs in a temporary PSI_Data for validation */ + memset(&T, 0, sizeof(T)); + T.error = error; + for (i = 0; i < psi_predef_type_count(); ++i) { const psi_predef_type *pre = &psi_predef_types[i]; decl_type *type = init_decl_type(pre->type_tag, pre->type_name); decl_typedef *def = init_decl_typedef(pre->alias, type); - data.defs = add_decl_typedef(data.defs, def); + T.defs = add_decl_typedef(T.defs, def); } for (i = 0; i < psi_predef_const_count(); ++i) { const psi_predef_const *pre = &psi_predef_consts[i]; @@ -83,16 +480,18 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr const_type *type = init_const_type(pre->type_tag, pre->type_name); constant *constant = init_constant(type, pre->name, val); - data.consts = add_constant(data.consts, constant); + T.consts = add_constant(T.consts, constant); } for (i = 0; i < psi_predef_struct_count(); ++i) { const psi_predef_struct *pre = &psi_predef_structs[i]; decl_args *dargs = init_decl_args(NULL); + decl_struct *dstruct; for (j = 0; j < PSI_PREDEF_STRUCT_MEMBERS; ++j) { const psi_predef_struct_member *member = &pre->members[j]; decl_type *type; decl_var *dvar; + decl_arg *darg; if (!member->name) { break; @@ -100,15 +499,111 @@ PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErr type = init_decl_type(member->type_tag, member->type_name); dvar = init_decl_var(member->name, member->pointer_level, member->array_size); - dargs = add_decl_arg(dargs, init_decl_arg(type, dvar)); + darg = init_decl_arg(type, dvar); + darg->layout = init_decl_struct_layout(member->off, member->len); + dargs = add_decl_arg(dargs, darg); } - data.structs = add_decl_struct(data.structs, - init_decl_struct(pre->name, dargs)); + dstruct = init_decl_struct(pre->name, dargs); + T.structs = add_decl_struct(T.structs, dstruct); } + + for (i = 0; i < psi_predef_type_count(); ++i) { + decl_typedef *def = T.defs->list[i]; + + if (validate_decl_typedef(&T, def)) { + C->defs = add_decl_typedef(C->defs, def); + } + } + + for (i = 0; i < psi_predef_const_count(); ++i) { + constant *constant = T.consts->list[i]; + + if (validate_constant(&T, constant)) { + C->consts = add_constant(C->consts, constant); + } + } + + for (i = 0; i < psi_predef_struct_count(); ++i) { + decl_struct *dstruct = T.structs->list[i]; + + if (validate_decl_struct(&T, dstruct)) { + C->structs = add_decl_struct(C->structs, dstruct); + } + } + + C->count = 1; + C->data = malloc(sizeof(*C->data)); + PSI_DataExchange(C->data, &T); + return C; } +int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P) +{ + PSI_Data *D; + void *dlopened = NULL; + size_t count = C->count++; + + C->data = realloc(C->data, C->count * sizeof(*C->data)); + D = PSI_DataExchange(&C->data[count], PSI_DATA(P)); + + if (D->defs) { + size_t i; + + for (i = 0; i < D->defs->count; ++i) { + if (validate_decl_typedef(PSI_DATA(C), D->defs->list[i])) { + C->defs = add_decl_typedef(C->defs, D->defs->list[i]); + } + } + } + if (D->structs) { + size_t i; + + for (i = 0; i < D->structs->count; ++i) { + if (validate_decl_struct(PSI_DATA(C), D->structs->list[i])) { + C->structs = add_decl_struct(C->structs, D->structs->list[i]); + } + } + } + if (D->consts) { + size_t i; + + for (i = 0; i < D->consts->count; ++i) { + if (validate_constant(PSI_DATA(C), D->consts->list[i])) { + C->consts = add_constant(C->consts, D->consts->list[i]); + } + } + } + + if (!validate_lib(D, &dlopened)) { + return 0; + } + + add_decl_lib(&C->psi.libs, dlopened); + + if (D->decls) { + size_t i; + + for (i = 0; i < D->decls->count; ++i) { + if (validate_decl(PSI_DATA(C), dlopened, D->decls->list[i])) { + C->decls = add_decl(C->decls, D->decls->list[i]); + } + } + } + if (D->impls) { + size_t i; + + for (i = 0; i < D->impls->count; ++i) { + if (validate_impl_stmts(PSI_DATA(C), D->impls->list[i])) { + C->impls = add_impl(C->impls, D->impls->list[i]); + } + } + } + + return 1; +} + static int psi_select_dirent(const struct dirent *entry) { #ifndef FNM_CASEFOLD @@ -117,7 +612,6 @@ static int psi_select_dirent(const struct dirent *entry) return 0 == fnmatch("*.psi", entry->d_name, FNM_CASEFOLD); } - void PSI_ContextBuild(PSI_Context *C, const char *path) { int i, n; @@ -130,7 +624,6 @@ void PSI_ContextBuild(PSI_Context *C, const char *path) } else for (i = 0; i < n; ++i) { char psi[MAXPATHLEN]; PSI_Parser P; - PSI_Validator V; if (MAXPATHLEN <= slprintf(psi, MAXPATHLEN, "%s/%s", path, entries[i]->d_name)) { C->error(PSI_WARNING, "Path to PSI file too long: %s/%s", @@ -146,23 +639,14 @@ void PSI_ContextBuild(PSI_Context *C, const char *path) PSI_ParserParse(&P, PSI_TokenAlloc(&P)); }; PSI_ParserParse(&P, NULL); - - if (!PSI_ValidatorInit(&V, &P)) { - C->error(PSI_WARNING, "Failed to init PSI validator"); - break; - } + PSI_ContextValidate(C, &P); PSI_ParserDtor(&P); + } - if (PSI_ValidatorValidate(&V)) { - zend_function_entry *closures; - - closures = PSI_ContextCompile(C, (PSI_Data *) &V); - if (closures && SUCCESS != zend_register_functions(NULL, closures, NULL, MODULE_PERSISTENT)) { - C->error(PSI_WARNING, "Failed to register functions!"); - } - } - PSI_ValidatorDtor(&V); + if (PSI_ContextCompile(C) && SUCCESS != zend_register_functions(NULL, C->closures, NULL, MODULE_PERSISTENT)) { + C->error(PSI_WARNING, "Failed to register functions!"); } + if (entries) { for (i = 0; i < n; ++i) { free(entries[i]); @@ -172,19 +656,18 @@ void PSI_ContextBuild(PSI_Context *C, const char *path) } -zend_function_entry *PSI_ContextCompile(PSI_Context *C, PSI_Data *D) +zend_function_entry *PSI_ContextCompile(PSI_Context *C) { - size_t i, count = C->count++; - zend_function_entry *zfe; + size_t i; - if (D->consts) { + if (C->consts) { zend_constant zc; zc.flags = CONST_PERSISTENT|CONST_CS; zc.module_number = EG(current_module)->module_number; - for (i = 0; i < D->consts->count; ++i) { - constant *c = D->consts->list[i]; + for (i = 0; i < C->consts->count; ++i) { + constant *c = C->consts->list[i]; zc.name = zend_string_init(c->name + (c->name[0] == '\\'), strlen(c->name) - (c->name[0] == '\\'), 1); ZVAL_NEW_STR(&zc.value, zend_string_init(c->val->text, strlen(c->val->text), 1)); @@ -204,15 +687,8 @@ zend_function_entry *PSI_ContextCompile(PSI_Context *C, PSI_Data *D) } } - C->data = realloc(C->data, C->count * sizeof(*C->data)); - PSI_DataExchange(&C->data[count], D); - - zfe = C->ops->compile(C, &C->data[count]); - C->closures = realloc(C->closures, C->count * sizeof(*C->closures)); - C->closures[count] = zfe; - - return zfe; + return C->closures = C->ops->compile(C); } void PSI_ContextDtor(PSI_Context *C) @@ -221,15 +697,46 @@ void PSI_ContextDtor(PSI_Context *C) C->ops->dtor(C); + free_decl_libs(&C->psi.libs); + for (i = 0; i < C->count; ++i) { PSI_DataDtor(&C->data[i]); - if (C->closures[i]){ - free(C->closures[i]); - } } + free(C->data); free(C->closures); + if (C->consts) { + if (C->consts->list) { + free(C->consts->list); + } + free(C->consts); + } + if (C->defs) { + if (C->defs->list) { + free(C->defs->list); + } + free(C->defs); + } + if (C->structs) { + if (C->structs->list) { + free(C->structs->list); + } + free(C->structs); + } + if (C->decls) { + if (C->decls->list) { + free(C->decls->list); + } + free(C->decls); + } + if (C->impls) { + if (C->impls->list) { + free(C->impls->list); + } + free(C->impls); + } + memset(C, 0, sizeof(*C)); } diff --git a/src/context.h b/src/context.h index 24bdb9c..351799b 100644 --- a/src/context.h +++ b/src/context.h @@ -13,21 +13,22 @@ typedef struct PSI_ContextOps PSI_ContextOps; struct PSI_ContextOps { void (*init)(PSI_Context *C); void (*dtor)(PSI_Context *C); - zend_function_entry *(*compile)(PSI_Context *C, PSI_Data *D); + zend_function_entry *(*compile)(PSI_Context *C); }; struct PSI_Context { + PSI_DATA_MEMBERS; void *context; - PSI_ContextErrorFunc error; struct PSI_ContextOps *ops; - struct PSI_Data *data; - zend_function_entry **closures; + zend_function_entry *closures; + PSI_Data *data; size_t count; }; PSI_Context *PSI_ContextInit(PSI_Context *C, PSI_ContextOps *ops, PSI_ContextErrorFunc error); void PSI_ContextBuild(PSI_Context *C, const char *path); -zend_function_entry *PSI_ContextCompile(PSI_Context *C, PSI_Data *D); +int PSI_ContextValidate(PSI_Context *C, PSI_Parser *P); +zend_function_entry *PSI_ContextCompile(PSI_Context *C); void PSI_ContextDtor(PSI_Context *C); void PSI_ContextFree(PSI_Context **C); diff --git a/src/libffi.c b/src/libffi.c index 25456d2..38fa096 100644 --- a/src/libffi.c +++ b/src/libffi.c @@ -257,23 +257,28 @@ static void psi_ffi_dtor(PSI_Context *C) PSI_LibffiContextFree((void *) &C->context); } -static zend_function_entry *psi_ffi_compile(PSI_Context *C, PSI_Data *D) +static zend_function_entry *psi_ffi_compile(PSI_Context *C) { size_t i, j = 0; - zend_function_entry *zfe = calloc(D->impls->count + 1, sizeof(*zfe)); + zend_function_entry *zfe; PSI_LibffiContext *ctx = C->context; - for (i = 0; i < D->impls->count; ++i) { + if (!C->impls) { + return NULL; + } + + zfe = calloc(C->impls->count + 1, sizeof(*zfe)); + for (i = 0; i < C->impls->count; ++i) { zend_function_entry *zf = &zfe[j]; PSI_LibffiData *data; - if (!D->impls->list[i]->decl) { + if (!C->impls->list[i]->decl) { continue; } - data = PSI_LibffiDataAlloc(ctx, D->impls->list[i]); - zf->fname = D->impls->list[i]->func->name + (D->impls->list[i]->func->name[0] == '\\'); - zf->num_args = D->impls->list[i]->func->args->count; + data = PSI_LibffiDataAlloc(ctx, C->impls->list[i]); + zf->fname = C->impls->list[i]->func->name + (C->impls->list[i]->func->name[0] == '\\'); + zf->num_args = C->impls->list[i]->func->args->count; zf->handler = data->code; zf->arg_info = data->arginfo; ++j; diff --git a/src/libjit.c b/src/libjit.c index 055ba1b..773f0e0 100644 --- a/src/libjit.c +++ b/src/libjit.c @@ -196,25 +196,30 @@ static void psi_jit_dtor(PSI_Context *C) PSI_LibjitContextFree((void *) &C->context); } -static zend_function_entry *psi_jit_compile(PSI_Context *C, PSI_Data *D) +static zend_function_entry *psi_jit_compile(PSI_Context *C) { size_t i, j = 0; - zend_function_entry *zfe = calloc(D->impls->count + 1, sizeof(*zfe)); + zend_function_entry *zfe; PSI_LibjitContext *ctx = C->context; + if (!C->impls) { + return NULL; + } + + zfe = calloc(C->impls->count + 1, sizeof(*zfe)); jit_context_build_start(ctx->jit); - for (i = 0; i < D->impls->count; ++i) { + for (i = 0; i < C->impls->count; ++i) { zend_function_entry *zf = &zfe[j]; PSI_LibjitData *data; - if (!D->impls->list[i]->decl) { + if (!C->impls->list[i]->decl) { continue; } - data = PSI_LibjitDataAlloc(ctx, D->impls->list[i]); - zf->fname = D->impls->list[i]->func->name + (D->impls->list[i]->func->name[0] == '\\'); - zf->num_args = D->impls->list[i]->func->args->count; + data = PSI_LibjitDataAlloc(ctx, C->impls->list[i]); + zf->fname = C->impls->list[i]->func->name + (C->impls->list[i]->func->name[0] == '\\'); + zf->num_args = C->impls->list[i]->func->args->count; zf->handler = data->closure; zf->arg_info = data->arginfo; ++j; diff --git a/src/module.c b/src/module.c index 628694b..3b4a643 100644 --- a/src/module.c +++ b/src/module.c @@ -295,11 +295,10 @@ void psi_from_zval(impl_val *mem, decl_arg *spec, zval *zv, void **tmp) void *psi_array_to_struct(decl_struct *s, HashTable *arr) { - size_t i, j = 0, size = decl_struct_size(s); - char *mem = ecalloc(1, size + s->args->count * sizeof(void *)); + size_t i, j = 0; + char *mem = ecalloc(1, s->size + s->args->count * sizeof(void *)); if (arr) for (i = 0; i < s->args->count; ++i) { - decl_struct_layout *layout = &s->layout[i]; decl_arg *darg = s->args->args[i]; zval *entry = zend_hash_str_find_ind(arr, darg->var->name, strlen(darg->var->name)); @@ -309,9 +308,9 @@ void *psi_array_to_struct(decl_struct *s, HashTable *arr) memset(&tmp, 0, sizeof(tmp)); psi_from_zval(&val, darg, entry, &tmp); - memcpy(mem + layout->pos, &val, layout->len); + memcpy(mem + darg->layout->pos, &val, darg->layout->len); if (tmp) { - ((void **)(mem + size))[j++] = tmp; + ((void **)(mem + s->size))[j++] = tmp; } } } @@ -333,13 +332,12 @@ void psi_to_array(zval *return_value, token_t t, impl_val *ret_val, decl_var *va ZEND_ASSERT(s); for (i = 0; i < s->args->count; ++i) { decl_arg *darg = s->args->args[i]; - decl_struct_layout layout = s->layout[i]; impl_val tmp; zval ztmp; - char *ptr = (char *) ret_val->ptr + layout.pos; + char *ptr = (char *) ret_val->ptr + darg->layout->pos; memset(&tmp, 0, sizeof(tmp)); - memcpy(&tmp, ptr, layout.len); + memcpy(&tmp, ptr, darg->layout->len); switch (real_decl_type(darg->type)->type) { case PSI_T_FLOAT: case PSI_T_DOUBLE: @@ -452,8 +450,8 @@ void *psi_do_calloc(let_calloc *alloc) size_t size; if (type->type == PSI_T_STRUCT) { - /* psi_do_clean expects a NULL pointer after the struct */ - size = decl_struct_size(type->strct) + sizeof(void *); + /* psi_do_clean expects at least one NULL pointer after the struct */ + size = type->strct->size + sizeof(void *); } else { size = psi_t_size(type->type); } @@ -618,8 +616,7 @@ void psi_do_clean(impl *impl) decl_type *type = real_decl_type(darg->type); if (type->type == PSI_T_STRUCT) { - size_t eos = decl_struct_size(type->strct); - void **ptr = (void **) ((char *) darg->let->mem + eos); + void **ptr = (void **) ((char *) darg->let->mem + type->strct->size); while (*ptr) { efree(*ptr++); diff --git a/src/parser.h b/src/parser.h index cb069c9..3d2dd6f 100644 --- a/src/parser.h +++ b/src/parser.h @@ -113,9 +113,27 @@ static inline void free_decl_var(decl_var *var) { free(var); } +typedef struct decl_struct_layout { + size_t pos; + size_t len; +} decl_struct_layout; + +static inline decl_struct_layout *init_decl_struct_layout(size_t pos, size_t len) { + decl_struct_layout *l = calloc(1, sizeof(*l)); + + l->pos = pos; + l->len = len; + return l; +} + +static inline void free_decl_struct_layout(decl_struct_layout *l) { + free(l); +} + typedef struct decl_arg { decl_type *type; decl_var *var; + decl_struct_layout *layout; struct let_stmt *let; } decl_arg; @@ -123,13 +141,15 @@ static inline decl_arg *init_decl_arg(decl_type *type, decl_var *var) { decl_arg *arg = calloc(1, sizeof(*arg)); arg->type = type; arg->var = var; - arg->let = NULL; return arg; } static inline void free_decl_arg(decl_arg *arg) { free_decl_type(arg->type); free_decl_var(arg->var); + if (arg->layout) { + free_decl_struct_layout(arg->layout); + } free(arg); } @@ -140,9 +160,11 @@ typedef struct decl_vars { static inline decl_vars *init_decl_vars(decl_var *var) { decl_vars *vars = calloc(1, sizeof(*vars)); - vars->count = 1; - vars->vars = calloc(1, sizeof(*vars->vars)); - vars->vars[0] = var; + if (var) { + vars->count = 1; + vars->vars = calloc(1, sizeof(*vars->vars)); + vars->vars[0] = var; + } return vars; } @@ -169,9 +191,11 @@ typedef struct decl_args { static inline decl_args *init_decl_args(decl_arg *arg) { decl_args *args = calloc(1, sizeof(*args)); - args->count = 1; - args->args = calloc(1, sizeof(*args->args)); - args->args[0] = arg; + if (arg) { + args->count = 1; + args->args = calloc(1, sizeof(*args->args)); + args->args[0] = arg; + } return args; } @@ -254,15 +278,10 @@ static inline void free_decls(decls *decls) { free(decls); } -typedef struct decl_struct_layout { - size_t pos; - size_t len; -} decl_struct_layout; - typedef struct decl_struct { char *name; decl_args *args; - decl_struct_layout *layout; + size_t size; } decl_struct; static inline decl_struct *init_decl_struct(const char *name, decl_args *args) { @@ -276,19 +295,10 @@ static inline void free_decl_struct(decl_struct *s) { if (s->args) { free_decl_args(s->args); } - if (s->layout) { - free(s->layout); - } free(s->name); free(s); } -static inline size_t decl_struct_size(decl_struct *s) { - size_t c = s->args->count - 1; - decl_type *type = real_decl_type(s->args->args[c]->type); - return s->layout[c].pos + psi_t_alignment(type->type); -} - typedef struct decl_structs { size_t count; decl_struct **list; @@ -426,13 +436,10 @@ typedef struct impl_args { static inline impl_args *init_impl_args(impl_arg *arg) { impl_args *args = calloc(1, sizeof(*args)); - args->args = calloc(1, sizeof(*args->args)); if (arg) { args->count = 1; + args->args = calloc(1, sizeof(*args->args)); args->args[0] = arg; - } else { - args->count = 0; - args->args = NULL; } return args; } @@ -866,22 +873,67 @@ static inline void free_constants(constants *c) { #define PSI_WARNING 32 typedef void (*psi_error_cb)(int type, const char *msg, ...); +typedef struct decl_file { + char *ln; + char *fn; +} decl_file; + +static inline void free_decl_file(decl_file *file) { + if (file->ln) { + free(file->ln); + } + if (file->fn) { + free(file->fn); + } + memset(file, 0, sizeof(*file)); +} + +typedef struct decl_libs { + void **dl; + size_t count; +} decl_libs; + +static inline void free_decl_libs(decl_libs *libs) { + if (libs->dl) { + size_t i; + for (i = 0; i < libs->count; ++i) { + if (libs->dl[i]) { + dlclose(libs->dl[i]); + } + } + free(libs->dl); + } + memset(libs, 0, sizeof(*libs)); +} + +static inline void add_decl_lib(decl_libs *libs, void *dlopened) { + libs->dl = realloc(libs->dl, ++libs->count * sizeof(*libs->dl)); + libs->dl[libs->count-1] = dlopened; +} + +#define PSI_DATA(D) ((PSI_Data *) (D)) #define PSI_DATA_MEMBERS \ constants *consts; \ decl_typedefs *defs; \ decl_structs *structs; \ decls *decls; \ impls *impls; \ - char *lib; \ - char *fn; \ + union { \ + decl_file file; \ + decl_libs libs; \ + } psi; \ psi_error_cb error typedef struct PSI_Data { PSI_DATA_MEMBERS; } PSI_Data; -static inline void PSI_DataExchange(PSI_Data *dest, PSI_Data *src) { +static inline PSI_Data *PSI_DataExchange(PSI_Data *dest, PSI_Data *src) { + if (!dest) { + dest = malloc(sizeof(*dest)); + } memcpy(dest, src, sizeof(*dest)); memset(src, 0, sizeof(*src)); + return dest; } static inline void PSI_DataDtor(PSI_Data *data) { @@ -900,12 +952,7 @@ static inline void PSI_DataDtor(PSI_Data *data) { if (data->impls) { free_impls(data->impls); } - if (data->lib) { - free(data->lib); - } - if (data->fn) { - free(data->fn); - } + free_decl_file(&data->psi.file); } typedef struct PSI_Parser { diff --git a/src/parser.re b/src/parser.re index 831b218..0eae943 100644 --- a/src/parser.re +++ b/src/parser.re @@ -30,8 +30,8 @@ PSI_Parser *PSI_ParserInit(PSI_Parser *P, const char *filename, psi_error_cb err } memset(P, 0, sizeof(*P)); + P->psi.file.fn = strdup(filename); P->fp = fp; - P->fn = strdup(filename); P->line = 1; P->error = error; P->flags = flags; diff --git a/src/parser_proc.y b/src/parser_proc.y index 2fb309e..81a013c 100644 --- a/src/parser_proc.y +++ b/src/parser_proc.y @@ -15,7 +15,7 @@ %extra_argument {PSI_Parser *P} /* TOKEN is defined inside syntax_error */ %syntax_error { - PSI_ParserSyntaxError(P, P->fn, P->line, "Unexpected token '%s'", TOKEN->text); + PSI_ParserSyntaxError(P, P->psi.file.fn, P->line, "Unexpected token '%s'", TOKEN->text); } %nonassoc NAME. @@ -28,10 +28,10 @@ blocks ::= blocks block. block ::= COMMENT. block ::= LIB(T) QUOTED_STRING(libname) EOS. { - if (P->lib) { - PSI_ParserSyntaxError(P, P->fn, T->line, "Extra 'lib %s' statement has no effect", libname->text); + if (P->psi.file.ln) { + PSI_ParserSyntaxError(P, P->psi.file.ln, T->line, "Extra 'lib %s' statement has no effect", libname->text); } else { - P->lib = strndup(libname->text + 1, libname->size - 2); + P->psi.file.ln = strndup(libname->text + 1, libname->size - 2); } free(libname); free(T); diff --git a/tests/idn/idn.psi b/tests/idn/idn.psi index 1583680..845335b 100644 --- a/tests/idn/idn.psi +++ b/tests/idn/idn.psi @@ -20,7 +20,7 @@ const int \IDNA_ALLOW_UNASSIGNED = 1; const int \IDNA_USE_STD3_ASCII_RULES = 2; -default int idna_to_ascii_8z(sint8 *host, sint8 **buffer, int flags); +default int idna_to_ascii_8z(char *host, char **buffer, int flags); function idn\utf8_to_ascii(string $host, string &$result, int $flags = 0) : int { let buffer = &NULL; let host = strval($host); @@ -29,7 +29,7 @@ function idn\utf8_to_ascii(string $host, string &$result, int $flags = 0) : int return to_int(idna_to_ascii_8z); free *buffer; } -default sint8 *idna_strerror(int rc); +default char *idna_strerror(int rc); function idn\strerror(int $rc) : string { return to_string(idna_strerror); let rc = intval($rc); diff --git a/tests/time/time.psi b/tests/time/time.psi index 5a9b2b0..5b02dc4 100644 --- a/tests/time/time.psi +++ b/tests/time/time.psi @@ -1,35 +1,3 @@ -typedef long time_t; -typedef int suseconds_t; - -struct timespec { - time_t tv_sec; - long tv_nsec; -} - -struct timeval { - time_t tv_sec; - suseconds_t tv_usec; -} - -struct timezone { - int tz_minuteswest; - int tz_dsttime; -} - -struct tm { - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; - long tm_gmtoff; - char *tm_zone; -} - extern int gettimeofday(struct timeval *tv, struct timezone *tz); function psi\gettimeofday(array &$tv = NULL, array &$tz = NULL) : int { let tv = calloc(1, struct timeval); -- 2.30.2