Changeset 46d274f in git


Ignore:
Timestamp:
2014-09-12T04:27:41Z (3 years ago)
Author:
Xuefer <xuefer@…>
Branches:
master, trunk
Children:
499e70e
Parents:
70ad55b
Message:

adds class const support for __FILE__ __DIR__

git-svn-id: svn://svn.lighttpd.net/xcache/trunk@1530 c26eb9a1-5813-0410-bd6c-c2e55f420ca7

Files:
6 edited

Legend:

Unmodified
Added
Removed
  • ChangeLog

    r97bec7a r46d274f  
    1010   * (WIP) defragment
    1111   * (WIP) cache to disk
     12   * added class const support for __FILE__ __DIR__
    1213 * disassembler, decompiler:
    1314   * PHP_5_6 support
  • NEWS

    r97bec7a r46d274f  
    33 * api updates
    44 * cache defragment, cache to disk
     5 * added class const support for __FILE__ __DIR__
     6 * updated disassembler decompiler support
    57
    683.2.1 2013-??-??
  • lib/Decompiler.class.php

    r71137b9 r46d274f  
    587587    var $namespaceDecided;
    588588    var $activeFile;
     589    var $activeDir;
    589590    var $activeClass;
    590591    var $activeMethod;
     
    15171518            $EX['value2constant'][$this->activeFile] = '__FILE__';
    15181519        }
     1520        if (isset($this->activeDir)) {
     1521            $EX['value2constant'][$this->activeDir] = '__DIR__';
     1522        }
    15191523        if (isset($this->activeClass)) {
    15201524            $EX['value2constant'][$this->activeClass] = '__CLASS__';
     
    27922796        }
    27932797        $this->activeFile = null;
     2798        $this->activeDir = null;
    27942799        return true;
    27952800    }
     
    28032808        }
    28042809        $this->activeFile = realpath($file);
     2810        if (ZEND_ENGINE_2_3) {
     2811            $this->activeDir = dirname($this->activeFile);
     2812        }
    28052813        return true;
    28062814    }
     
    28102818        $this->dc = $content;
    28112819        $this->activeFile = null;
     2820        $this->activeDir = null;
    28122821        return true;
    28132822    }
  • mod_cacher/xc_cache.h

    rbe1ba47 r46d274f  
    1717struct _xc_lock_t;
    1818struct _xc_shm_t;
    19 /* {{{ xc_op_array_info_detail_t */
     19/* {{{ xc_constant_info_t */
    2020typedef struct {
    2121    zend_uint index;
    2222    zend_uint info;
    23 } xc_op_array_info_detail_t;
     23} xc_constant_info_t;
    2424/* }}} */
    2525/* {{{ xc_op_array_info_t */
    2626typedef struct {
    27 #ifdef ZEND_ENGINE_2_4
    28     zend_uint literalinfo_cnt;
    29     xc_op_array_info_detail_t *literalinfos;
    30 #else
    31     zend_uint oplineinfo_cnt;
    32     xc_op_array_info_detail_t *oplineinfos;
    33 #endif
     27    zend_uint           constantinfo_cnt;
     28    xc_constant_info_t *constantinfos;
    3429} xc_op_array_info_t;
    3530/* }}} */
     
    4439    zend_uint           methodinfo_cnt;
    4540    xc_op_array_info_t *methodinfos;
     41#ifdef ZEND_ENGINE_2
     42    zend_uint           constantinfo_cnt;
     43    xc_constant_info_t *constantinfos;
     44#endif
    4645    xc_cest_t           cest;
    4746#ifndef ZEND_COMPILE_DELAYED_BINDING
     
    149148
    150149typedef struct {
     150    char  *str;
     151    size_t len;
     152} xc_constant_string_t;
     153
     154#ifdef IS_UNICODE
     155typedef struct {
     156    UChar  *str;
     157    size_t len;
     158} xc_constant_u_string_t;
     159#endif
     160
     161typedef struct {
    151162    xc_entry_t entry;
    152163    xc_entry_data_php_t *php;
     
    158169    size_t file_inode;
    159170
    160     size_t filepath_len;
    161     ZEND_24(NOTHING, const) char *filepath;
     171    xc_constant_string_t filepath;
    162172#ifdef ZEND_ENGINE_2_3
    163     size_t dirpath_len;
    164     char  *dirpath;
    165 #endif
    166 #ifdef IS_UNICODE
    167     int    ufilepath_len;
    168     UChar *ufilepath;
    169 #   ifdef ZEND_ENGINE_2_3
    170     int    udirpath_len;
    171     UChar *udirpath;
    172 #   endif
     173    xc_constant_string_t dirpath;
     174#endif
     175#ifdef IS_UNICODE
     176    xc_constant_u_string_t u_filepath;
     177    xc_constant_u_string_t u_dirpath;
    173178#endif
    174179} xc_entry_php_t;
     
    205210/* }}} */
    206211void xc_gc_add_op_array(xc_gc_op_array_t *gc_op_array TSRMLS_DC);
    207 void xc_fix_op_array_info(const xc_entry_php_t *xce, const xc_entry_data_php_t *php, zend_op_array *op_array, int shallow_copy, const xc_op_array_info_t *op_array_info TSRMLS_DC);
     212#ifdef ZEND_ENGINE_2
     213void xc_fix_class_info(const xc_entry_php_t *entry_php, xc_classinfo_t *classinfo, int shallow_copy TSRMLS_DC);
     214#endif
     215void xc_fix_op_array_info(const xc_entry_php_t *xce, zend_op_array *op_array, int shallow_copy, const xc_op_array_info_t *op_array_info TSRMLS_DC);
    208216
    209217#endif /* XC_CACHE_H_684B099102B4651FB10058EF6F7E80CE */
  • mod_cacher/xc_cacher.c

    r21a895a r46d274f  
    1 #if 0
     1#if 1
    22#define XCACHE_DEBUG
    33#endif
     
    943943} while (0)
    944944#ifdef ZEND_ENGINE_2_3
    945     X_FREE(dirpath);
     945    X_FREE(dirpath.str);
    946946#endif
    947947#ifdef IS_UNICODE
    948     X_FREE(ufilepath);
     948    X_FREE(u_filepath.str);
    949949#   ifdef ZEND_ENGINE_2_3
    950     X_FREE(udirpath);
     950    X_FREE(u_dirpath.str);
    951951#   endif
    952952#endif
     
    12701270    }
    12711271
    1272     compiler->new_entry.filepath  = NULL;
     1272    compiler->new_entry.filepath.str   = NULL;
    12731273#ifdef ZEND_ENGINE_2_3
    1274     compiler->new_entry.dirpath   = NULL;
     1274    compiler->new_entry.dirpath.str    = NULL;
    12751275#endif
    12761276#ifdef IS_UNICODE
    1277     compiler->new_entry.ufilepath = NULL;
    1278 #   ifdef ZEND_ENGINE_2_3
    1279     compiler->new_entry.udirpath  = NULL;
    1280 #   endif
     1277    compiler->new_entry.u_filepath.str = NULL;
     1278    compiler->new_entry.u_dirpath.str  = NULL;
    12811279#endif
    12821280
     
    13311329static void xc_entry_php_init(xc_entry_php_t *entry_php, const char *filepath TSRMLS_DC) /* {{{*/
    13321330{
    1333     entry_php->filepath    = ZEND_24((char *), NOTHING) filepath;
    1334     entry_php->filepath_len = strlen(entry_php->filepath);
     1331    entry_php->filepath.str = ZEND_24((char *), NOTHING) filepath;
     1332    entry_php->filepath.len = strlen(entry_php->filepath.str);
    13351333#ifdef ZEND_ENGINE_2_3
    1336     entry_php->dirpath      = estrndup(entry_php->filepath, entry_php->filepath_len);
    1337     entry_php->dirpath_len  = zend_dirname(entry_php->dirpath, entry_php->filepath_len);
     1334    entry_php->dirpath.str  = estrndup(entry_php->filepath.str, entry_php->filepath.len);
     1335    entry_php->dirpath.len  = zend_dirname(entry_php->dirpath.str, entry_php->filepath.len);
    13381336#endif
    13391337#ifdef IS_UNICODE
    1340     zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &entry_php->ufilepath, &entry_php->ufilepath_len, entry_php->filepath, entry_php->filepath_len TSRMLS_CC);
    1341 #   ifdef ZEND_ENGINE_2_3
    1342     zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &entry_php->udirpath,  &entry_php->udirpath_len,  entry_php->dirpath,  entry_php->dirpath_len TSRMLS_CC);
    1343 #   endif
     1338    zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &entry_php->u_filepath.str, &entry_php->u_filepath.len, entry_php->filepath.str, entry_php->filepath.len TSRMLS_CC);
     1339    zend_string_to_unicode(ZEND_U_CONVERTER(UG(runtime_encoding_conv)), &entry_php->u_dirpath.str,  &entry_php->u_dirpath.len,  entry_php->dirpath.str,  entry_php->dirpath.len TSRMLS_CC);
    13441340#endif
    13451341}
     
    13771373
    13781374/* {{{ Constant Usage */
    1379 #ifdef ZEND_ENGINE_2_4
    1380 #   define xcache_literal_is_file 1
    1381 #   define xcache_literal_is_dir  2
    1382 #else
    1383 #   define xcache_op1_is_file 1
    1384 #   define xcache_op2_is_file 2
    1385 #   ifdef ZEND_ENGINE_2_3
    1386 #       define xcache_op1_is_dir  4
    1387 #       define xcache_op2_is_dir  8
    1388 #   endif
    1389 #endif
     1375#define xcache_constant_is_file    1
     1376#ifdef ZEND_ENGINE_2_3
     1377#   define xcache_constant_is_dir  2
     1378#endif
     1379#define xcache_constant_info_mask  0x0F
     1380#define xcache_constant_info_shift 4
    13901381typedef struct {
    13911382    zend_bool filepath_used;
     
    13941385#endif
    13951386#ifdef IS_UNICODE
    1396     zend_bool ufilepath_used;
     1387    zend_bool u_filepath_used;
    13971388#   ifdef ZEND_ENGINE_2_3
    1398     zend_bool udirpath_used;
     1389    zend_bool u_dirpath_used;
    13991390#   endif
    14001391#endif
    14011392} xc_const_usage_t;
    1402 /* }}} */
     1393
     1394#define XCACHE_ANALYZE_CONSTANT(type, u_, shift) \
     1395    if (zend_##u_##binary_strcmp(Z_STRVAL_P(constant), Z_STRLEN_P(constant), compiler->new_entry.u_##type##path.str, compiler->new_entry.u_##type##path.len) == 0) { \
     1396        usage->u_##type##path_used = 1; \
     1397        constantinfo |= xcache_constant_is_##type << (shift * xcache_constant_info_shift); \
     1398        TRACE("found %s constant %s", #type, Z_STRVAL_P(constant)); \
     1399    }
     1400
     1401/* }}} */
     1402#ifdef ZEND_ENGINE_2
     1403static void xc_collect_class_constant_info(xc_compiler_t *compiler, xc_const_usage_t *usage, xc_classinfo_t *classinfo, HashTable *constants TSRMLS_DC) /* {{{ */
     1404{
     1405    zend_uint count = 0;
     1406    uint index;
     1407    xc_vector_t constantinfos;
     1408
     1409    xc_vector_init(xc_constant_info_t, &constantinfos);
     1410
     1411    for (index = 0; index < constants->nTableSize; ++index) {
     1412        Bucket *bucket;
     1413        zend_uint index2 = 0;
     1414
     1415        for (bucket = constants->arBuckets[index]; bucket; bucket = bucket->pNext, ++index2) {
     1416            zval *constant = *(zval **) bucket->pData;
     1417            zend_uint constantinfo = 0;
     1418
     1419            assert(constant);
     1420
     1421            if ((Z_TYPE_P(constant) & IS_CONSTANT_TYPE_MASK) == IS_STRING) {
     1422                XCACHE_ANALYZE_CONSTANT(file, , 0)
     1423                else XCACHE_ANALYZE_CONSTANT(dir, , 0)
     1424            }
     1425#   ifdef IS_UNICODE
     1426            else if ((Z_TYPE_P(constant) & IS_CONSTANT_TYPE_MASK) == IS_UNICODE) {
     1427                XCACHE_ANALYZE_CONSTANT(file, u_, 0)
     1428                else XCACHE_ANALYZE_CONSTANT(dir, u_, 0)
     1429            }
     1430#   endif
     1431
     1432            if (constantinfo) {
     1433                xc_constant_info_t detail;
     1434                detail.index = index2 * constants->nTableSize + index;
     1435                detail.info  = constantinfo;
     1436                xc_vector_add(xc_constant_info_t, &constantinfos, detail);
     1437            }
     1438        }
     1439    }
     1440
     1441    classinfo->constantinfo_cnt = constantinfos.cnt;
     1442    classinfo->constantinfos    = xc_vector_detach(xc_constant_info_t, &constantinfos);
     1443}
     1444/* }}} */
     1445#endif
    14031446static void xc_collect_op_array_info(xc_compiler_t *compiler, xc_const_usage_t *usage, xc_op_array_info_t *op_array_info, zend_op_array *op_array TSRMLS_DC) /* {{{ */
    14041447{
     
    14081451    zend_uint oplinenum;
    14091452#endif
    1410     xc_vector_t details;
    1411 
    1412     xc_vector_init(xc_op_array_info_detail_t, &details);
    1413 
    1414 #define XCACHE_ANALYZE_LITERAL(type) \
    1415     if (zend_binary_strcmp(Z_STRVAL(literal->constant), Z_STRLEN(literal->constant), compiler->new_entry.type##path, compiler->new_entry.type##path_len) == 0) { \
    1416         usage->type##path_used = 1; \
    1417         literalinfo |= xcache_##literal##_is_##type; \
    1418     }
    1419 
    1420 #define XCACHE_U_ANALYZE_LITERAL(type) \
    1421     if (zend_u_##binary_strcmp(Z_USTRVAL(literal->constant), Z_USTRLEN(literal->constant), compiler->new_entry.u##type##path, compiler->new_entry.u##type##path_len) == 0) { \
    1422         usage->u##type##path_used = 1; \
    1423         literalinfo |= xcache_##literal##_is_##type; \
    1424     }
    1425 
    1426 #define XCACHE_ANALYZE_OP(type, op) \
    1427     if (zend_binary_strcmp(Z_STRVAL(Z_OP_CONSTANT(opline->op)), Z_STRLEN(Z_OP_CONSTANT(opline->op)), compiler->new_entry.type##path, compiler->new_entry.type##path_len) == 0) { \
    1428         usage->type##path_used = 1; \
    1429         oplineinfo |= xcache_##op##_is_##type; \
    1430     }
    1431 
    1432 #define XCACHE_U_ANALYZE_OP(type, op) \
    1433     if (zend_u_##binary_strcmp(Z_USTRVAL(Z_OP_CONSTANT(opline->op)), Z_USTRLEN(Z_OP_CONSTANT(opline->op)), compiler->new_entry.u##type##path, compiler->new_entry.u##type##path_len) == 0) { \
    1434         usage->u##type##path_used = 1; \
    1435         oplineinfo |= xcache_##op##_is_##type; \
    1436     }
     1453    xc_vector_t constantinfos;
     1454
     1455    xc_vector_init(xc_constant_info_t, &constantinfos);
    14371456
    14381457#ifdef ZEND_ENGINE_2_4
    14391458    for (literalindex = 0; literalindex < op_array->last_literal; literalindex++) {
    14401459        zend_literal *literal = &op_array->literals[literalindex];
    1441         zend_uint literalinfo = 0;
    1442         if (Z_TYPE(literal->constant) == IS_STRING) {
    1443             XCACHE_ANALYZE_LITERAL(file)
    1444             else XCACHE_ANALYZE_LITERAL(dir)
     1460        zval *constant = &literal->constant;
     1461        zend_uint constantinfo = 0;
     1462
     1463        if (Z_TYPE_P(constant) == IS_STRING) {
     1464            XCACHE_ANALYZE_CONSTANT(file, , 0)
     1465            else XCACHE_ANALYZE_CONSTANT(dir, , 0)
    14451466        }
    14461467#   ifdef IS_UNICODE
    1447         else if (Z_TYPE(literal->constant) == IS_UNICODE) {
    1448             XCACHE_U_ANALYZE_LITERAL(file)
    1449             else XCACHE_U_ANALYZE_LITERAL(dir)
     1468        else if (Z_TYPE_P(constant) == IS_UNICODE) {
     1469            XCACHE_ANALYZE_CONSTANT(file, u_, 0)
     1470            else XCACHE_ANALYZE_CONSTANT(dir, u_, 0)
    14501471        }
    14511472#   endif
    1452         if (literalinfo) {
    1453             xc_op_array_info_detail_t detail;
     1473
     1474        if (constantinfo) {
     1475            xc_constant_info_t detail;
    14541476            detail.index = literalindex;
    1455             detail.info  = literalinfo;
    1456             xc_vector_add(xc_op_array_info_detail_t, &details, detail);
    1457         }
    1458     }
    1459 
    1460     op_array_info->literalinfo_cnt = details.cnt;
    1461     op_array_info->literalinfos    = xc_vector_detach(xc_op_array_info_detail_t, &details);
     1477            detail.info  = constantinfo;
     1478            xc_vector_add(xc_constant_info_t, &constantinfos, detail);
     1479        }
     1480    }
     1481
     1482    op_array_info->constantinfo_cnt = constantinfos.cnt;
     1483    op_array_info->constantinfos    = xc_vector_detach(xc_constant_info_t, &constantinfos);
    14621484#else /* ZEND_ENGINE_2_4 */
    14631485    for (oplinenum = 0; oplinenum < op_array->last; oplinenum++) {
    14641486        zend_op *opline = &op_array->opcodes[oplinenum];
    1465         zend_uint oplineinfo = 0;
     1487        zend_uint constantinfo = 0;
     1488
    14661489        if (Z_OP_TYPE(opline->op1) == IS_CONST) {
    1467             if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) {
    1468                 XCACHE_ANALYZE_OP(file, op1)
     1490            zval *constant = &Z_OP_CONSTANT(opline->op1);
     1491            if (Z_TYPE_P(constant) == IS_STRING) {
     1492                XCACHE_ANALYZE_CONSTANT(file, , 0)
    14691493#   ifdef ZEND_ENGINE_2_3
    1470                 else XCACHE_ANALYZE_OP(dir, op1)
     1494                else XCACHE_ANALYZE_CONSTANT(dir, , 0)
    14711495#   endif
    14721496            }
    14731497#   ifdef IS_UNICODE
    1474             else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) {
    1475                 XCACHE_U_ANALYZE_OP(file, op1)
    1476 #       ifdef ZEND_ENGINE_2_3
    1477                 else XCACHE_U_ANALYZE_OP(dir, op1)
    1478 #       endif
     1498            else if (Z_TYPE_P(constant) == IS_UNICODE) {
     1499                XCACHE_ANALYZE_CONSTANT(file, u_, 0)
     1500                else XCACHE_ANALYZE_CONSTANT(dir, u_, 0)
    14791501            }
    14801502#   endif
     
    14821504
    14831505        if (Z_OP_TYPE(opline->op2) == IS_CONST) {
    1484             if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) {
    1485                 XCACHE_ANALYZE_OP(file, op2)
     1506            zval *constant = &Z_OP_CONSTANT(opline->op2);
     1507            if (Z_TYPE_P(constant) == IS_STRING) {
     1508                XCACHE_ANALYZE_CONSTANT(file, , 1)
    14861509#   ifdef ZEND_ENGINE_2_3
    1487                 else XCACHE_ANALYZE_OP(dir, op2)
     1510                else XCACHE_ANALYZE_CONSTANT(dir, , 1)
    14881511#   endif
    14891512            }
    14901513#   ifdef IS_UNICODE
    1491             else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) {
    1492                 XCACHE_U_ANALYZE_OP(file, op2)
    1493 #       ifdef ZEND_ENGINE_2_3
    1494                 else XCACHE_U_ANALYZE_OP(dir, op2)
    1495 #       endif
     1514            else if (Z_TYPE_P(constant) == IS_UNICODE) {
     1515                XCACHE_ANALYZE_CONSTANT(file, u_, 1)
     1516                else XCACHE_ANALYZE_CONSTANT(dir, u_, 1)
    14961517            }
    14971518#   endif
    14981519        }
    14991520
    1500         if (oplineinfo) {
    1501             xc_op_array_info_detail_t detail;
     1521        if (constantinfo) {
     1522            xc_constant_info_t detail;
    15021523            detail.index = oplinenum;
    1503             detail.info  = oplineinfo;
    1504             xc_vector_add(xc_op_array_info_detail_t, &details, detail);
    1505         }
    1506     }
    1507 
    1508     op_array_info->oplineinfo_cnt = details.cnt;
    1509     op_array_info->oplineinfos    = xc_vector_detach(xc_op_array_info_detail_t, &details);
     1524            detail.info  = constantinfo;
     1525            xc_vector_add(xc_constant_info_t, &constantinfos, detail);
     1526        }
     1527    }
     1528
     1529    op_array_info->constantinfo_cnt = constantinfos.cnt;
     1530    op_array_info->constantinfos    = xc_vector_detach(xc_constant_info_t, &constantinfos);
    15101531#endif /* ZEND_ENGINE_2_4 */
    1511     xc_vector_free(xc_op_array_info_detail_t, &details);
    1512 }
    1513 /* }}} */
    1514 void xc_fix_op_array_info(const xc_entry_php_t *entry_php, const xc_entry_data_php_t *php, zend_op_array *op_array, int shallow_copy, const xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */
    1515 {
     1532    xc_vector_free(xc_constant_info_t, &constantinfos);
     1533}
     1534/* }}} */
     1535#ifdef IS_UNICODE
     1536#   define xc_restore_constant_string xc_restore_constant_string_impl
     1537#else
     1538#   define xc_restore_constant_string(where, constant, type, constant_string, constant_u_string, shallow_copy) xc_restore_constant_string_impl(where, constant, type, constant_string, shallow_copy)
     1539#endif
     1540static inline void xc_restore_constant_string(const char *where, zval *constant, zend_uchar type, const xc_constant_string_t *constant_string, const xc_constant_u_string_t *constant_u_string, int shallow_copy TSRMLS_DC) /* {{{ */
     1541{
     1542    TRACE("fixing constant in %s: %s", where, Z_STRVAL_P(constant));
     1543    if (!shallow_copy) {
     1544        efree(Z_STRVAL_P(constant));
     1545    }
     1546    if (type == IS_STRING) {
     1547        assert(constant_string->str);
     1548        ZVAL_STRINGL(constant, constant_string->str, constant_string->len, !shallow_copy);
     1549        TRACE("fixed  constant in %s: %s", where, constant_string->str);
     1550    }
     1551#ifdef IS_UNICODE
     1552    else if (type == IS_UNICODE) {
     1553        assert(constant_u_string.str);
     1554        ZVAL_UNICODEL(constant, constant_u_string->str, constant_u_string->len, !shallow_copy);
     1555        /* TRACE("restored constant: %s", constant_u_string->str); */
     1556    }
     1557#endif
     1558    else {
     1559        assert(0);
     1560    }
     1561}
     1562/* }}} */
     1563#ifdef ZEND_ENGINE_2
     1564void xc_fix_class_info(const xc_entry_php_t *entry_php, xc_classinfo_t *classinfo, int shallow_copy TSRMLS_DC) /* {{{ */
     1565{
     1566    zend_class_entry *ce = CestToCePtr(classinfo->cest);
     1567    Bucket **constants = ce->constants_table.arBuckets;
     1568   
     1569    zend_uint constantinfo_index;
     1570
     1571    for (constantinfo_index = 0; constantinfo_index < classinfo->constantinfo_cnt; ++constantinfo_index) {
     1572        int index = classinfo->constantinfos[constantinfo_index].index;
     1573        int constantinfo = classinfo->constantinfos[constantinfo_index].info;
     1574
     1575        int index2 = index / ce->constants_table.nTableSize;
     1576
     1577        Bucket *bucket;
     1578        zval *constant;
     1579
     1580        for (bucket = constants[(index & ce->constants_table.nTableMask)]; index2; bucket = bucket->pNext, --index2) {
     1581            /* empty */
     1582        }
     1583        constant = *((zval **) bucket->pData);
     1584
     1585        if ((constantinfo & xcache_constant_is_file)) {
     1586            xc_restore_constant_string("class_constant", constant, Z_TYPE_P(constant), &entry_php->filepath, &entry_php->u_filepath, shallow_copy TSRMLS_CC);
     1587        }
     1588        else if ((constantinfo & xcache_constant_is_dir)) {
     1589            xc_restore_constant_string("class_constant", constant, Z_TYPE_P(constant), &entry_php->dirpath, &entry_php->u_dirpath, shallow_copy TSRMLS_CC);
     1590        }
     1591    }
     1592}
     1593/* }}} */
     1594#endif
     1595void xc_fix_op_array_info(const xc_entry_php_t *entry_php, zend_op_array *op_array, int shallow_copy, const xc_op_array_info_t *op_array_info TSRMLS_DC) /* {{{ */
     1596{
     1597    zend_uint constantinfo_index;
     1598    for (constantinfo_index = 0; constantinfo_index < op_array_info->constantinfo_cnt; ++constantinfo_index) {
     1599        int index = op_array_info->constantinfos[constantinfo_index].index;
     1600        int constantinfo = op_array_info->constantinfos[constantinfo_index].info;
     1601
    15161602#ifdef ZEND_ENGINE_2_4
    1517     zend_uint literalinfoindex;
    1518 
    1519     for (literalinfoindex = 0; literalinfoindex < op_array_info->literalinfo_cnt; ++literalinfoindex) {
    1520         int literalindex = op_array_info->literalinfos[literalinfoindex].index;
    1521         int literalinfo = op_array_info->literalinfos[literalinfoindex].info;
    1522         zend_literal *literal = &op_array->literals[literalindex];
    1523         if ((literalinfo & xcache_literal_is_file)) {
    1524             if (!shallow_copy) {
    1525                 efree(Z_STRVAL(literal->constant));
    1526             }
    1527             if (Z_TYPE(literal->constant) == IS_STRING) {
    1528                 assert(entry_php->filepath);
    1529                 ZVAL_STRINGL(&literal->constant, entry_php->filepath, entry_php->filepath_len, !shallow_copy);
    1530                 TRACE("restored literal constant: %s", entry_php->filepath);
    1531             }
    1532 #ifdef IS_UNICODE
    1533             else if (Z_TYPE(literal->constant) == IS_UNICODE) {
    1534                 assert(entry_php->ufilepath);
    1535                 ZVAL_UNICODEL(&literal->constant, entry_php->ufilepath, entry_php->ufilepath_len, !shallow_copy);
    1536             }
    1537 #endif
    1538             else {
    1539                 assert(0);
    1540             }
    1541         }
    1542         else if ((literalinfo & xcache_literal_is_dir)) {
    1543             if (!shallow_copy) {
    1544                 efree(Z_STRVAL(literal->constant));
    1545             }
    1546             if (Z_TYPE(literal->constant) == IS_STRING) {
    1547                 assert(entry_php->dirpath);
    1548                 TRACE("restored literal constant: %s", entry_php->dirpath);
    1549                 ZVAL_STRINGL(&literal->constant, entry_php->dirpath, entry_php->dirpath_len, !shallow_copy);
    1550             }
    1551 #ifdef IS_UNICODE
    1552             else if (Z_TYPE(literal->constant) == IS_UNICODE) {
    1553                 assert(!entry_php->udirpath);
    1554                 ZVAL_UNICODEL(&literal->constant, entry_php->udirpath, entry_php->udirpath_len, !shallow_copy);
    1555             }
    1556 #endif
    1557             else {
    1558                 assert(0);
    1559             }
    1560         }
    1561     }
     1603        zend_literal *literal = &op_array->literals[index];
     1604
     1605        if ((constantinfo & xcache_constant_is_file)) {
     1606            xc_restore_constant_string("literal", &literal->constant, Z_TYPE(literal->constant), &entry_php->filepath, &entry_php->u_filepath, shallow_copy TSRMLS_CC);
     1607        }
     1608        else if ((constantinfo & xcache_constant_is_dir)) {
     1609            xc_restore_constant_string("literal", &literal->constant, Z_TYPE(literal->constant), &entry_php->dirpath, &entry_php->u_dirpath, shallow_copy TSRMLS_CC);
     1610        }
    15621611#else /* ZEND_ENGINE_2_4 */
    1563     zend_uint oplinenum;
    1564 
    1565     for (oplinenum = 0; oplinenum < op_array_info->oplineinfo_cnt; ++oplinenum) {
    1566         int oplineindex = op_array_info->oplineinfos[oplinenum].index;
    1567         int oplineinfo = op_array_info->oplineinfos[oplinenum].info;
    1568         zend_op *opline = &op_array->opcodes[oplineindex];
    1569         if ((oplineinfo & xcache_op1_is_file)) {
    1570             assert(Z_OP_TYPE(opline->op1) == IS_CONST);
    1571             if (!shallow_copy) {
    1572                 efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1)));
    1573             }
    1574             if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) {
    1575                 assert(entry_php->filepath);
    1576                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), entry_php->filepath, entry_php->filepath_len, !shallow_copy);
    1577                 TRACE("restored op1 constant: %s", entry_php->filepath);
    1578             }
    1579 #   ifdef IS_UNICODE
    1580             else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) {
    1581                 assert(entry_php->ufilepath);
    1582                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), entry_php->ufilepath, entry_php->ufilepath_len, !shallow_copy);
    1583             }
     1612        zend_op *opline = &op_array->opcodes[index];
     1613       
     1614        if ((constantinfo & xcache_constant_is_file)) {
     1615            xc_restore_constant_string("op1", &Z_OP_CONSTANT(opline->op1), Z_TYPE(Z_OP_CONSTANT(opline->op1)), &entry_php->filepath, &entry_php->u_filepath, shallow_copy TSRMLS_CC);
     1616        }
     1617#   ifdef ZEND_ENGINE_2_3
     1618        else if ((constantinfo & xcache_constant_is_dir)) {
     1619            xc_restore_constant_string("op1", &Z_OP_CONSTANT(opline->op1), Z_TYPE(Z_OP_CONSTANT(opline->op1)), &entry_php->dirpath, &entry_php->u_dirpath, shallow_copy TSRMLS_CC);
     1620        }
    15841621#   endif
    1585             else {
    1586                 assert(0);
    1587             }
     1622
     1623        constantinfo >>= xcache_constant_info_shift * 1;
     1624        if ((constantinfo & xcache_constant_is_file)) {
     1625            xc_restore_constant_string("op2", &Z_OP_CONSTANT(opline->op2), Z_TYPE(Z_OP_CONSTANT(opline->op2)), &entry_php->filepath, &entry_php->u_filepath, shallow_copy TSRMLS_CC);
    15881626        }
    15891627#   ifdef ZEND_ENGINE_2_3
    1590         else if ((oplineinfo & xcache_op1_is_dir)) {
    1591             assert(Z_OP_TYPE(opline->op1) == IS_CONST);
    1592             if (!shallow_copy) {
    1593                 efree(Z_STRVAL(Z_OP_CONSTANT(opline->op1)));
    1594             }
    1595             if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_STRING) {
    1596                 assert(entry_php->dirpath);
    1597                 TRACE("restored op1 constant: %s", entry_php->dirpath);
    1598                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op1), entry_php->dirpath, entry_php->dirpath_len, !shallow_copy);
    1599             }
    1600 #       ifdef IS_UNICODE
    1601             else if (Z_TYPE(Z_OP_CONSTANT(opline->op1)) == IS_UNICODE) {
    1602                 assert(!entry_php->udirpath);
    1603                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op1), entry_php->udirpath, entry_php->udirpath_len, !shallow_copy);
    1604             }
    1605 #       endif
    1606             else {
    1607                 assert(0);
    1608             }
    1609         }
    1610 #endif
    1611 
    1612         if ((oplineinfo & xcache_op2_is_file)) {
    1613             assert(Z_OP_TYPE(opline->op2) == IS_CONST);
    1614             if (!shallow_copy) {
    1615                 efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2)));
    1616             }
    1617             if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) {
    1618                 assert(entry_php->filepath);
    1619                 TRACE("restored op2 constant: %s", entry_php->filepath);
    1620                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), entry_php->filepath, entry_php->filepath_len, !shallow_copy);
    1621             }
    1622 #   ifdef IS_UNICODE
    1623             else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) {
    1624                 assert(entry_php->ufilepath);
    1625                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), entry_php->ufilepath, entry_php->ufilepath_len, !shallow_copy);
    1626             }
     1628        else if ((constantinfo & xcache_constant_is_dir)) {
     1629            xc_restore_constant_string("op2", &Z_OP_CONSTANT(opline->op2), Z_TYPE(Z_OP_CONSTANT(opline->op2)), &entry_php->dirpath, &entry_php->u_dirpath, shallow_copy TSRMLS_CC);
     1630        }
    16271631#   endif
    1628             else {
    1629                 assert(0);
    1630             }
    1631         }
    1632 #   ifdef ZEND_ENGINE_2_3
    1633         else if ((oplineinfo & xcache_op2_is_dir)) {
    1634             assert(Z_OP_TYPE(opline->op2) == IS_CONST);
    1635             if (!shallow_copy) {
    1636                 efree(Z_STRVAL(Z_OP_CONSTANT(opline->op2)));
    1637             }
    1638             if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_STRING) {
    1639                 assert(entry_php->dirpath);
    1640                 TRACE("restored op2 constant: %s", entry_php->dirpath);
    1641                 ZVAL_STRINGL(&Z_OP_CONSTANT(opline->op2), entry_php->dirpath, entry_php->dirpath_len, !shallow_copy);
    1642             }
    1643 #       ifdef IS_UNICODE
    1644             else if (Z_TYPE(Z_OP_CONSTANT(opline->op2)) == IS_UNICODE) {
    1645                 assert(entry_php->udirpath);
    1646                 ZVAL_UNICODEL(&Z_OP_CONSTANT(opline->op2), entry_php->udirpath, entry_php->udirpath_len, !shallow_copy);
    1647             }
    1648 #       endif
    1649             else {
    1650                 assert(0);
    1651             }
    1652         }
    1653 #   endif
    1654     }
    16551632#endif /* ZEND_ENGINE_2_4 */
     1633    }
    16561634}
    16571635/* }}} */
     
    16591637{
    16601638#ifdef ZEND_ENGINE_2_4
    1661     if (op_array_info->literalinfos) {
    1662         efree(op_array_info->literalinfos);
     1639    if (op_array_info->constantinfos) {
     1640        efree(op_array_info->constantinfos);
    16631641    }
    16641642#else
    1665     if (op_array_info->oplineinfos) {
    1666         efree(op_array_info->oplineinfos);
     1643    if (op_array_info->constantinfos) {
     1644        efree(op_array_info->constantinfos);
    16671645    }
    16681646#endif
     
    16841662                efree(classinfo->methodinfos);
    16851663            }
     1664
     1665#ifdef ZEND_ENGINE_2
     1666            if (classinfo->constantinfos) {
     1667                efree(classinfo->constantinfos);
     1668            }
     1669#endif
    16861670        }
    16871671    }
     
    18651849            xc_classinfo_t *classinfo = &compiler->new_php.classinfos[i];
    18661850            zend_class_entry *ce = CestToCePtr(classinfo->cest);
    1867             classinfo->methodinfo_cnt = ce->function_table.nTableSize;
     1851
     1852            classinfo->methodinfo_cnt = ce->function_table.nNumOfElements;
    18681853            if (classinfo->methodinfo_cnt) {
    18691854                int j;
     
    18811866                classinfo->methodinfos = NULL;
    18821867            }
     1868
     1869#ifdef ZEND_ENGINE_2
     1870            if (ce->constants_table.nNumOfElements) {
     1871                xc_collect_class_constant_info(compiler, &const_usage, classinfo, &ce->constants_table TSRMLS_CC);
     1872            }
     1873            else {
     1874                classinfo->constantinfo_cnt = 0;
     1875                classinfo->constantinfos = NULL;
     1876            }
     1877#endif
    18831878        }
    18841879
     
    18921887#define X_FREE_UNUSED(var) \
    18931888        if (!const_usage.var##path_used) { \
    1894             efree(compiler->new_entry.var##path); \
    1895             compiler->new_entry.var##path = NULL; \
    1896             compiler->new_entry.var##path_len = 0; \
     1889            efree(compiler->new_entry.var##path.str); \
     1890            compiler->new_entry.var##path.str = NULL; \
     1891            compiler->new_entry.var##path.len = 0; \
    18971892        }
    18981893        /* filepath is required to restore op_array->filename, so no free filepath here */
     
    19011896#endif
    19021897#ifdef IS_UNICODE
    1903         X_FREE_UNUSED(ufile)
    1904 #   ifdef ZEND_ENGINE_2_3
    1905         X_FREE_UNUSED(udir)
    1906 #   endif
     1898        X_FREE_UNUSED(u_file)
     1899        X_FREE_UNUSED(u_dir)
    19071900#endif
    19081901#undef X_FREE_UNUSED
  • processor/processor.m4

    rbe1ba47 r46d274f  
    508508#   ifdef ZEND_ENGINE_2_4
    509509    DISABLECHECK(`
    510     IFRESTORE(`DST(`info.user.filename') = processor->entry_php_src->filepath;', `PROC_STRING(info.user.filename)')
     510    IFRESTORE(`DST(`info.user.filename') = processor->entry_php_src->filepath.str;', `PROC_STRING(info.user.filename)')
    511511    PROCESS(zend_uint, info.user.line_start)
    512512    PROCESS(zend_uint, info.user.line_end)
     
    516516    DONE(info)
    517517#   else
    518     IFRESTORE(`DST(`filename') = processor->entry_php_src->filepath;DONE(filename)', `PROC_STRING(filename)')
     518    IFRESTORE(`DST(`filename') = processor->entry_php_src->filepath.str;DONE(filename)', `PROC_STRING(filename)')
    519519    PROCESS(zend_uint, line_start)
    520520    PROCESS(zend_uint, line_end)
     
    826826        }
    827827#endif
    828         DST(`filename') = processor->entry_php_src->filepath;
    829 
    830 #ifdef ZEND_ENGINE_2_4
    831         if (SRC(`literals') && op_array_info->literalinfo_cnt) {
     828        DST(`filename') = processor->entry_php_src->filepath.str;
     829
     830#ifdef ZEND_ENGINE_2_4
     831        if (SRC(`literals') && op_array_info->constantinfo_cnt) {
    832832            gc_opcodes = 1;
    833833            gc_literals = 1;
    834834        }
    835835#else
    836         if (op_array_info->oplineinfo_cnt) {
     836        if (op_array_info->constantinfo_cnt) {
    837837            gc_opcodes = 1;
    838838        }
     
    10321032#endif
    10331033
    1034     IFRESTORE(`DST(`filename') = processor->entry_php_src->filepath;DONE(filename)', `PROC_STRING(filename)')
     1034    IFRESTORE(`DST(`filename') = processor->entry_php_src->filepath.str; DONE(filename)', `PROC_STRING(filename)')
    10351035#ifdef IS_UNICODE
    10361036    IFRESTORE(`
     
    10601060#endif
    10611061    } while (0);
    1062     IFRESTORE(`xc_fix_op_array_info(processor->entry_php_src, processor->php_src, DST(), shallow_copy, op_array_info TSRMLS_CC);')
     1062    IFRESTORE(`xc_fix_op_array_info(processor->entry_php_src, DST(), shallow_copy, op_array_info TSRMLS_CC);')
    10631063
    10641064#ifdef ZEND_ENGINE_2
     
    11331133#endif
    11341134IFRESTORE(`', `
    1135 DEF_STRUCT_P_FUNC(`xc_op_array_info_detail_t', , `dnl {{{
     1135DEF_STRUCT_P_FUNC(`xc_constant_info_t', , `dnl {{{
    11361136    PROCESS(zend_uint, index)
    11371137    PROCESS(zend_uint, info)
     
    11391139dnl }}}
    11401140DEF_STRUCT_P_FUNC(`xc_op_array_info_t', , `dnl {{{
    1141 #ifdef ZEND_ENGINE_2_4
    1142     PROCESS(zend_uint, literalinfo_cnt)
    1143     STRUCT_ARRAY(zend_uint, literalinfo_cnt, xc_op_array_info_detail_t, literalinfos)
    1144 #else
    1145     PROCESS(zend_uint, oplineinfo_cnt)
    1146     STRUCT_ARRAY(zend_uint, oplineinfo_cnt, xc_op_array_info_detail_t, oplineinfos)
    1147 #endif
     1141    PROCESS(zend_uint, constantinfo_cnt)
     1142    STRUCT_ARRAY(zend_uint, constantinfo_cnt, xc_constant_info_t, constantinfos)
    11481143')
    11491144dnl }}}
     
    11811176        STRUCT_ARRAY(zend_uint, methodinfo_cnt, xc_op_array_info_t, methodinfos)
    11821177    ')
     1178#ifdef ZEND_ENGINE_2
     1179    PROCESS(zend_uint, constantinfo_cnt)
     1180    IFRESTORE(`COPYPOINTER(constantinfos)', `
     1181        STRUCT_ARRAY(zend_uint, constantinfo_cnt, xc_constant_info_t, constantinfos)
     1182    ')
     1183#endif
    11831184    IFRESTORE(`
    11841185        processor->active_op_array_infos_src = SRC(`methodinfos');
     
    11891190#else
    11901191    STRUCT(zend_class_entry, cest)
     1192#endif
     1193#ifdef ZEND_ENGINE_2
     1194    IFRESTORE(`xc_fix_class_info(processor->entry_php_src, DST(), 0 TSRMLS_CC);')
    11911195#endif
    11921196#ifndef ZEND_COMPILE_DELAYED_BINDING
     
    12901294')
    12911295dnl }}}
     1296DEF_STRUCT_P_FUNC(`xc_constant_string_t', , `dnl {{{
     1297    PROCESS(size_t, len)
     1298    IFRESTORE(`COPYPOINTER(str)', `PROC_STRING_L(str, len)')
     1299')
     1300dnl }}}
     1301#ifdef IS_UNICODE
     1302DEF_STRUCT_P_FUNC(`xc_constant_u_string_t', , `dnl {{{
     1303    PROCESS(size_t, len)
     1304    IFRESTORE(`COPYPOINTER(str)', `PROC_USTRING_L(str, len)')
     1305')
     1306dnl }}}
     1307#endif
    12921308DEF_STRUCT_P_FUNC(`xc_entry_php_t', , `dnl {{{
    12931309    STRUCT(xc_entry_t, entry)
     
    13071323    PROCESS(size_t, file_inode)
    13081324
    1309     PROCESS(size_t, filepath_len)
    1310     IFRESTORE(`COPYPOINTER(filepath)', `PROC_STRING_L(filepath, filepath_len)')
     1325    STRUCT(xc_constant_string_t, filepath)
    13111326#ifdef ZEND_ENGINE_2_3
    1312     PROCESS(size_t, dirpath_len)
    1313     IFRESTORE(`COPYPOINTER(dirpath)', `PROC_STRING_L(dirpath, dirpath_len)')
     1327    STRUCT(xc_constant_string_t, dirpath)
    13141328#endif
    13151329#ifdef IS_UNICODE
    1316     PROCESS(int, ufilepath_len)
    1317     IFRESTORE(`COPYPOINTER(ufilepath)', `PROC_USTRING_L(ufilepath, ufilepath_len)')
    1318 #   ifdef ZEND_ENGINE_2_3
    1319     PROCESS(int, udirpath_len)
    1320     IFRESTORE(`COPYPOINTER(udirpath)', `PROC_USTRING_L(udirpath, udirpath_len)')
    1321 #   endif
     1330    STRUCT(xc_constant_u_string_t, u_filepath)
     1331    STRUCT(xc_constant_u_string_t, u_dirpath)
    13221332#endif
    13231333')
Note: See TracChangeset for help on using the changeset viewer.