Changeset 662 in svn for trunk/xcache.c


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

back patch __FILE and __DIR on cache restore

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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 */
Note: See TracChangeset for help on using the changeset viewer.