Changeset 662


Ignore:
Timestamp:
2009-08-03T10:15:53+02:00 (5 years ago)
Author:
moo
Message:

back patch __FILE and __DIR on cache restore

Location:
trunk
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/processor/dispatch.m4

    r484 r662  
    2828    ) 
    2929') 
     30dnl {{{ DISPATCH_ARRAY(1:count, 2:type, 3:elm) 
     31define(`DISPATCH_ARRAY', ` 
     32    if (src->$3) { 
     33        int i; 
     34        IFDASM(` 
     35            zval *arr; 
     36            ALLOC_INIT_ZVAL(arr); 
     37            array_init(arr); 
     38            for (i = 0; i < src->$1; i ++) { 
     39                ifelse( 
     40                    `$2', `zend_bool', `add_assoc_bool_ex(arr, ZEND_STRS("$3"), src->$3[i] ? 1 : 0);' 
     41                , `', `', `add_assoc_long_ex(arr, ZEND_STRS("$3"), src->$3[i]);') 
     42            } 
     43            add_assoc_zval_ex(dst, ZEND_STRS("$3"), arr); 
     44        ', ` 
     45            COPY_N_EX($@) 
     46            for (i = 0; i < src->$1; i ++) { 
     47                DISABLECHECK(` 
     48                    DISPATCH(`$2', `$3[i]', `$4') 
     49                ') 
     50            } 
     51        ')dnl IFDASM 
     52        DONE(`$3') 
     53    } 
     54    else { 
     55        COPYNULL(`$3') 
     56    } 
     57') 
     58dnl }}} 
  • trunk/processor/head.m4

    r645 r662  
    6969    const xc_cache_t          *cache; 
    7070    const zend_class_entry *cache_ce; 
    71     zend_uint cache_class_num; 
     71    zend_uint cache_class_index; 
    7272 
    7373    const zend_op          *active_opcodes_src; 
     
    7575    const zend_class_entry *active_class_entry_src; 
    7676    zend_class_entry       *active_class_entry_dst; 
    77     zend_uint               active_class_num; 
     77    zend_uint                 active_class_index; 
     78    zend_uint                 active_op_array_index; 
     79    const xc_op_array_info_t *active_op_array_infos_src; 
    7880 
    7981    zend_bool readonly_protection; /* wheather it's present */ 
     
    186188 
    187189    if (processor->cache_ce == ce) { 
    188         return processor->cache_class_num; 
     190        return processor->cache_class_index + 1; 
    189191    } 
    190192    for (i = 0; i < php->classinfo_cnt; i ++) { 
     
    192194        if (ZCEP_REFCOUNT_PTR(ceptr) == ZCEP_REFCOUNT_PTR(ce)) { 
    193195            processor->cache_ce = ceptr; 
    194             processor->cache_class_num = i + 1; 
     196            processor->cache_class_index = i + 1; 
    195197            return i + 1; 
    196198        } 
     
    199201    return (zend_ulong) -1; 
    200202} 
     203define(`xc_get_class_num', `xc_get_class_numNOTDEFINED') 
    201204/* }}} */ 
    202205/* {{{ xc_get_class */ 
     
    204207static zend_class_entry *xc_get_class(xc_processor_t *processor, zend_ulong class_num) { 
    205208    /* must be parent or currrent class */ 
    206     assert(class_num <= processor->active_class_num); 
     209    assert(class_num <= processor->active_class_index + 1); 
    207210    return CestToCePtr(processor->php_dst->classinfos[class_num - 1].cest); 
    208211} 
    209212#endif 
     213define(`xc_get_class', `xc_get_classNOTDEFINED') 
    210214/* }}} */ 
    211215#ifdef ZEND_ENGINE_2 
  • trunk/processor/main.m4

    r569 r662  
    150150define(`COPY', `IFNOTMEMCPY(`IFCOPY(`dst->$1 = src->$1;')')DONE(`$1')') 
    151151dnl }}} 
     152dnl {{{ COPY_N_EX 
     153define(`COPY_N_EX', ` 
     154    ALLOC(`dst->$3', `$2', `src->$1') 
     155    IFCOPY(` 
     156        memcpy(dst->$3, src->$3, sizeof(dst->$3[0]) * src->$1); 
     157        ') 
     158') 
     159dnl }}} 
     160dnl {{{ COPY_N 
     161define(`COPY_N', `COPY_N_EX(`$1',`$2')DONE(`$1')') 
     162dnl }}} 
    152163dnl {{{ COPYPOINTER 
    153164define(`COPYPOINTER', `COPY(`$1')') 
    154165dnl }}} 
     166dnl {{{ COPYARRAY_EX 
     167define(`COPYARRAY_EX', `IFNOTMEMCPY(`IFCOPY(`memcpy(dst->$1, src->$1, sizeof(dst->$1));')')') 
     168dnl }}} 
    155169dnl {{{ COPYARRAY 
    156 define(`COPYARRAY', `IFNOTMEMCPY(`IFCOPY(`memcpy(dst->$1, src->$1, sizeof(dst->$1));')')DONE(`$1')') 
     170define(`COPYARRAY', `COPYARRAY_EX(`$1',`$2')DONE(`$1')') 
    157171dnl }}} 
    158172dnl {{{ SETNULL_EX 
     
    244258define(`IFNOTMEMCPY', `ifdef(`USEMEMCPY', `', `$1')') 
    245259REDEF(`KIND', `calc') include(srcdir`/processor/processor.m4') 
     260pushdef(`xc_get_class_num', ``xc_get_class_num'($@)') 
    246261REDEF(`KIND', `store') include(srcdir`/processor/processor.m4') 
     262popdef(`xc_get_class_num') 
     263pushdef(`xc_get_class', ``xc_get_class'($@)') 
    247264REDEF(`KIND', `restore') include(srcdir`/processor/processor.m4') 
     265popdef(`xc_get_class') 
    248266 
    249267REDEF(`IFNOTMEMCPY', `$1') 
  • trunk/processor/processor.m4

    r648 r662  
    339339        if (src->num_interfaces) { 
    340340            /* 
     341            int i; 
    341342            zval *arr; 
    342343            ALLOC_INIT_ZVAL(arr); 
     
    499500DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{ 
    500501    IFRESTORE(` 
     502    const xc_op_array_info_t *op_array_info = &processor->active_op_array_infos_src[processor->active_op_array_index]; 
    501503    dnl shadow copy must NOT meet: 
    502504    dnl readonly_protection=on 
    503505    dnl main op_array && have early binding 
    504     zend_uint ii; 
    505506#ifdef ZEND_COMPILE_DELAYED_BINDING 
    506507    zend_bool need_early_binding = 0; 
     
    508509    zend_bool need_early_binding = processor->php_src->have_early_binding; 
    509510#endif 
    510     if (!processor->readonly_protection && !(src == processor->php_src->op_array && need_early_binding)) { 
     511    zend_bool shallow_copy = !processor->readonly_protection && !(src == processor->php_src->op_array && need_early_binding); 
     512    if (shallow_copy) { 
     513        zend_bool gc_arg_info = 0; 
     514        int gc_opcodes        = 0; 
    511515        /* really fast shallow copy */ 
    512516        memcpy(dst, src, sizeof(src[0])); 
     
    515519        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr) 
    516520#ifdef ZEND_ENGINE_2 
    517         STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info) 
    518         xc_gc_add_op_array(dst TSRMLS_CC); 
    519 #endif 
     521        STRUCT_ARRAY(num_args, zend_arg_info, arg_info) 
     522        gc_arg_info = 1; 
     523#endif 
     524        if (op_array_info->oplineinfo_cnt) { 
     525            gc_opcodes = 1; 
     526            COPY_N_EX(last, zend_op, opcodes) 
     527        } 
     528        if (gc_arg_info || gc_opcodes) { 
     529            xc_gc_op_array_t gc_op_array; 
     530#ifdef ZEND_ENGINE_2 
     531            gc_op_array.num_args = gc_arg_info ? dst->num_args : 0; 
     532            gc_op_array.arg_info = gc_arg_info ? dst->arg_info : NULL; 
     533#endif 
     534            gc_op_array.last     = gc_opcodes > 1 ? dst->last : 0; 
     535            gc_op_array.opcodes  = gc_opcodes ? dst->opcodes : NULL; 
     536            xc_gc_add_op_array(&gc_op_array TSRMLS_CC); 
     537        } 
    520538        define(`SKIPASSERT_ONCE') 
    521539    } 
     
    524542    do { 
    525543    dnl RESTORE is done above! 
    526     zend_uint ii; 
    527     int i; 
    528544 
    529545    /* Common elements */ 
     
    532548#ifdef ZEND_ENGINE_2 
    533549    DISPATCH(zend_uint, fn_flags) 
    534     STRUCT_ARRAY_I(num_args, zend_arg_info, arg_info) 
     550    STRUCT_ARRAY(num_args, zend_arg_info, arg_info) 
    535551    DISPATCH(zend_uint, num_args) 
    536552    DISPATCH(zend_uint, required_num_args) 
     
    541557        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));') 
    542558        IFDASM(`do { 
    543             zend_uint ii; 
    544559            int i; 
    545560            zval *zv; 
     
    581596        processor->active_opcodes_src = src->opcodes; 
    582597    ')') 
    583     STRUCT_ARRAY_I(last, zend_op, opcodes) 
     598    STRUCT_ARRAY(last, zend_op, opcodes) 
    584599    popdef(`AFTER_ALLOC') 
    585600    DISPATCH(zend_uint, last) 
     
    599614    DISPATCH(zend_uint, T) 
    600615 
    601     STRUCT_ARRAY_I(last_brk_cont, zend_brk_cont_element, brk_cont_array) 
     616    STRUCT_ARRAY(last_brk_cont, zend_brk_cont_element, brk_cont_array) 
    602617    DISPATCH(zend_uint, last_brk_cont) 
    603618    DISPATCH(zend_uint, current_brk_cont) 
     
    649664#endif 
    650665    } while (0); 
     666    IFRESTORE(`xc_fix_op_array_info(processor->php_src, dst, !shallow_copy, op_array_info TSRMLS_CC);') 
    651667 
    652668#ifdef ZEND_ENGINE_2 
     
    713729dnl }}} 
    714730#endif 
     731DEF_STRUCT_P_FUNC(`xc_op_array_info_t', , `dnl {{{ 
     732    DISPATCH(zend_uint, oplineinfo_cnt) 
     733    DISPATCH_ARRAY(oplineinfo_cnt, int, oplineinfos) 
     734') 
     735dnl }}} 
    715736DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{ 
    716737    DISPATCH(zend_uint, key_size) 
     
    722743    ') 
    723744    DISPATCH(ulong, h) 
     745    IFRESTORE(`COPY(op_array_info)', ` 
     746        STRUCT(xc_op_array_info_t, op_array_info) 
     747    ') 
     748    IFRESTORE(` 
     749        processor->active_op_array_infos_src = &dst->op_array_info; 
     750        processor->active_op_array_index = 0; 
     751    ') 
    724752    STRUCT(zend_function, func) 
    725753') 
     
    734762    ') 
    735763    DISPATCH(ulong, h) 
     764    DISPATCH(zend_uint, methodinfo_cnt) 
     765    IFRESTORE(`COPY(methodinfos)', ` 
     766        STRUCT_ARRAY(methodinfo_cnt, xc_op_array_info_t, methodinfos) 
     767    ') 
     768    IFRESTORE(` 
     769        processor->active_op_array_infos_src = dst->methodinfos; 
     770        processor->active_op_array_index = 0; 
     771    ') 
    736772#ifdef ZEND_ENGINE_2 
    737773    STRUCT_P(zend_class_entry, cest) 
     
    767803#endif 
    768804DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{ 
    769     zend_uint i; 
    770  
    771805    IFCOPY(` 
    772806        processor->php_dst = dst; 
     
    785819    DISPATCH(size_t, size) 
    786820 
     821    DISPATCH(int, filepath_len) 
     822    IFRESTORE(`COPY(filepath)', `PROC_STRING_L(filepath, filepath_len)') 
     823    DISPATCH(int, dirpath_len) 
     824    IFRESTORE(`COPY(dirpath)', `PROC_STRING_L(dirpath, dirpath_len)') 
     825#ifdef IS_UNICODE 
     826    DISPATCH(int, ufilepath_len) 
     827    IFRESTORE(`COPY(ufilepath)', `PROC_USTRING_L(ufilepath, ufilepath_len)') 
     828    DISPATCH(int, udirpath_len) 
     829    IFRESTORE(`COPY(udirpath)', `PROC_USTRING_L(udirpath, udirpath_len)') 
     830#endif 
     831 
     832    IFRESTORE(`COPY(op_array_info)', ` 
     833        STRUCT(xc_op_array_info_t, op_array_info) 
     834    ') 
     835    IFRESTORE(` 
     836        processor->active_op_array_infos_src = &dst->op_array_info; 
     837        processor->active_op_array_index = 0; 
     838    ') 
    787839    STRUCT_P(zend_op_array, op_array) 
    788840 
     
    796848 
    797849    DISPATCH(zend_uint, classinfo_cnt) 
    798     pushdef(`BEFORE_LOOP', ` 
    799         IFCOPY(` 
    800             processor->active_class_num = i + 1; 
    801         ') 
    802     ') 
    803     STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos) 
    804     popdef(`BEFORE_LOOP') 
     850    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos, , IFRESTORE(`processor->active_class_index')) 
    805851#ifdef ZEND_ENGINE_2_1 
    806852    DISPATCH(zend_uint, autoglobal_cnt) 
     
    879925        switch (src->type) { 
    880926        case XC_TYPE_PHP: 
    881             IFCALCCOPY(`DONE(data.php)', `STRUCT_P(xc_entry_data_php_t, data.php)') 
     927            IFCALCCOPY(`COPY(data.php)', `STRUCT_P(xc_entry_data_php_t, data.php)') 
    882928            break; 
    883929 
  • trunk/processor/string.m4

    r658 r662  
    77            STRTYPE, `zstr_char', `char', 
    88            `',      `',          `UChar')) 
    9     pushdef(`ISTYPE', ifelse(STRTYPE,`zstr_uchar',IS_UNICODE,IS_STRING)) 
     9    pushdef(`ISTYPE', ifelse(PTRTYPE,`UChar',IS_UNICODE,IS_STRING)) 
    1010    pushdef(`UNI_STRLEN', ifelse( 
    1111            STRTYPE, `zstr_uchar', `xc_zstrlen_uchar', 
    1212            STRTYPE, `zstr_char',  `xc_zstrlen_char', 
    1313            `',      `',           `strlen')) 
    14     pushdef(`SRCSTR', ifelse(STRTYPE,`char',`ZSTR($2)',`$2')) 
     14    pushdef(`SRCSTR', ifelse(STRTYPE,`char',`ZSTR($2)',STRTYPE,`UChar',`ZSTR($2)',`$2')) 
    1515    pushdef(`SRCPTR', ifelse( 
    1616            STRTYPE, `zstr_uchar', `ZSTR_U($2)', 
     
    8888dnl PROC_STRING_N(1:name, 2:size, 3:type) 
    8989define(`PROC_STRING_N', `DBG(`$0($*)') DONE(`$1')`'PROC_STRING_N_EX(`dst->$1', `src->$1', `src->$2', `$1', `char')') 
     90define(`PROC_USTRING_N', `DBG(`$0($*)') DONE(`$1')`'PROC_STRING_N_EX(`dst->$1', `src->$1', `src->$2', `$1', `UChar')') 
    9091 
    9192define(`PROC_STRING_L', `DBG(`$0($*)') PROC_STRING_N(`$1', `$2 + 1')') 
     93define(`PROC_USTRING_L', `DBG(`$0($*)') PROC_USTRING_N(`$1', `$2 + 1')') 
    9294define(`PROC_STRING',   `DBG(`$0($*)') DONE(`$1')`'PROC_STRING_N_EX(`dst->$1', `src->$1', `strlen(src->$1) + 1', `$1', `char')') 
     95define(`PROC_USTRING',  `DBG(`$0($*)') DONE(`$1')`'PROC_STRING_N_EX(`dst->$1', `src->$1', `strlen(src->$1) + 1', `$1', `UChar')') 
    9396 
    9497dnl {{{ PROC_ZSTRING_N(1:type, 2:name, 3:size, 4:size_type) 
  • trunk/processor/struct.m4

    r534 r662  
    165165') 
    166166dnl }}} 
    167 dnl {{{ STRUCT_ARRAY_I(1:count, 2:type, 3:elm, 4:name=type) 
    168 define(`STRUCT_ARRAY_I', ` 
    169 pushdef(`i', `ii') 
    170 STRUCT_ARRAY(`$1', `$2', `$3', `$4') 
    171 popdef(`i') 
    172 ') 
    173 dnl }}} 
    174 dnl {{{ STRUCT_ARRAY(1:count, 2:type, 3:elm, 4:name=type) 
     167dnl {{{ STRUCT_ARRAY(1:count, 2:type, 3:elm, 4:name=type, 5:loopcounter) 
    175168define(`STRUCT_ARRAY', ` 
    176169    if (src->$3) { 
     170        ifelse( 
     171            `$5', `', `int i; pushdef(`LOOPCOUNTER', `i')', 
     172            `', `', `pushdef(`LOOPCOUNTER', `$5')') 
    177173        pushdefFUNC_NAME(`$2', `$4') 
    178174        IFDASM(` 
     
    180176            ALLOC_INIT_ZVAL(arr); 
    181177            array_init(arr); 
    182             for (i = 0; i < src->$1; i ++) { 
     178            for (LOOPCOUNTER = 0; LOOPCOUNTER < src->$1; LOOPCOUNTER ++) { 
    183179                zval *zv; 
    184180 
    185181                ALLOC_INIT_ZVAL(zv); 
    186182                array_init(zv); 
    187                 FUNC_NAME (zv, &(src->$3[i]) TSRMLS_CC); 
     183                FUNC_NAME (zv, &(src->$3[LOOPCOUNTER]) TSRMLS_CC); 
    188184                add_next_index_zval(arr, zv); 
    189185            } 
     
    192188            ALLOC(`dst->$3', `$2', `src->$1') 
    193189            ifdef(`AFTER_ALLOC', AFTER_ALLOC) 
    194             for (i = 0; i < src->$1; i ++) { 
     190            for (LOOPCOUNTER = 0; LOOPCOUNTER < src->$1; LOOPCOUNTER ++) { 
    195191                DISABLECHECK(` 
    196                     ifdef(`BEFORE_LOOP', `BEFORE_LOOP') 
    197                     STRUCT(`$2', `$3[i]', `$4') 
     192                    STRUCT(`$2', `$3[LOOPCOUNTER]', `$4') 
    198193                ') 
    199194            } 
     
    201196        DONE(`$3') 
    202197        popdef(`FUNC_NAME') 
     198        popdef(`LOOPCOUNTER') 
    203199    } 
    204200    else { 
  • trunk/utils.h

    r640 r662  
    3838 
    3939#   define IFDEBUG(x) do { } while (0) 
    40 #   ifndef NDEBUG 
    41 #       define NDEBUG 
    42 #   endif 
    4340#endif /* XCACHE_DEBUG */ 
    4441#include <assert.h> 
     
    132129void xc_copy_internal_zend_constants(HashTable *target, HashTable *source); 
    133130#endif 
     131 
     132typedef struct { 
     133    zend_uint size; 
     134    zend_uint cnt; 
     135    void *data; 
     136} xc_vector_t; 
     137 
     138#define xc_vector_init(type, vector) do { \ 
     139    (vector)->cnt = 0;     \ 
     140    (vector)->size = 0;    \ 
     141    (vector)->data = NULL; \ 
     142} while (0) 
     143 
     144#define xc_vector_add(type, vector, value) do { \ 
     145    if ((vector)->cnt == (vector)->size) { \ 
     146        if ((vector)->size) { \ 
     147            (vector)->size <<= 1; \ 
     148            (vector)->data = erealloc((vector)->data, sizeof(type) * (vector)->size); \ 
     149        } \ 
     150        else { \ 
     151            (vector)->size = 8; \ 
     152            (vector)->data = emalloc(sizeof(type) * (vector)->size); \ 
     153        } \ 
     154    } \ 
     155    ((type *) (vector)->data)[(vector)->cnt++] = value; \ 
     156} while (0) 
     157 
     158static inline void *xc_vector_detach_impl(xc_vector_t *vector) 
     159{ 
     160    void *data = vector->data; 
     161    vector->data = NULL; 
     162    vector->size = 0; 
     163    vector->cnt = 0; 
     164    return data; 
     165} 
     166 
     167#define xc_vector_detach(type, vector) ((type *) xc_vector_detach_impl(vector)) 
     168 
     169static inline void xc_vector_free_impl(xc_vector_t *vector TSRMLS_DC) 
     170{ 
     171    if (vector->data) { 
     172        efree(vector->data); 
     173    } 
     174    vector->size = 0; 
     175    vector->cnt = 0; 
     176} 
     177 
     178#define xc_vector_free(type, vector) xc_vector_free_impl(vector TSRMLS_CC) 
     179 
  • trunk/xcache.c

    r661 r662  
    3737#include "opcode_spec.h" 
    3838#include "utils.h" 
     39 
     40#ifndef ZEND_ENGINE_2_3 
     41ZEND_API size_t zend_dirname(char *path, size_t len) 
     42{ 
     43    php_dirname(path, len); 
     44    return strlen(path); 
     45} 
     46#endif 
    3947 
    4048#define VAR_ENTRY_EXPIRED(pentry) ((pentry)->ttl && XG(request_time) > pentry->ctime + (pentry)->ttl) 
     
    10051013    { 
    10061014        /* hash on filename, let's expand it to real path */ 
     1015        /* FIXME */ 
    10071016        filename = expand_filepath(filename, opened_path_buffer TSRMLS_CC); 
    10081017        if (filename == NULL) { 
     
    11081117/* }}} */ 
    11091118#endif 
     1119 
     1120/* {{{ Constant Usage */ 
     1121#define xcache_op1_is_file 1 
     1122#define xcache_op1_is_dir  2 
     1123#define xcache_op2_is_file 4 
     1124#define xcache_op2_is_dir  8 
     1125typedef struct { 
     1126    zend_bool filepath_used; 
     1127    zend_bool dirpath_used; 
     1128    zend_bool ufilepath_used; 
     1129    zend_bool udirpath_used; 
     1130} xc_const_usage_t; 
     1131/* }}} */ 
     1132static void xc_collect_op_array_info(xc_entry_data_php_t *php, xc_const_usage_t *usage, xc_op_array_info_t *op_array_info, zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
     1133{ 
     1134    int oplineno; 
     1135    xc_vector_t vector_int; 
     1136 
     1137    xc_vector_init(int, &vector_int); 
     1138 
     1139#define XCACHE_CHECK_OP(type, op) \ 
     1140    if (zend_binary_strcmp(Z_STRVAL(opline->op.u.constant), Z_STRLEN(opline->op.u.constant), php->type##path, php->type##path_len) == 0) { \ 
     1141        usage->type##path_used = 1; \ 
     1142        oplineinfo |= xcache_##op##_is_##type; \ 
     1143    } 
     1144 
     1145#define XCACHE_U_CHECK_OP(type, op) \ 
     1146    if (zend_u_##binary_strcmp(Z_USTRVAL(opline->op.u.constant), Z_USTRLEN(opline->op.u.constant), php->u##type##path, php->u##type##path_len) == 0) { \ 
     1147        usage->u##type##path_used = 1; \ 
     1148        oplineinfo |= xcache_##op##_is_##type; \ 
     1149    } 
     1150 
     1151    for (oplineno = 0; oplineno < op_array->last; oplineno++) { 
     1152        zend_op *opline = &op_array->opcodes[oplineno]; 
     1153        int oplineinfo = 0; 
     1154        if (opline->op1.op_type == IS_CONST) { 
     1155            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1156                XCACHE_CHECK_OP(file, op1) 
     1157                else XCACHE_CHECK_OP(dir, op1) 
     1158            } 
     1159 
     1160#ifdef IS_UNICODE 
     1161            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1162                XCACHE_U_CHECK_OP(file, op1) 
     1163                else XCACHE_U_CHECK_OP(dir, op1) 
     1164            } 
     1165#endif 
     1166        } 
     1167        if (opline->op2.op_type == IS_CONST) { 
     1168            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1169                XCACHE_CHECK_OP(file, op2) 
     1170                else XCACHE_CHECK_OP(dir, op2) 
     1171            } 
     1172 
     1173#ifdef IS_UNICODE 
     1174            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1175                XCACHE_U_CHECK_OP(file, op2) 
     1176                else XCACHE_U_CHECK_OP(dir, op2) 
     1177            } 
     1178#endif 
     1179        } 
     1180        if (oplineinfo) { 
     1181            xc_vector_add(int, &vector_int, oplineno); 
     1182            xc_vector_add(int, &vector_int, oplineinfo); 
     1183        } 
     1184    } 
     1185 
     1186    op_array_info->oplineinfo_cnt = vector_int.cnt; 
     1187    op_array_info->oplineinfos    = xc_vector_detach(int, &vector_int); 
     1188    xc_vector_free(int, &vector_int); 
     1189} 
     1190/* }}} */ 
     1191void xc_fix_op_array_info(const xc_entry_data_php_t *php, zend_op_array *op_array, int copy, const xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */ 
     1192{ 
     1193    int i; 
     1194    if (!op_array_info->oplineinfo_cnt) { 
     1195        return; 
     1196    } 
     1197 
     1198    for (i = 0; i < op_array_info->oplineinfo_cnt; i += 2) { 
     1199        int oplineno = op_array_info->oplineinfos[i]; 
     1200        int oplineinfo = op_array_info->oplineinfos[i + 1]; 
     1201        zend_op *opline = &op_array->opcodes[oplineno]; 
     1202        if ((oplineinfo & xcache_op1_is_file)) { 
     1203            assert(opline->op1.op_type == IS_CONST); 
     1204            if (copy) { 
     1205                efree(Z_STRVAL(opline->op1.u.constant)); 
     1206            } 
     1207            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1208                assert(php->filepath); 
     1209                ZVAL_STRINGL(&opline->op1.u.constant, php->filepath, php->filepath_len, copy); 
     1210            } 
     1211#ifdef IS_UNICODE 
     1212            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1213                assert(php->ufilepath); 
     1214                ZVAL_UNICODEL(&opline->op1.u.constant, php->ufilepath, php->ufilepath_len, copy); 
     1215            } 
     1216#endif 
     1217            else { 
     1218                assert(0); 
     1219            } 
     1220        } 
     1221        else if ((oplineinfo & xcache_op1_is_dir)) { 
     1222            assert(opline->op1.op_type == IS_CONST); 
     1223            if (copy) { 
     1224                efree(Z_STRVAL(opline->op1.u.constant)); 
     1225            } 
     1226            if (Z_TYPE(opline->op1.u.constant) == IS_STRING) { 
     1227                assert(php->dirpath); 
     1228                ZVAL_STRINGL(&opline->op1.u.constant, php->dirpath, php->dirpath_len, copy); 
     1229            } 
     1230#ifdef IS_UNICODE 
     1231            else if (Z_TYPE(opline->op1.u.constant) == IS_UNICODE) { 
     1232                assert(!php->udirpath); 
     1233                ZVAL_UNICODEL(&opline->op1.u.constant, php->udirpath, php->udirpath_len, copy); 
     1234            } 
     1235#endif 
     1236            else { 
     1237                assert(0); 
     1238            } 
     1239        } 
     1240 
     1241        if ((oplineinfo & xcache_op2_is_file)) { 
     1242            assert(opline->op2.op_type == IS_CONST); 
     1243            if (copy) { 
     1244                efree(Z_STRVAL(opline->op2.u.constant)); 
     1245            } 
     1246            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1247                assert(php->filepath); 
     1248                ZVAL_STRINGL(&opline->op2.u.constant, php->filepath, php->filepath_len, copy); 
     1249            } 
     1250#ifdef IS_UNICODE 
     1251            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1252                assert(php->ufilepath); 
     1253                ZVAL_UNICODEL(&opline->op2.u.constant, php->ufilepath, php->ufilepath_len, copy); 
     1254            } 
     1255#endif 
     1256            else { 
     1257                assert(0); 
     1258            } 
     1259        } 
     1260        else if ((oplineinfo & xcache_op2_is_dir)) { 
     1261            assert(opline->op2.op_type == IS_CONST); 
     1262            if (copy) { 
     1263                efree(Z_STRVAL(opline->op2.u.constant)); 
     1264            } 
     1265            if (Z_TYPE(opline->op2.u.constant) == IS_STRING) { 
     1266                assert(!php->dirpath); 
     1267                ZVAL_STRINGL(&opline->op2.u.constant, php->dirpath, php->dirpath_len, copy); 
     1268            } 
     1269#ifdef IS_UNICODE 
     1270            else if (Z_TYPE(opline->op2.u.constant) == IS_UNICODE) { 
     1271                assert(!php->udirpath); 
     1272                ZVAL_UNICODEL(&opline->op2.u.constant, php->udirpath, php->udirpath_len, copy); 
     1273            } 
     1274#endif 
     1275            else { 
     1276                assert(0); 
     1277            } 
     1278        } 
     1279    } 
     1280} 
     1281/* }}} */ 
     1282static void xc_free_op_array_info(xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */ 
     1283{ 
     1284    if (op_array_info->oplineinfos) { 
     1285        efree(op_array_info->oplineinfos); 
     1286    } 
     1287} 
     1288/* }}} */ 
    11101289static void xc_free_php(xc_entry_data_php_t *php TSRMLS_DC) /* {{{ */ 
    11111290{ 
     1291    int i; 
     1292    if (php->classinfos) { 
     1293        for (i = 0; i < php->classinfo_cnt; i ++) { 
     1294            xc_classinfo_t *classinfo = &php->classinfos[i]; 
     1295            int j; 
     1296            for (j = 0; j < classinfo->methodinfo_cnt; j ++) { 
     1297                xc_free_op_array_info(&classinfo->methodinfos[j] TSRMLS_CC); 
     1298            } 
     1299 
     1300            if (classinfo->methodinfos) { 
     1301                efree(classinfo->methodinfos); 
     1302            } 
     1303        } 
     1304    } 
     1305    if (php->funcinfos) { 
     1306        for (i = 0; i < php->funcinfo_cnt; i ++) { 
     1307            xc_free_op_array_info(&php->funcinfos[i].op_array_info TSRMLS_CC); 
     1308        } 
     1309    } 
     1310    xc_free_op_array_info(&php->op_array_info TSRMLS_CC); 
     1311 
    11121312#define X_FREE(var) do {\ 
    11131313    if (php->var) { \ 
     
    11161316} while (0) 
    11171317 
     1318    X_FREE(dirpath); 
     1319#ifdef IS_UNICODE 
     1320    X_FREE(ufilepath); 
     1321    X_FREE(udirpath); 
     1322#endif 
     1323 
    11181324#ifdef ZEND_ENGINE_2_1 
    11191325    X_FREE(autoglobals); 
     
    11321338    int old_constinfo_cnt, old_funcinfo_cnt, old_classinfo_cnt; 
    11331339    zend_bool catched = 0; 
     1340    xc_const_usage_t const_usage; 
    11341341 
    11351342    /* {{{ compile */ 
     
    11621369    /* }}} */ 
    11631370    /* {{{ prepare */ 
     1371    zend_restore_compiled_filename(h->opened_path ? h->opened_path : h->filename TSRMLS_CC); 
    11641372    php->op_array      = op_array; 
    11651373 
     
    12061414#endif 
    12071415#undef X_ALLOC 
     1416    /* }}} */ 
     1417 
     1418    /* {{{ file/dir path init */ 
     1419    memset(&const_usage, 0, sizeof(const_usage)); 
     1420    php->filepath     = zend_get_compiled_filename(TSRMLS_C); 
     1421    php->filepath_len = strlen(php->filepath); 
     1422    php->dirpath      = estrndup(php->filepath, php->filepath_len); 
     1423    php->dirpath_len  = zend_dirname(php->dirpath, php->filepath_len); 
     1424#ifdef IS_UNICODE 
     1425    zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &php->ufilepath, &php->ufilepath_len, php->filepath, php->filepath_len TSRMLS_CC); 
     1426    zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &php->udirpath,  &php->udirpath_len,  php->dirpath,  php->dirpath_len TSRMLS_CC); 
     1427#endif 
    12081428    /* }}} */ 
    12091429    /* {{{ shallow copy, pointers only */ { 
     
    12421462        b = CG(class_table)->pListHead;    COPY_H(xc_classinfo_t, classinfos, classinfo_cnt, cest,     xc_cest_t); 
    12431463 
     1464        for (i = 0; i < php->classinfo_cnt; i ++) { 
     1465            xc_classinfo_t *classinfo = &php->classinfos[i]; 
     1466            zend_class_entry *ce = CestToCePtr(classinfo->cest); 
     1467            classinfo->methodinfo_cnt = ce->function_table.nTableSize; 
     1468            if (classinfo->methodinfo_cnt) { 
     1469                int j; 
     1470 
     1471                ECALLOC_N(classinfo->methodinfos, classinfo->methodinfo_cnt); 
     1472                if (!classinfo->methodinfos) { 
     1473                    goto err_alloc; 
     1474                } 
     1475 
     1476                for (j = 0, b = ce->function_table.pListHead; b; j ++, b = b->pListNext) { 
     1477                    xc_collect_op_array_info(php, &const_usage, &classinfo->methodinfos[j], (zend_op_array *) b->pData TSRMLS_CC); 
     1478                } 
     1479            } 
     1480            else { 
     1481                classinfo->methodinfos = NULL; 
     1482            } 
     1483        } 
     1484 
     1485        for (i = 0; i < php->funcinfo_cnt; i ++) { 
     1486            xc_collect_op_array_info(php, &const_usage, &php->funcinfos[i].op_array_info, (zend_op_array *) &php->funcinfos[i].func TSRMLS_CC); 
     1487        } 
     1488 
     1489        xc_collect_op_array_info(php, &const_usage, &php->op_array_info, php->op_array TSRMLS_CC); 
     1490 
    12441491#undef COPY_H 
    12451492 
     
    12711518    } 
    12721519    /* }}} */ 
     1520    /* {{{ file/dir path free unused */ 
     1521#define X_FREE_UNUSED(var) \ 
     1522    if (!const_usage.var##path_used) { \ 
     1523        efree(php->var##path); \ 
     1524        php->var##path = NULL; \ 
     1525        php->var##path_len = 0; \ 
     1526    } 
     1527    if (!const_usage.filepath_used) { 
     1528        php->filepath = NULL; 
     1529        php->filepath_len = 0; 
     1530    } 
     1531    X_FREE_UNUSED(dir) 
     1532#ifdef IS_UNICODE 
     1533    X_FREE_UNUSED(ufile) 
     1534    X_FREE_UNUSED(udir) 
     1535#endif 
     1536#undef X_FREE_UNUSED 
     1537    /* }}} */ 
    12731538#ifdef E_STRICT 
    12741539    php->compilererrors = ((xc_sandbox_t *) XG(sandbox))->compilererrors; 
     
    14671732        php.autoglobals = NULL; 
    14681733#endif 
     1734        memset(&php.op_array_info, 0, sizeof(php.op_array_info)); 
     1735 
    14691736        zend_try { 
    14701737            op_array = xc_compile_php(&php, h, type TSRMLS_CC); 
     
    16381905/* }}} */ 
    16391906 
    1640 #ifdef ZEND_ENGINE_2 
    1641 /* {{{ xc_gc_op_array_t */ 
    1642 typedef struct { 
    1643     zend_uint num_args; 
    1644     zend_arg_info *arg_info; 
    1645 } xc_gc_op_array_t; 
    1646 /* }}} */ 
    1647 void xc_gc_add_op_array(zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
    1648 { 
    1649     xc_gc_op_array_t gc_op_array; 
    1650     gc_op_array.num_args = op_array->num_args; 
    1651     gc_op_array.arg_info = op_array->arg_info; 
    1652 #ifdef ZEND_ENGINE_2 
    1653     zend_llist_add_element(&XG(gc_op_arrays), (void *) &gc_op_array); 
    1654 #endif 
     1907void xc_gc_add_op_array(xc_gc_op_array_t *gc_op_array TSRMLS_DC) /* {{{ */ 
     1908{ 
     1909    zend_llist_add_element(&XG(gc_op_arrays), (void *) gc_op_array); 
    16551910} 
    16561911/* }}} */ 
     
    16591914    xc_gc_op_array_t *op_array = (xc_gc_op_array_t *) pDest; 
    16601915    zend_uint i; 
     1916#ifdef ZEND_ENGINE_2 
    16611917    if (op_array->arg_info) { 
    16621918        for (i = 0; i < op_array->num_args; i++) { 
     
    16681924        efree(op_array->arg_info); 
    16691925    } 
    1670 } 
    1671 /* }}} */ 
    1672 #endif 
     1926#endif 
     1927    if (op_array->opcodes) { 
     1928        efree(op_array->opcodes); 
     1929    } 
     1930} 
     1931/* }}} */ 
    16731932 
    16741933/* module helper function */ 
  • trunk/xcache.h

    r659 r662  
    6262#ifndef IS_CONSTANT_TYPE_MASK 
    6363#   define IS_CONSTANT_TYPE_MASK (~IS_CONSTANT_INDEX) 
     64#endif 
     65 
     66#ifndef ZEND_ENGINE_2_3 
     67#define zend_dirname(path, len) xc_dirname(path, len) 
    6468#endif 
    6569 
     
    238242} xc_cache_t; 
    239243/* }}} */ 
     244/* {{{ xc_op_array_info_t */ 
     245typedef struct { 
     246    zend_uint oplineinfo_cnt; 
     247    int *oplineinfos; 
     248} xc_op_array_info_t; 
     249/* }}} */ 
    240250/* {{{ xc_classinfo_t */ 
    241251typedef struct { 
     
    246256    zend_uint key_size; 
    247257    ulong     h; 
     258    zend_uint methodinfo_cnt; 
     259    xc_op_array_info_t *methodinfos; 
    248260    xc_cest_t cest; 
    249261#ifndef ZEND_COMPILE_DELAYED_BINDING 
     
    273285    zend_uint key_size; 
    274286    ulong     h; 
     287    xc_op_array_info_t op_array_info; 
    275288    zend_function func; 
    276289} xc_funcinfo_t; 
     
    311324    size_t     size; 
    312325 
     326    int    filepath_len; 
     327    char  *filepath; 
     328    int    dirpath_len; 
     329    char  *dirpath; 
     330#ifdef IS_UNICODE 
     331    UChar *ufilepath; 
     332    int    ufilepath_len; 
     333    UChar *udirpath; 
     334    int    udirpath_len; 
     335#endif 
     336 
     337    xc_op_array_info_t op_array_info; 
    313338    zend_op_array *op_array; 
    314339 
     
    387412int xc_is_ro(const void *p); 
    388413int xc_is_shm(const void *p); 
    389 void xc_gc_add_op_array(zend_op_array *op_array TSRMLS_DC); 
     414/* {{{ xc_gc_op_array_t */ 
     415typedef struct { 
     416#ifdef ZEND_ENGINE_2 
     417    zend_uint num_args; 
     418    zend_arg_info *arg_info; 
     419#endif 
     420    zend_uint last; 
     421    zend_op *opcodes; 
     422} xc_gc_op_array_t; 
     423/* }}} */ 
     424void xc_gc_add_op_array(xc_gc_op_array_t *gc_op_array TSRMLS_DC); 
     425void xc_fix_op_array_info(const xc_entry_data_php_t *php, zend_op_array *op_array, int shallow_copied, const xc_op_array_info_t *op_array_info TSRMLS_DC); 
    390426 
    391427#endif /* __XCACHE_H */ 
  • trunk/xcache_globals.h

    r656 r662  
    1818    long   var_ttl; 
    1919 
    20 #ifdef ZEND_ENGINE_2 
    2120    zend_llist gc_op_arrays; 
    22 #endif 
    2321 
    2422#ifdef HAVE_XCACHE_CONSTANT 
Note: See TracChangeset for help on using the changeset viewer.