Changeset 95 in svn


Ignore:
Timestamp:
2006-07-16T11:07:57Z (9 years ago)
Author:
Xuefer
Message:

fixed #20, default: --enable-xcache-constant=yes

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/config.m4

    r87 r95  
    1818
    1919if test "$PHP_XCACHE" != "no"; then
     20    PHP_ARG_ENABLE(xcache-constant, for XCache handle of compile time constant,
     21  [  --enable-xcache-constant        XCache: Handle new constants made by php compiler (e.g.: for __halt_compiler)], yes, no)
     22    if test "$PHP_XCACHE_CONSTANT" != "no"; then
     23        AC_DEFINE([HAVE_XCACHE_CONSTANT], 1, [Define to enable XCache handling of compile time constants])
     24    fi
     25
    2026  xcache_sources="processor.c \
    2127                  xcache.c \
  • trunk/config.w32

    r37 r95  
    55
    66if (PHP_XCACHE != "no") {
     7    // {{{ check for xcache-constant
     8    ARG_ENABLE("xcache-constant", "XCache: Handle new constants made by php compiler (e.g.: for __halt_compiler)", "yes");
     9    if (PHP_XCACHE_CONSTANT != "no") {
     10        AC_DEFINE("HAVE_XCACHE_CONSTANT", 1, "Define to enable XCache handling of compile time constants");
     11    }
     12    // }}}
     13
    714    var xcache_sources = "processor.c \
    815                          xcache.c \
  • trunk/processor/processor.m4

    r94 r95  
    55DECL_STRUCT_P_FUNC(`zend_op_array')
    66DECL_STRUCT_P_FUNC(`zend_class_entry')
     7#ifdef HAVE_XCACHE_CONSTANT
     8DECL_STRUCT_P_FUNC(`zend_constant')
     9#endif
    710DECL_STRUCT_P_FUNC(`zend_function')
    811DECL_STRUCT_P_FUNC(`xc_entry_t')
     
    5962dnl }}}
    6063DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr',           `zval_ptr')
     64#ifdef HAVE_XCACHE_CONSTANT
     65DEF_HASH_TABLE_FUNC(`HashTable_zend_constant',      `zend_constant')
     66#endif
    6167DEF_HASH_TABLE_FUNC(`HashTable_zend_function',      `zend_function')
    6268#ifdef ZEND_ENGINE_2
     
    205211#endif
    206212dnl }}}
     213#ifdef HAVE_XCACHE_CONSTANT
     214DEF_STRUCT_P_FUNC(`zend_constant', , `dnl {{{
     215    STRUCT(zval, value)
     216    DISPATCH(int, flags)
     217    DISPATCH(uint, name_len)
     218    PROC_STRING_L(name, name_len)
     219    zstr name;
     220    DISPATCH(int, module_number)
     221')
     222dnl }}}
     223#endif
    207224DEF_STRUCT_P_FUNC(`zend_function', , `dnl {{{
    208225    DISABLECHECK(`
     
    599616    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
    600617
    601     IFCOPY(`dst->start_op = src->start_op;')
    602     DONE(start_op)
     618    COPY(start_op)
    603619    DISPATCH(int, backpatch_count)
    604620
     
    628644dnl }}}
    629645
     646#ifdef HAVE_XCACHE_CONSTANT
     647DEF_STRUCT_P_FUNC(`xc_constinfo_t', , `dnl {{{
     648    DISPATCH(zend_uint, key_size)
     649#ifdef IS_UNICODE
     650    DISPATCH(zend_uchar, type)
     651#endif
     652    IFRESTORE(`COPY(key)', `
     653        PROC_USTRING_N(type, key, key_size)
     654    ')
     655    STRUCT(zend_constant, constant)
     656')
     657dnl }}}
     658#endif
    630659DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{
    631660    DISPATCH(zend_uint, key_size)
     
    666695
    667696    STRUCT_P(zend_op_array, op_array)
     697
     698#ifdef HAVE_XCACHE_CONSTANT
     699    DISPATCH(zend_uint, constinfo_cnt)
     700    STRUCT_ARRAY(constinfo_cnt, xc_constinfo_t, constinfos)
     701#endif
    668702
    669703    DISPATCH(zend_uint, funcinfo_cnt)
  • trunk/utils.c

    r88 r95  
    265265#endif
    266266
     267#ifdef HAVE_XCACHE_CONSTANT
     268void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, void *key, uint len TSRMLS_DC) /* {{{ */
     269{
     270    if (zend_u_hash_add(EG(zend_constants), type, key, len,
     271                constant, sizeof(zend_constant),
     272                NULL
     273                ) == FAILURE) {
     274        CG(in_compilation) = 1;
     275        CG(compiled_filename) = filename;
     276        CG(zend_lineno) = 0;
     277        zend_error(E_NOTICE, "Constant %s already defined", key);
     278        free(constant->name);
     279        if (!(constant->flags & CONST_PERSISTENT)) {
     280            zval_dtor(&constant->value);
     281        }
     282    }
     283}
     284/* }}} */
     285#endif
    267286void xc_install_function(char *filename, zend_function *func, zend_uchar type, void *key, uint len TSRMLS_DC) /* {{{ */
    268287{
     
    316335#define OG(x) (sandbox->orig_##x)
    317336/* }}} */
     337#ifdef HAVE_XCACHE_CONSTANT
     338static void xc_constant_copy_ctor(zend_constant *c) /* {{{ */
     339{
     340    c->name = zend_strndup(c->name, c->name_len - 1);
     341    if (!(c->flags & CONST_PERSISTENT)) {
     342        zval_copy_ctor(&c->value);
     343    }
     344}
     345/* }}} */
     346#endif
    318347xc_sandbox_t *xc_sandbox_init(xc_sandbox_t *sandbox, char *filename TSRMLS_DC) /* {{{ */
    319348{
     
    325354        sandbox->alloc = 1;
    326355    }
     356
    327357    memcpy(&OG(included_files), &EG(included_files), sizeof(EG(included_files)));
    328358    memcpy(&OG(open_files), &CG(open_files), sizeof(CG(open_files)));
     359
     360#ifdef HAVE_XCACHE_CONSTANT
     361    OG(zend_constants) = EG(zend_constants);
     362    EG(zend_constants) = &TG(zend_constants);
     363#endif
    329364
    330365    OG(function_table) = CG(function_table);
     
    342377    zend_llist_init(TG(open_files), sizeof(zend_file_handle), (void (*)(void *)) zend_file_handle_dtor, 0);
    343378    zend_hash_init_ex(TG(included_files), 5, NULL, NULL, 0, 1);
     379#ifdef HAVE_XCACHE_CONSTANT
     380    zend_hash_init_ex(&TG(zend_constants), 20, NULL, ZEND_CONSTANT_DTOR, 1, 0);
     381#endif
    344382    zend_hash_init_ex(&TG(function_table), 128, NULL, ZEND_FUNCTION_DTOR, 0, 0);
    345383    zend_hash_init_ex(&TG(class_table), 16, NULL, ZEND_CLASS_DTOR, 0, 0);
     
    356394    zend_llist_position lpos;
    357395    zend_file_handle *handle;
     396
     397#ifdef HAVE_XCACHE_CONSTANT
     398    b = TG(zend_constants).pListHead;
     399    /* install constants */
     400    while (b != NULL) {
     401        zend_constant *c = (zend_constant*) b->pData;
     402        xc_install_constant(sandbox->filename, c,
     403                BUCKET_KEY_TYPE(b), BUCKET_KEY(b), b->nKeyLength TSRMLS_CC);
     404        b = b->pListNext;
     405    }
     406#endif
    358407
    359408    b = TG(function_table).pListHead;
     
    386435{
    387436    /* restore first first install function/class */
     437#ifdef HAVE_XCACHE_CONSTANT
     438    EG(zend_constants) = OG(zend_constants);
     439#endif
    388440    CG(function_table) = OG(function_table);
    389441    CG(class_table)    = OG(class_table);
     
    394446
    395447        /* no free as it's installed */
     448#ifdef HAVE_XCACHE_CONSTANT
     449        TG(zend_constants).pDestructor = NULL;
     450#endif
    396451        TG(function_table).pDestructor = NULL;
    397452        TG(class_table).pDestructor = NULL;
     
    400455
    401456    /* destroy all the tmp */
     457#ifdef HAVE_XCACHE_CONSTANT
     458    zend_hash_destroy(&TG(zend_constants));
     459#endif
    402460    zend_hash_destroy(&TG(function_table));
    403461    zend_hash_destroy(&TG(class_table));
  • trunk/utils.h

    r88 r95  
    2626
    2727/* installer */
     28#ifdef HAVE_XCACHE_CONSTANT
     29void xc_install_constant(char *filename, zend_constant *constant, zend_uchar type, void *key, uint len TSRMLS_DC);
     30#endif
    2831void xc_install_function(char *filename, zend_function *func, zend_uchar type, void *key, uint len TSRMLS_DC);
    2932ZESW(xc_cest_t *, void) xc_install_class(char *filename, xc_cest_t *cest, zend_uchar type, void *key, uint len TSRMLS_DC);
     
    3942    zend_llist *tmp_open_files;
    4043
     44#ifdef HAVE_XCACHE_CONSTANT
     45    HashTable *orig_zend_constants;
     46    HashTable tmp_zend_constants;
     47#endif
    4148    HashTable *orig_function_table;
    4249    HashTable *orig_class_table;
  • trunk/xcache.c

    r92 r95  
    301301        case XC_TYPE_PHP:
    302302            php = entry->data.php;
    303             add_assoc_long_ex(ei, ZEND_STRS("sourcesize"),   php->sourcesize);
     303            add_assoc_long_ex(ei, ZEND_STRS("sourcesize"),    php->sourcesize);
    304304#ifdef HAVE_INODE
    305             add_assoc_long_ex(ei, ZEND_STRS("device"),       php->device);
    306             add_assoc_long_ex(ei, ZEND_STRS("inode"),        php->inode);
    307 #endif
    308             add_assoc_long_ex(ei, ZEND_STRS("mtime"),        php->mtime);
    309 
    310             add_assoc_long_ex(ei, ZEND_STRS("function_cnt"), php->funcinfo_cnt);
    311             add_assoc_long_ex(ei, ZEND_STRS("class_cnt"),    php->classinfo_cnt);
     305            add_assoc_long_ex(ei, ZEND_STRS("device"),        php->device);
     306            add_assoc_long_ex(ei, ZEND_STRS("inode"),         php->inode);
     307#endif
     308            add_assoc_long_ex(ei, ZEND_STRS("mtime"),         php->mtime);
     309
     310#ifdef HAVE_XCACHE_CONSTANT
     311            add_assoc_long_ex(ei, ZEND_STRS("constinfo_cnt"), php->constinfo_cnt);
     312#endif
     313            add_assoc_long_ex(ei, ZEND_STRS("function_cnt"),  php->funcinfo_cnt);
     314            add_assoc_long_ex(ei, ZEND_STRS("class_cnt"),     php->classinfo_cnt);
    312315            break;
    313316        case XC_TYPE_VAR:
     
    354357    /* new ptr which is stored inside CG(class_table) */
    355358    xc_cest_t **new_cest_ptrs = (xc_cest_t **)do_alloca(sizeof(xc_cest_t*) * p->classinfo_cnt);
     359#endif
     360
     361#ifdef HAVE_XCACHE_CONSTANT
     362    /* install constant */
     363    for (i = 0; i < p->constinfo_cnt; i ++) {
     364        xc_constinfo_t *ci = &p->constinfos[i];
     365        xc_install_constant(xce->name.str.val, &ci->constant,
     366                UNISW(0, ci->type), ci->key, ci->key_size TSRMLS_CC);
     367    }
    356368#endif
    357369
     
    594606    zend_bool catched = 0;
    595607    char *filename;
     608    int old_constinfo_cnt, old_funcinfo_cnt, old_classinfo_cnt;
    596609
    597610    if (!xc_initized) {
     
    675688    xc_sandbox_init(&sandbox, filename TSRMLS_CC);
    676689
     690    old_classinfo_cnt = zend_hash_num_elements(CG(class_table));
     691    old_funcinfo_cnt  = zend_hash_num_elements(CG(function_table));
     692    old_constinfo_cnt  = zend_hash_num_elements(EG(zend_constants));
     693
    677694    zend_try {
    678695        op_array = origin_compile_file(h, type TSRMLS_CC);
     
    703720    php.op_array      = op_array;
    704721
    705     php.funcinfo_cnt  = zend_hash_num_elements(CG(function_table));
    706     php.classinfo_cnt = zend_hash_num_elements(CG(class_table));
    707 
    708     php.funcinfos     = ECALLOC_N(php.funcinfos, php.funcinfo_cnt);
    709     if (!php.funcinfos) {
    710         goto err_func;
    711     }
    712     php.classinfos    = ECALLOC_N(php.classinfos, php.classinfo_cnt);
    713     if (!php.classinfos) {
    714         goto err_class;
    715     }
     722#ifdef HAVE_XCACHE_CONSTANT
     723    php.constinfo_cnt = zend_hash_num_elements(EG(zend_constants)) - old_constinfo_cnt;
     724#endif
     725    php.funcinfo_cnt  = zend_hash_num_elements(CG(function_table)) - old_funcinfo_cnt;
     726    php.classinfo_cnt = zend_hash_num_elements(CG(class_table))    - old_classinfo_cnt;
     727
     728#define X_ALLOC_N(var, cnt) do {     \
     729    if (php.cnt) {                   \
     730        ECALLOC_N(php.var, php.cnt); \
     731        if (!php.var) {              \
     732            goto err_##var;          \
     733        }                            \
     734    }                                \
     735    else {                           \
     736        php.var = NULL;              \
     737    }                                \
     738} while (0)
     739
     740#ifdef HAVE_XCACHE_CONSTANT
     741    X_ALLOC_N(constinfos, constinfo_cnt);
     742#endif
     743    X_ALLOC_N(funcinfos,  funcinfo_cnt);
     744    X_ALLOC_N(classinfos, classinfo_cnt);
     745#undef X_ALLOC
    716746    /* }}} */
    717747    /* {{{ shallow copy, pointers only */ {
     
    719749        unsigned int i;
    720750
    721         b = CG(function_table)->pListHead;
    722         for (i = 0; b; i ++, b = b->pListNext) {
    723             xc_funcinfo_t *fi = &php.funcinfos[i];
    724 
    725             assert(i < php.funcinfo_cnt);
    726             assert(b->pData);
    727             memcpy(&fi->func, b->pData, sizeof(zend_function));
    728             UNISW(NOTHING, fi->type = b->key.type;)
    729             fi->key        = BUCKET_KEY(b);
    730             fi->key_size   = b->nKeyLength;
    731         }
    732 
    733         b = CG(class_table)->pListHead;
    734         for (i = 0; b; i ++, b = b->pListNext) {
    735             xc_classinfo_t *ci = &php.classinfos[i];
    736 
    737             assert(i < php.classinfo_cnt);
    738             assert(b->pData);
    739             memcpy(&ci->cest, b->pData, sizeof(xc_cest_t));
    740             UNISW(NOTHING, ci->type = b->key.type;)
    741             ci->key        = BUCKET_KEY(b);
    742             ci->key_size   = b->nKeyLength;
    743             /* need to fix inside store */
    744         }
     751#define COPY_H(vartype, var, cnt, name, datatype) do {        \
     752    for (i = 0; b; i ++, b = b->pListNext) {                  \
     753        vartype *data = &php.var[i];                          \
     754                                                              \
     755        if (i < old_##cnt) {                                  \
     756            continue;                                         \
     757        }                                                     \
     758                                                              \
     759        assert(i < old_##cnt + php.cnt);                      \
     760        assert(b->pData);                                     \
     761        memcpy(&data->name, b->pData, sizeof(datatype));      \
     762        UNISW(NOTHING, data->type = b->key.type;)             \
     763        data->key        = BUCKET_KEY(b);                     \
     764        data->key_size   = b->nKeyLength;                     \
     765    }                                                         \
     766} while(0)
     767
     768#ifdef HAVE_XCACHE_CONSTANT
     769        b = EG(zend_constants)->pListHead; COPY_H(xc_constinfo_t, constinfos, constinfo_cnt, constant, zend_constant);
     770#endif
     771        b = CG(function_table)->pListHead; COPY_H(xc_funcinfo_t,  funcinfos,  funcinfo_cnt,  func,     zend_function);
     772        b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, cest,     xc_cest_t);
     773
     774#undef COPY_H
     775        /* for ZE1, cest need to fix inside store */
    745776    }
    746777    /* }}} */
     
    754785#endif
    755786
    756     efree(xce.data.php->classinfos);
    757 err_class:
    758     efree(xce.data.php->funcinfos);
    759 err_func:
     787#define X_FREE(var) \
     788    if (xce.data.php->var) { \
     789        efree(xce.data.php->var); \
     790    } \
     791err_##var:
     792
     793    X_FREE(classinfos)
     794    X_FREE(funcinfos)
     795#ifdef HAVE_XCACHE_CONSTANT
     796    X_FREE(constinfos)
     797#endif
     798#undef X_FREE
     799
    760800err_oparray:
    761801err_bailout:
     
    790830#endif
    791831    xc_processor_restore_xc_entry_t(&xce, stored_xce, xc_readonly_protection TSRMLS_CC);
    792     op_array = xc_entry_install(&xce, h TSRMLS_CC);
    793 
    794     efree(xce.data.php->funcinfos);
    795     efree(xce.data.php->classinfos);
     832
     833    catched = 0;
     834    zend_try {
     835        op_array = xc_entry_install(&xce, h TSRMLS_CC);
     836    } zend_catch {
     837        catched = 1;
     838    } zend_end_try();
     839
     840#define X_FREE(var) \
     841    if (xce.data.php->var) { \
     842        efree(xce.data.php->var); \
     843    }
     844    X_FREE(classinfos)
     845    X_FREE(funcinfos)
     846#ifdef HAVE_XCACHE_CONSTANT
     847    X_FREE(constinfos)
     848#endif
     849#undef X_FREE
    796850    efree(xce.data.php);
     851
     852    if (catched) {
     853        zend_bailout();
     854    }
    797855#ifdef DEBUG
    798856    fprintf(stderr, "restored\n");
  • trunk/xcache.h

    r88 r95  
    154154} xc_classinfo_t;
    155155/* }}} */
     156#ifdef HAVE_XCACHE_CONSTANT
     157/* {{{ xc_constinfo_t */
     158typedef struct {
     159#ifdef IS_UNICODE
     160    zend_uchar type;
     161#endif
     162    char *key;
     163    zend_uint key_size;
     164    zend_constant constant;
     165} xc_constinfo_t;
     166/* }}} */
     167#endif
    156168/* {{{ xc_funcinfo_t */
    157169typedef struct {
     
    175187
    176188    zend_op_array *op_array;
     189
     190#ifdef HAVE_XCACHE_CONSTANT
     191    zend_uint constinfo_cnt;
     192    xc_constinfo_t *constinfos;
     193#endif
    177194
    178195    zend_uint funcinfo_cnt;
Note: See TracChangeset for help on using the changeset viewer.