X-Git-Url: https://git.m6w6.name/?p=m6w6%2Fext-psi;a=blobdiff_plain;f=src%2Flibffi.c;h=301995e5903d9bc377c3d2630f1be48fed9e0513;hp=d5158271b65879a31afccd66dbbbef6f922f5730;hb=d3171526ab7658114cac4ebe1098af4b038e576e;hpb=61918592ab618c073b9846783ce79fed9f26c5f7 diff --git a/src/libffi.c b/src/libffi.c index d515827..301995e 100644 --- a/src/libffi.c +++ b/src/libffi.c @@ -8,6 +8,7 @@ #include "php_psi.h" #include "libffi.h" +#include "engine.h" #undef PACKAGE #undef PACKAGE_BUGREPORT @@ -56,6 +57,7 @@ static void psi_ffi_closure_free(void *c) } static void psi_ffi_handler(ffi_cif *signature, void *_result, void **_args, void *_data); +static inline ffi_type *psi_ffi_decl_arg_type(decl_arg *darg); static inline ffi_abi psi_ffi_abi(const char *convention) { return FFI_DEFAULT_ABI; @@ -86,15 +88,131 @@ static inline ffi_type *psi_ffi_token_type(token_t t) { case PSI_T_BOOL: return &ffi_type_uchar; case PSI_T_INT: + case PSI_T_ENUM: return &ffi_type_sint; + case PSI_T_LONG: + return &ffi_type_slong; case PSI_T_FLOAT: return &ffi_type_float; case PSI_T_DOUBLE: return &ffi_type_double; +#ifdef HAVE_LONG_DOUBLE + case PSI_T_LONG_DOUBLE: + return &ffi_type_longdouble; +#endif + case PSI_T_POINTER: + return &ffi_type_pointer; + } +} +static inline ffi_type *psi_ffi_impl_type(token_t impl_type) { + switch (impl_type) { + case PSI_T_BOOL: + return &ffi_type_sint8; + case PSI_T_INT: + return &ffi_type_sint64; + case PSI_T_STRING: + return &ffi_type_pointer; + case PSI_T_FLOAT: + case PSI_T_DOUBLE: + return &ffi_type_double; + EMPTY_SWITCH_DEFAULT_CASE(); + } + return NULL; +} +static void psi_ffi_struct_type_dtor(void *type) { + ffi_type *strct = type; + + if (strct->elements) { + ffi_type **ptr; + + for (ptr = strct->elements; *ptr; ++ptr) { + free(*ptr); + } + free(strct->elements); + } + free(strct); +} + +static size_t psi_ffi_struct_type_pad(ffi_type **els, size_t padding) { + size_t i; + + for (i = 0; i < padding; ++i) { + ffi_type *pad = malloc(sizeof(*pad)); + + memcpy(pad, &ffi_type_schar, sizeof(*pad)); + *els++ = pad; + } + + return padding; +} + +static ffi_type **psi_ffi_struct_type_elements(decl_struct *strct) { + size_t i, argc = strct->args->count, nels = 0, offset = 0, maxalign = 0; + ffi_type **els = calloc(argc + 1, sizeof(*els)); + + for (i = 0; i < strct->args->count; ++i) { + decl_arg *darg = strct->args->args[i]; + ffi_type *type = malloc(sizeof(*type)); + size_t padding; + + memcpy(type, psi_ffi_decl_arg_type(darg), sizeof(*type)); + + ZEND_ASSERT(type->size == darg->layout->len); + + if (type->alignment > maxalign) { + maxalign = type->alignment; + } + + if ((padding = psi_offset_padding(darg->layout->pos - offset, type->alignment))) { + if (nels + padding + 1 > argc) { + argc += padding; + els = realloc(els, (argc + 1) * sizeof(*els)); + els[argc] = NULL; + } + psi_ffi_struct_type_pad(&els[nels], padding); + nels += padding; + offset += padding; + } + ZEND_ASSERT(offset == darg->layout->pos); + + offset = (offset + darg->layout->len + type->alignment - 1) & ~(type->alignment - 1); + els[nels++] = type; + } + + /* apply struct alignment padding */ + offset = (offset + maxalign - 1) & ~(maxalign - 1); + + ZEND_ASSERT(offset <= strct->size); + if (offset < strct->size) { + psi_ffi_struct_type_pad(&els[nels], strct->size - offset); } + + return els; } static inline ffi_type *psi_ffi_decl_type(decl_type *type) { - return psi_ffi_token_type(real_decl_type(type)->type); + decl_type *real = real_decl_type(type); + + switch (real->type) { + case PSI_T_STRUCT: + if (!real->strct->engine.type) { + ffi_type *strct = calloc(1, sizeof(ffi_type)); + + strct->type = FFI_TYPE_STRUCT; + strct->size = 0; + strct->elements = psi_ffi_struct_type_elements(real->strct); + + real->strct->engine.type = strct; + real->strct->engine.dtor = psi_ffi_struct_type_dtor; + } + + return real->strct->engine.type; + + case PSI_T_UNION: + return psi_ffi_decl_arg_type(real->unn->args->args[0]); + + default: + return psi_ffi_token_type(real->type); + } } static inline ffi_type *psi_ffi_decl_arg_type(decl_arg *darg) { if (darg->var->pointer_level) { @@ -127,6 +245,8 @@ static inline PSI_LibffiCall *PSI_LibffiCallAlloc(PSI_Context *C, decl *decl) { call->params[c] = NULL; decl->call.info = call; + decl->call.rval = &decl->func->ptr; + decl->call.argc = c; decl->call.args = (void **) &call->params[c+1]; rc = ffi_prep_cif(&call->signature, psi_ffi_abi(decl->abi->convention), @@ -152,7 +272,7 @@ static inline void PSI_LibffiCallInitClosure(PSI_Context *C, PSI_LibffiCall *cal call->code); #elif PSI_HAVE_FFI_PREP_CLOSURE - rc = ffi_prep_closure(data->code, &context->signature, psi_ffi_handler, data); + rc = ffi_prep_closure(call->code, &context->signature, psi_ffi_handler, impl); #else # error "Neither ffi_prep_closure() nor ffi_prep_closure_loc() available" #endif @@ -250,10 +370,38 @@ static zend_function_entry *psi_ffi_compile(PSI_Context *C) return zfe; } -static void psi_ffi_call(PSI_Context *C, impl_val *ret_val, decl *decl) { - PSI_LibffiCall *call = decl->call.info; +static void psi_ffi_call(PSI_Context *C, decl_callinfo *decl_call, impl_vararg *va) { + PSI_LibffiCall *call = decl_call->info; - ffi_call(&call->signature, FFI_FN(decl->call.sym), ret_val, decl->call.args); + if (va) { + ffi_status rc; + ffi_cif signature; + size_t i, nfixedargs = decl_call->argc, ntotalargs = nfixedargs + va->args->count; + void **params = calloc(2 * ntotalargs + 2, sizeof(void *)); + + for (i = 0; i < nfixedargs; ++i) { + params[i] = call->params[i]; + params[i + ntotalargs + 1] = call->params[i + nfixedargs + 1]; + } + for (i = 0; i < va->args->count; ++i) { + params[nfixedargs + i] = psi_ffi_impl_type(va->types[i]); + params[nfixedargs + i + ntotalargs + 1] = &va->values[i]; + } +#ifdef PSI_HAVE_FFI_PREP_CIF_VAR + rc = ffi_prep_cif_var(&signature, call->signature.abi, + nfixedargs, ntotalargs, + call->signature.rtype, (ffi_type **) params); +#else + /* FIXME: test in config.m4; assume we can just call anyway */ + rc = ffi_prep_cif(&signature, call->signature.abi, ntotalargs, + call->signature.rtype, (ffi_type **) params); +#endif + ZEND_ASSERT(FFI_OK == rc); + ffi_call(&signature, FFI_FN(decl_call->sym), *decl_call->rval, ¶ms[ntotalargs + 1]); + free(params); + } else { + ffi_call(&call->signature, FFI_FN(decl_call->sym), *decl_call->rval, decl_call->args); + } } static PSI_ContextOps ops = {