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

   1 #include "php.h"
   2 #include "libjit.h"
   3 #include "parser_proc.h"
   4 #include "parser.h"
   5
   6 #include <jit/jit.h>
   7
   8 static void init(PSI_Context *C)
   9 {
  10         C->context = jit_context_create();
  11 }
  12
  13 static void dtor(PSI_Context *C)
  14 {
  15         jit_context_destroy(C->context);
  16         C->context = NULL;
  17 }
  18
  19 static inline size_t impl_num_min_args(impl *impl) {
  20         size_t i, n = impl->func->args->count;
  21
  22         for (i = 0; i < impl->func->args->count; ++i) {
  23                 if (impl->func->args->args[i]->def) {
  24                         --n;
  25                 }
  26         }
  27         return n;
  28 }
  29
  30 static inline jit_abi_t psi_jit_abi(const char *convention) {
  31         return jit_abi_cdecl;
  32 }
  33 static inline jit_type_t psi_jit_type(token_t t) {
  34         switch (t) {
  35         default:
  36                 ZEND_ASSERT(0);
  37                 /* no break */
  38         case PSI_T_VOID:
  39                 return jit_type_void;
  40         case PSI_T_SINT8:
  41                 return jit_type_sbyte;
  42         case PSI_T_UINT8:
  43                 return jit_type_ubyte;
  44         case PSI_T_SINT16:
  45                 return jit_type_short;
  46         case PSI_T_UINT16:
  47                 return jit_type_ushort;
  48         case PSI_T_SINT32:
  49                 return jit_type_int;
  50         case PSI_T_UINT32:
  51                 return jit_type_uint;
  52         case PSI_T_SINT64:
  53                 return jit_type_long;
  54         case PSI_T_UINT64:
  55                 return jit_type_ulong;
  56         case PSI_T_BOOL:
  57                 return jit_type_sys_bool;
  58         case PSI_T_CHAR:
  59                 return jit_type_sys_char;
  60         case PSI_T_SHORT:
  61                 return jit_type_sys_short;
  62         case PSI_T_INT:
  63                 return jit_type_sys_int;
  64         case PSI_T_LONG:
  65                 return jit_type_sys_long;
  66         case PSI_T_FLOAT:
  67                 return jit_type_sys_float;
  68         case PSI_T_DOUBLE:
  69                 return jit_type_sys_double;
  70         }
  71 }
  72 static inline jit_type_t psi_jit_decl_type(decl_type *type) {
  73         return psi_jit_type(real_decl_type(type)->type);
  74 }
  75 static inline jit_type_t psi_jit_decl_arg_type(decl_arg *darg) {
  76         if (darg->var->pointer_level) {
  77                 return jit_type_void_ptr;
  78         } else {
  79                 return psi_jit_decl_type(darg->type);
  80         }
  81 }
  82
  83 typedef struct PSI_ClosureData {
  84         void *context;
  85         impl *impl;
  86         jit_type_t signature;
  87         jit_type_t params[1];
  88 } PSI_ClosureData;
  89
  90 static inline PSI_ClosureData *PSI_ClosureDataAlloc(void *context, impl *impl) {
  91         size_t i, c = impl->decl->args->count;
  92         PSI_ClosureData *data = malloc(sizeof(*data) + (c ? c-1 : c) * sizeof(jit_type_t));
  93
  94         data->context = context;
  95         data->impl = impl;
  96         for (i = 0; i < c; ++i) {
  97                 data->params[i] = psi_jit_decl_arg_type(impl->decl->args->args[i]);
  98         }
  99         data->signature = jit_type_create_signature(
 100                 psi_jit_abi(data->impl->decl->abi->convention),
 101                 psi_jit_decl_arg_type(data->impl->decl->func),
 102                 data->params,
 103                 data->impl->decl->args->count,
 104                 1);
 105         return data;
 106 }
 107
 108
 109 static inline impl_val *deref(unsigned level, impl_val *ret_val, decl_arg *darg) {
 110         unsigned i;
 111
 112         for (i = level; i < darg->var->pointer_level; ++i) {
 113                 ret_val = *(void **)ret_val;
 114         }
 115
 116         return ret_val;
 117 }
 118 static void to_int(impl_val *ret_val, decl_arg *func, zval *return_value) {
 119         switch (real_decl_type(func->type)->type) {
 120         case PSI_T_FLOAT:
 121         case PSI_T_DOUBLE:
 122                 RETVAL_DOUBLE(deref(0, ret_val, func)->dval);
 123                 convert_to_long(return_value);
 124                 break;
 125         default:
 126                 RETVAL_LONG(deref(0, ret_val, func)->lval);
 127         }
 128 }
 129 static void to_string(impl_val *ret_val, decl_arg *func, zval *return_value) {
 130         switch (real_decl_type(func->type)->type) {
 131         case PSI_T_CHAR:
 132         case PSI_T_SINT8:
 133         case PSI_T_UINT8:
 134                 if (!func->var->pointer_level) {
 135                         char chr = ret_val->lval;
 136                         RETVAL_STRINGL(&chr, 1);
 137                 } else {
 138                         RETVAL_STRING(deref(1, ret_val, func)->ptr);
 139                 }
 140                 break;
 141         case PSI_T_FLOAT:
 142         case PSI_T_DOUBLE:
 143                 RETVAL_DOUBLE(deref(0, ret_val, func)->dval);
 144                 convert_to_string(return_value);
 145                 break;
 146         default:
 147                 RETVAL_LONG(deref(0, ret_val, func)->lval);
 148                 convert_to_string(return_value);
 149                 break;
 150         }
 151 }
 152
 153 static ZEND_RESULT_CODE handle_args(zend_execute_data *execute_data, impl *impl) {
 154         impl_arg *iarg;
 155
 156         if (!impl->func->args->count) {
 157                 return zend_parse_parameters_none();
 158         }
 159
 160         ZEND_PARSE_PARAMETERS_START(impl_num_min_args(impl), impl->func->args->count)
 161         nextarg:
 162                 iarg = impl->func->args->args[_i];
 163                 if (iarg->def) {
 164                         Z_PARAM_OPTIONAL;
 165                 }
 166                 if (PSI_T_BOOL == iarg->type->type) {
 167                         if (iarg->def) {
 168                                 iarg->val.cval = iarg->def->type == PSI_T_TRUE ? 1 : 0;
 169                         }
 170                         Z_PARAM_BOOL(iarg->val.cval);
 171                 } else if (PSI_T_INT == iarg->type->type) {
 172                         if (iarg->def) {
 173                                 iarg->val.lval = zend_atol(iarg->def->text, strlen(iarg->def->text));
 174                         }
 175                         Z_PARAM_LONG(iarg->val.lval);
 176                 } else if (PSI_T_FLOAT == iarg->type->type) {
 177                         if (iarg->def) {
 178                                 iarg->val.dval = zend_strtod(iarg->def->text, NULL);
 179                         }
 180                         Z_PARAM_DOUBLE(iarg->val.dval);
 181                 } else if (PSI_T_STRING == iarg->type->type) {
 182                         struct {char *val; size_t len;} str;
 183                         if (iarg->def) {
 184                                 /* FIXME */
 185                                 str.len = strlen(iarg->def->text) - 2;
 186                                 str.val = &iarg->def->text[1];
 187                         }
 188                         Z_PARAM_STR_EX(iarg->val.str, 1, 0);
 189                         if (iarg->val.str) {
 190                                 zend_string_addref(iarg->val.str);
 191                         } else if (iarg->def) {
 192                                 iarg->val.str = zend_string_init(str.val, str.len, 0);
 193                         }
 194                 } else {
 195                         error_code = ZPP_ERROR_FAILURE;
 196                         break;
 197                 }
 198                 iarg->_zv = _arg;
 199                 if (_i < _max_num_args) {
 200                         goto nextarg;
 201                 }
 202         ZEND_PARSE_PARAMETERS_END_EX(return FAILURE);
 203
 204         return SUCCESS;
 205 }
 206
 207 static impl_val *handle_let(decl_arg *darg, impl_arg *iarg) {
 208         impl_val *arg_val = &darg->let->out;
 209
 210         if (!iarg) {
 211                 /* let foo = NULL */
 212                 memset(arg_val, 0, sizeof(*arg_val));
 213                 return arg_val;
 214         }
 215         switch (darg->let->val->func->type) {
 216         case PSI_T_BOOLVAL:
 217                 if (iarg->type->type == PSI_T_BOOL) {
 218                         arg_val->cval = iarg->val.cval;
 219                 } else {
 220                         arg_val->cval = zend_is_true(iarg->_zv);
 221                 }
 222                 break;
 223         case PSI_T_INTVAL:
 224                 if (iarg->type->type == PSI_T_INT) {
 225                         arg_val->lval = iarg->val.lval;
 226                 } else {
 227                         arg_val->lval = zval_get_long(iarg->_zv);
 228                 }
 229                 break;
 230         case PSI_T_STRVAL:
 231                 if (iarg->type->type == PSI_T_STRING) {
 232                         arg_val->ptr = estrdup(iarg->val.str->val);
 233                         darg->let->mem = arg_val->ptr;
 234                         zend_string_release(iarg->val.str);
 235                 } else {
 236                         zend_string *zs = zval_get_string(iarg->_zv);
 237                         arg_val->ptr = estrdup(zs->val);
 238                         darg->let->mem = arg_val->ptr;
 239                         zend_string_release(zs);
 240                 }
 241                 break;
 242         case PSI_T_STRLEN:
 243                 if (iarg->type->type == PSI_T_STRING) {
 244                         arg_val->lval = iarg->val.str->len;
 245                         zend_string_release(iarg->val.str);
 246                 } else {
 247                         zend_string *zs = zval_get_string(iarg->_zv);
 248                         arg_val->lval = zs->len;
 249                         zend_string_release(zs);
 250                 }
 251                 break;
 252         EMPTY_SWITCH_DEFAULT_CASE();
 253         }
 254
 255         return arg_val;
 256 }
 257
 258 static void handle_rval(impl *impl, impl_val *ret_val, zval *return_value) {
 259         switch (impl->stmts->ret.list[0]->func->type) {
 260         case PSI_T_TO_STRING:
 261                 to_string(ret_val, impl->decl->func, return_value);
 262                 break;
 263         case PSI_T_TO_INT:
 264                 to_int(ret_val, impl->decl->func, return_value);
 265                 break;
 266         EMPTY_SWITCH_DEFAULT_CASE();
 267         }
 268 }
 269
 270 static void handle_set(zval *return_value, set_func *func, decl_vars *vars) {
 271         impl_val *val = &vars->vars[0]->arg->let->ptr;
 272
 273         zval_dtor(return_value);
 274
 275         switch (func->type) {
 276         case PSI_T_TO_STRING:
 277                 to_string(val, vars->vars[0]->arg, return_value);
 278                 break;
 279         EMPTY_SWITCH_DEFAULT_CASE();
 280         }
 281 }
 282
 283 static void handle_free(free_stmt *fre) {
 284         size_t i;
 285
 286         for (i = 0; i < fre->vars->count; ++i) {
 287                 decl_var *dvar = fre->vars->vars[i];
 288
 289                 if (dvar->arg && dvar->arg->let->out.ptr) {
 290                         free(dvar->arg->let->out.ptr);
 291                         dvar->arg->let->out.ptr = NULL;
 292                 }
 293         }
 294 }
 295
 296 static void handler(jit_type_t _sig, void *result, void **_args, void *_data)
 297 {
 298         PSI_ClosureData *data = _data;
 299         size_t i;
 300         void **arg_ptr = NULL, **arg_prm = NULL;
 301         impl_val ret_val;
 302
 303         if (SUCCESS != handle_args(*(zend_execute_data **)_args[0], data->impl)) {
 304                 return;
 305         }
 306
 307         if (data->impl->decl->args->count) {
 308                 arg_ptr = malloc(data->impl->decl->args->count * sizeof(*arg_ptr));
 309                 arg_prm = malloc(data->impl->decl->args->count * sizeof(*arg_prm));
 310
 311                 for (i = 0; i < data->impl->decl->args->count; ++i) {
 312                         decl_arg *darg = data->impl->decl->args->args[i];
 313                         impl_arg *iarg = darg->let ? darg->let->arg : NULL;
 314
 315                         arg_ptr[i] = handle_let(darg, iarg);
 316                         arg_prm[i] = darg->let->val->is_reference ? &arg_ptr[i] : arg_ptr[i];
 317
 318                         darg->let->ptr = arg_ptr[i];
 319                 }
 320         }
 321
 322         jit_apply(data->signature, data->impl->decl->dlptr, arg_prm, data->impl->decl->args->count, &ret_val);
 323
 324         handle_rval(data->impl, &ret_val, *(zval **)_args[1]);
 325
 326         for (i = 0; i < data->impl->stmts->set.count; ++i) {
 327                 set_stmt *set = data->impl->stmts->set.list[i];
 328
 329                 handle_set(set->arg->_zv, set->val->func, set->val->vars);
 330         }
 331
 332         if (data->impl->decl->args->count) {
 333                 for (i = 0; i < data->impl->decl->args->count; ++i) {
 334                         decl_arg *darg = data->impl->decl->args->args[i];
 335
 336                         if (darg->let && darg->let->mem) {
 337                                 efree(darg->let->mem);
 338                                 darg->let->mem = NULL;
 339                         }
 340                 }
 341                 free(arg_ptr);
 342                 free(arg_prm);
 343         }
 344
 345         for (i = 0; i < data->impl->stmts->fre.count; ++i) {
 346                 free_stmt *fre = data->impl->stmts->fre.list[i];
 347
 348                 handle_free(fre);
 349         }
 350 }
 351
 352 static inline int fill_type_hint(impl_type *type) {
 353         switch (type->type) {
 354         case PSI_T_BOOL:
 355                 return _IS_BOOL;
 356         case PSI_T_INT:
 357         case PSI_T_LONG:
 358                 return IS_LONG;
 359         case PSI_T_FLOAT:
 360         case PSI_T_DOUBLE:
 361                 return IS_DOUBLE;
 362         case PSI_T_STRING:
 363                 return IS_STRING;
 364         case PSI_T_ARRAY:
 365                 return IS_ARRAY;
 366         default:
 367                 return 0;
 368         }
 369 }
 370
 371 static inline zend_internal_arg_info *fill_arginfo(impl *impl) {
 372         size_t i;
 373         zend_internal_arg_info *aip;
 374         zend_internal_function_info *fi;
 375
 376         aip = calloc(impl->func->args->count + 1, sizeof(*aip));
 377
 378         fi = (zend_internal_function_info *) &aip[0];
 379         fi->required_num_args = impl_num_min_args(impl);
 380         fi->return_reference = impl->func->return_reference;
 381         fi->type_hint = fill_type_hint(impl->func->return_type);
 382
 383         for (i = 0; i < impl->func->args->count; ++i) {
 384                 impl_arg *iarg = impl->func->args->args[i];
 385                 zend_internal_arg_info *ai = &aip[i+1];
 386
 387                 ai->name = iarg->var->name;
 388                 ai->type_hint = fill_type_hint(iarg->type);
 389                 if (iarg->var->reference) {
 390                         ai->pass_by_reference = 1;
 391                 }
 392                 if (iarg->var->reference || (iarg->def && iarg->def->type == PSI_T_NULL)) {
 393                         ai->allow_null = 1;
 394                 }
 395         }
 396
 397         return aip;
 398 }
 399
 400 static zend_function_entry *compile(PSI_Context *C, PSI_Data *D)
 401 {
 402         size_t i, j = 0;
 403         jit_type_t signature, params[] = {
 404                 jit_type_void_ptr,
 405                 jit_type_void_ptr
 406         };
 407         zend_function_entry *zfe = calloc(D->impls->count + 1, sizeof(*zfe));
 408
 409         jit_context_build_start(C->context);
 410
 411         for (i = 0; i < D->impls->count; ++i) {
 412                 zend_function_entry *zf = &zfe[j];
 413                 PSI_ClosureData *data;
 414
 415                 if (!D->impls->list[i]->decl) {
 416                         continue;
 417                 }
 418
 419                 data = PSI_ClosureDataAlloc(C, D->impls->list[i]);
 420                 signature = jit_type_create_signature(jit_abi_cdecl, jit_type_void, params, 2, 1);
 421                 zf->fname = D->impls->list[i]->func->name + (D->impls->list[i]->func->name[0] == '\\');
 422                 zf->handler = jit_closure_create(C->context, signature, &handler, data);
 423                 zf->num_args = D->impls->list[i]->func->args->count;
 424                 zf->arg_info = fill_arginfo(D->impls->list[i]);
 425                 ++j;
 426         }
 427
 428         jit_context_build_end(C->context);
 429
 430         return zfe;
 431 }
 432
 433 static PSI_ContextOps ops = {
 434         init,
 435         dtor,
 436         compile,
 437 };
 438
 439 PSI_ContextOps *PSI_Libjit(void)
 440 {
 441         return &ops;
 442 }