git.m6w6.name Git - m6w6/ext-psi/blob - src/libjit.c

   1 #ifdef HAVE_CONFIG_H
   2 # include "config.h"
   3 #endif
   4
   5 #include "php.h"
   6
   7 #ifdef HAVE_LIBJIT
   8
   9 #include "php_psi.h"
  10 #include "libjit.h"
  11
  12 #include <jit/jit.h>
  13
  14 static void psi_jit_handler(jit_type_t _sig, void *result, void **_args, void *_data);
  15
  16 static inline jit_abi_t psi_jit_abi(const char *convention) {
  17         return jit_abi_cdecl;
  18 }
  19 static inline jit_type_t psi_jit_token_type(token_t t) {
  20         switch (t) {
  21         case PSI_T_VOID:
  22                 return jit_type_void;
  23         case PSI_T_INT8:
  24                 return jit_type_sbyte;
  25         case PSI_T_UINT8:
  26                 return jit_type_ubyte;
  27         case PSI_T_INT16:
  28                 return jit_type_short;
  29         case PSI_T_UINT16:
  30                 return jit_type_ushort;
  31         case PSI_T_INT32:
  32                 return jit_type_int;
  33         case PSI_T_UINT32:
  34                 return jit_type_uint;
  35         case PSI_T_INT64:
  36                 return jit_type_long;
  37         case PSI_T_UINT64:
  38                 return jit_type_ulong;
  39         case PSI_T_BOOL:
  40                 return jit_type_sys_bool;
  41         case PSI_T_FLOAT:
  42                 return jit_type_sys_float;
  43         case PSI_T_DOUBLE:
  44                 return jit_type_sys_double;
  45         EMPTY_SWITCH_DEFAULT_CASE();
  46         }
  47 }
  48 static inline jit_type_t psi_jit_decl_type(decl_type *type) {
  49         return psi_jit_token_type(real_decl_type(type)->type);
  50 }
  51 static inline jit_type_t psi_jit_decl_arg_type(decl_arg *darg) {
  52         if (darg->var->pointer_level) {
  53                 return jit_type_void_ptr;
  54         } else {
  55                 return psi_jit_decl_type(darg->type);
  56         }
  57 }
  58
  59 typedef struct PSI_LibjitContext {
  60         jit_context_t jit;
  61         jit_type_t signature;
  62         struct {
  63                 struct PSI_LibjitData **list;
  64                 size_t count;
  65         } data;
  66 } PSI_LibjitContext;
  67
  68 typedef struct PSI_LibjitCall {
  69         void *closure;
  70         jit_type_t signature;
  71         jit_type_t params[1]; /* [type1, type2, NULL, arg1, arg2] ... */
  72 } PSI_LibjitCall;
  73
  74 typedef struct PSI_LibjitData {
  75         PSI_LibjitContext *context;
  76         impl *impl;
  77         zend_internal_arg_info *arginfo;
  78 } PSI_LibjitData;
  79
  80 static inline PSI_LibjitCall *PSI_LibjitCallAlloc(PSI_Context *C, decl *decl) {
  81         size_t i, c = decl->args ? decl->args->count : 0;
  82         PSI_LibjitCall *call = calloc(1, sizeof(*call) + 2 * c * sizeof(void *));
  83
  84         for (i = 0; i < c; ++i) {
  85                 call->params[i] = psi_jit_decl_arg_type(decl->args->args[i]);
  86         }
  87         call->params[c] = NULL;
  88
  89         decl->call.info = call;
  90         decl->call.rval = decl->func->ptr;
  91         decl->call.argc = c;
  92         decl->call.args = (void **) &call->params[c+1];
  93
  94         call->signature = jit_type_create_signature(
  95                         psi_jit_abi(decl->abi->convention),
  96                         psi_jit_decl_arg_type(decl->func),
  97                         call->params, c, 1);
  98         return call;
  99 }
 100
 101 static inline void PSI_LibjitCallInitClosure(PSI_Context *C, PSI_LibjitCall *call, impl *impl) {
 102         PSI_LibjitContext *context = C->context;
 103         call->closure = jit_closure_create(context->jit, context->signature,
 104                         &psi_jit_handler, impl);
 105 }
 106
 107 static inline void PSI_LibjitCallFree(PSI_LibjitCall *call) {
 108         jit_type_free(call->signature);
 109 }
 110
 111 static inline PSI_LibjitContext *PSI_LibjitContextInit(PSI_LibjitContext *L) {
 112         jit_type_t params[] = {
 113                 jit_type_void_ptr,
 114                 jit_type_void_ptr
 115         };
 116
 117         if (!L) {
 118                 L = malloc(sizeof(*L));
 119         }
 120         memset(L, 0, sizeof(*L));
 121
 122         L->jit = jit_context_create();
 123         L->signature = jit_type_create_signature(jit_abi_cdecl, jit_type_void,
 124                         params, 2, 1);
 125
 126         return L;
 127 }
 128
 129 static inline void PSI_LibjitContextDtor(PSI_LibjitContext *L) {
 130         jit_type_free(L->signature);
 131         jit_context_destroy(L->jit);
 132 }
 133
 134 static inline void PSI_LibjitContextFree(PSI_LibjitContext **L) {
 135         if (*L) {
 136                 PSI_LibjitContextDtor(*L);
 137                 free(*L);
 138                 *L = NULL;
 139         }
 140 }
 141
 142 static void psi_jit_handler(jit_type_t _sig, void *result, void **_args, void *_data)
 143 {
 144         psi_call(*(zend_execute_data **)_args[0], *(zval **)_args[1], _data);
 145 }
 146
 147 static void psi_jit_init(PSI_Context *C)
 148 {
 149         C->context = PSI_LibjitContextInit(NULL);
 150 }
 151
 152 static void psi_jit_dtor(PSI_Context *C)
 153 {
 154         if (C->decls) {
 155                 size_t i;
 156
 157                 for (i = 0; i < C->decls->count; ++i) {
 158                         decl *decl = C->decls->list[i];
 159
 160                         PSI_LibjitCallFree(decl->call.info);
 161                 }
 162         }
 163         PSI_LibjitContextFree((void *) &C->context);
 164 }
 165
 166 static zend_function_entry *psi_jit_compile(PSI_Context *C)
 167 {
 168         size_t i, j = 0;
 169         zend_function_entry *zfe;
 170         PSI_LibjitContext *ctx = C->context;
 171
 172         if (!C->impls) {
 173                 return NULL;
 174         }
 175
 176         zfe = calloc(C->impls->count + 1, sizeof(*zfe));
 177         jit_context_build_start(ctx->jit);
 178
 179         for (i = 0; i < C->impls->count; ++i) {
 180                 zend_function_entry *zf = &zfe[j];
 181                 PSI_LibjitCall *call;
 182                 impl *impl = C->impls->list[i];
 183
 184                 if (!impl->decl) {
 185                         continue;
 186                 }
 187
 188                 call = PSI_LibjitCallAlloc(C, impl->decl);
 189                 PSI_LibjitCallInitClosure(C, call, impl);
 190
 191                 zf->fname = impl->func->name + (impl->func->name[0] == '\\');
 192                 zf->num_args = impl->func->args->count;
 193                 zf->handler = call->closure;
 194                 zf->arg_info = psi_internal_arginfo(impl);
 195                 ++j;
 196         }
 197
 198         for (i = 0; i < C->decls->count; ++i) {
 199                 decl *decl = C->decls->list[i];
 200
 201                 if (decl->impl) {
 202                         continue;
 203                 }
 204
 205                 PSI_LibjitCallAlloc(C, decl);
 206         }
 207
 208         jit_context_build_end(ctx->jit);
 209
 210         return zfe;
 211 }
 212
 213 static void psi_jit_call(PSI_Context *C, decl_callinfo *decl_call) {
 214         PSI_LibjitCall *call = decl_call->info;
 215
 216         jit_apply(call->signature, decl_call->sym, decl_call->args,
 217                         decl_call->argc, decl_call->rval);
 218 }
 219
 220 static PSI_ContextOps ops = {
 221         psi_jit_init,
 222         psi_jit_dtor,
 223         psi_jit_compile,
 224         psi_jit_call,
 225 };
 226
 227 PSI_ContextOps *PSI_Libjit(void)
 228 {
 229         return &ops;
 230 }
 231
 232 #endif /* HAVE_LIBJIT */