Changeset 822


Ignore:
Timestamp:
2012-03-22T17:22:37+01:00 (2 years ago)
Author:
moo
Message:

initial PHP_5_4 support

Location:
trunk
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/optimizer.c

    r716 r822  
    1919#else 
    2020#   define XCACHE_IS_CV 16 
     21#endif 
     22 
     23#ifdef ZEND_ENGINE_2_4 
     24#   undef Z_OP_CONSTANT 
     25/* Z_OP_CONSTANT is used before pass_two is applied */ 
     26#   define Z_OP_CONSTANT(op) op_array->literals[op.constant].constant 
    2127#endif 
    2228 
  • trunk/processor/hashtable.m4

    r721 r822  
    109109                /* pnew into hash node chain */ 
    110110                pnew->pLast = NULL; 
    111                 if (dst->arBuckets[n]) { 
    112                     pnew->pNext = dst->arBuckets[n]; 
     111                pnew->pNext = dst->arBuckets[n]; 
     112                if (pnew->pNext) { 
    113113                    pnew->pNext->pLast = pnew; 
    114                 } 
    115                 else { 
    116                     pnew->pNext = NULL; 
    117114                } 
    118115                dst->arBuckets[n] = pnew; 
  • trunk/processor/processor.m4

    r785 r822  
    486486undefine(`UNION_znode_op') 
    487487define(`UNION_znode_op', `dnl {{{ 
    488     switch ((src->$1_type & ~EXT_TYPE_UNUSED)) { 
     488#ifndef NDEBUG 
     489    switch ((src->$1_type ifelse($1, `result', & ~EXT_TYPE_UNUSED))) { 
    489490    case IS_CONST: 
    490491    case IS_VAR: 
     
    497498        assert(0); 
    498499    } 
     500#endif 
    499501 
    500502    dnl dirty dispatch 
    501503    DISABLECHECK(` 
    502     switch ((src->$1_type & ~EXT_TYPE_UNUSED)) { 
     504    switch ((src->$1_type ifelse($1, `result', & ~EXT_TYPE_UNUSED))) { 
    503505        case IS_CONST: 
    504             dnl TODO: fix me, use literals 
    505             IFDASM(`{ 
    506                 zval *zv; 
    507                 ALLOC_INIT_ZVAL(zv); 
    508                 *zv = ((zend_literal *) src->$1.ptr)->constant; 
    509                 zval_copy_ctor(zv); 
    510                 add_assoc_zval_ex(dst, ZEND_STRS("$1.constant"), zv); 
     506            ifelse($1, `result', ` 
     507                DISPATCH(zend_uint, $1.constant) 
     508            ', ` 
     509                IFDASM(`{ 
     510                    zval *zv; 
     511                    ALLOC_INIT_ZVAL(zv); 
     512                    *zv = src->$1.literal->constant; 
     513                    zval_copy_ctor(zv); 
     514                    add_assoc_zval_ex(dst, ZEND_STRS("$1.constant"), zv); 
    511515                } 
    512             ', ` 
    513                 DISPATCH(zend_uint, $1.constant) 
     516                ', ` 
     517                    IFCOPY(` 
     518                        dst->$1 = src->$1; 
     519                    ', ` 
     520                        DISPATCH(zend_uint, $1.constant) 
     521                    ') 
     522                ') 
    514523            ') 
    515524            break; 
     
    517526            IFNOTMEMCPY(` 
    518527                default: 
    519                     *dst = *src; 
     528                    $1 = $2; 
    520529            ') 
    521530        ', ` 
     
    607616#endif 
    608617    IFCOPY(` 
     618        pushdef(`UNION_znode_op_literal', ` 
     619            if (dst->$1_type == IS_CONST) { 
     620                IFSTORE(` 
     621                    dst->$1.constant = src->$1.literal - processor->active_op_array_src->literals; 
     622                    dst->$1.literal = &processor->active_op_array_dst->literals[dst->$1.constant]; 
     623                ') 
     624            } 
     625        ') 
     626        UNION_znode_op_literal(op1) 
     627        UNION_znode_op_literal(op2) 
     628        popdef(`UNION_znode_op_literal') 
    609629        switch (src->opcode) { 
    610630#ifdef ZEND_GOTO 
     
    659679    if (shallow_copy) { 
    660680        zend_bool gc_arg_info = 0; 
    661         int gc_opcodes        = 0; 
     681        zend_bool gc_opcodes  = 0; 
    662682        /* really fast shallow copy */ 
    663683        memcpy(dst, src, sizeof(src[0])); 
     
    669689        gc_arg_info = 1; 
    670690#endif 
    671         IFRESTORE(`dst->filename = processor->entry_src->filepath;') 
    672 #ifndef ZEND_ENGINE_2_4 
     691        dst->filename = processor->entry_src->filepath; 
     692#ifdef ZEND_ENGINE_2_4 
     693        if (src->literals /* || op_array_info->literalsinfo_cnt */) { 
     694            gc_opcodes = 1; 
     695        } 
     696#else 
    673697        if (op_array_info->oplineinfo_cnt) { 
     698            gc_opcodes = 1; 
     699        } 
     700#endif 
     701        if (gc_opcodes) { 
    674702            zend_op *opline, *end; 
    675             gc_opcodes = 1; 
    676703            COPY_N_EX(last, zend_op, opcodes) 
    677704 
    678705            for (opline = dst->opcodes, end = opline + src->last; opline < end; ++opline) { 
     706#ifdef ZEND_ENGINE_2_4 
     707                pushdef(`UNION_znode_op_literal', ` 
     708                    if (opline->$1_type == IS_CONST) { 
     709                        opline->$1.constant = opline->$1.literal - src->literals; 
     710                        opline->$1.literal = &dst->literals[opline->$1.constant]; 
     711                    } 
     712                ') 
     713                UNION_znode_op_literal(op1) 
     714                UNION_znode_op_literal(op2) 
     715                popdef(`UNION_znode_op_literal') 
     716#endif 
     717 
    679718                switch (opline->opcode) { 
    680719#ifdef ZEND_GOTO 
     
    700739            } 
    701740        } 
    702 #endif 
    703741        if (gc_arg_info || gc_opcodes) { 
    704742            xc_gc_op_array_t gc_op_array; 
     
    707745            gc_op_array.arg_info = gc_arg_info ? dst->arg_info : NULL; 
    708746#endif 
    709             gc_op_array.last     = gc_opcodes > 1 ? dst->last : 0; 
    710747            gc_op_array.opcodes  = gc_opcodes ? dst->opcodes : NULL; 
    711748            xc_gc_add_op_array(&gc_op_array TSRMLS_CC); 
     
    771808    IFSTORE(`dst->refcount[0] = 1;') 
    772809 
     810#ifdef ZEND_ENGINE_2_4 
     811    dnl before copying opcodes 
     812    DISPATCH(int, last_literal) 
     813    STRUCT_ARRAY(last_literal, zend_literal, literals) 
     814#endif 
     815 
    773816    pushdef(`AFTER_ALLOC', `IFCOPY(` 
    774817#ifndef NDEBUG 
     
    857900#endif 
    858901#ifdef ZEND_ENGINE_2_4 
    859     DISPATCH(int, last_literal) 
    860     IFRESTORE(`COPY(literals)', `STRUCT_ARRAY(last_literal, zend_literal, literals)') 
    861  
    862902    COPYNULL(run_time_cache) 
    863903    COPYNULL(last_cache_slot) 
  • trunk/utils.c

    r785 r822  
    1919#endif 
    2020 
    21 #define OP_ZVAL_DTOR(op) do { \ 
    22     Z_UNSET_ISREF(Z_OP_CONSTANT(op)); \ 
    23     zval_dtor(&Z_OP_CONSTANT(op)); \ 
    24 } while(0) 
     21#ifdef ZEND_ENGINE_2_4 
     22#   define OP_ZVAL_DTOR(op) do { } while(0) 
     23#else 
     24#   define OP_ZVAL_DTOR(op) do { \ 
     25        Z_UNSET_ISREF(Z_OP_CONSTANT(op)); \ 
     26        zval_dtor(&Z_OP_CONSTANT(op)); \ 
     27    } while(0) 
     28#endif 
    2529xc_compile_result_t *xc_compile_result_init(xc_compile_result_t *cr, /* {{{ */ 
    2630        zend_op_array *op_array, 
     
    130134} 
    131135/* }}} */ 
    132  
    133136int xc_undo_pass_two(zend_op_array *op_array TSRMLS_DC) /* {{{ */ 
    134137{ 
    135138    zend_op *opline, *end; 
    136139 
    137 #ifndef ZEND_ENGINE_2_4 
     140#ifdef ZEND_ENGINE_2_4 
     141    if (!(op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO)) { 
     142        return 0; 
     143    } 
     144#else 
    138145    if (!op_array->done_pass_two) { 
    139146        return 0; 
     
    144151    end = opline + op_array->last; 
    145152    while (opline < end) { 
     153#ifdef ZEND_ENGINE_2_4 
     154        if (opline->op1_type == IS_CONST) { 
     155            opline->op1.constant = opline->op1.literal - op_array->literals; 
     156        } 
     157        if (opline->op2_type == IS_CONST) { 
     158            opline->op2.constant = opline->op2.literal - op_array->literals; 
     159        } 
     160#endif 
     161 
    146162#ifdef ZEND_ENGINE_2_1 
    147163        switch (opline->opcode) { 
     
    167183        opline++; 
    168184    } 
    169 #ifndef ZEND_ENGINE_2_4 
     185#ifdef ZEND_ENGINE_2_4 
     186    op_array->fn_flags &= ~ZEND_ACC_DONE_PASS_TWO; 
     187#else 
    170188    op_array->done_pass_two = 0; 
    171189#endif 
     
    177195{ 
    178196    zend_op *opline, *end; 
    179  
    180 #ifndef ZEND_ENGINE_2_4 
     197#ifdef ZEND_ENGINE_2_4 
     198    zend_literal *literal = op_array->literals; 
     199#endif 
     200 
     201#ifdef ZEND_ENGINE_2_4 
     202    if ((op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO)) { 
     203        return 0; 
     204    } 
     205#else 
    181206    if (op_array->done_pass_two) { 
    182207        return 0; 
     
    188213    op_array->size = op_array->last; 
    189214    */ 
     215#ifdef ZEND_ENGINE_2_4 
     216    if (literal) { 
     217        zend_literal *end = literal + op_array->last_literal; 
     218        while (literal < end) { 
     219            Z_SET_ISREF(literal->constant); 
     220            Z_SET_REFCOUNT(literal->constant, 2); /* Make sure is_ref won't be reset */ 
     221            literal++; 
     222        } 
     223    } 
     224#endif 
    190225 
    191226    opline = op_array->opcodes; 
    192227    end = opline + op_array->last; 
    193228    while (opline < end) { 
     229#ifndef ZEND_ENGINE_2_4 
    194230        if (Z_OP_TYPE(opline->op1) == IS_CONST) { 
    195231            Z_SET_ISREF(Z_OP_CONSTANT(opline->op1)); 
    196232            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op1), 2); /* Make sure is_ref won't be reset */ 
    197  
    198233        } 
    199234        if (Z_OP_TYPE(opline->op2) == IS_CONST) { 
     
    201236            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op2), 2); 
    202237        } 
     238#endif 
    203239#ifdef ZEND_ENGINE_2_1 
    204240        switch (opline->opcode) { 
     
    226262    } 
    227263 
    228 #ifndef ZEND_ENGINE_2_4 
     264#ifdef ZEND_ENGINE_2_4 
     265    op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO; 
     266#else 
    229267    op_array->done_pass_two = 1; 
    230268#endif 
  • trunk/xcache.h

    r798 r822  
    2222 
    2323#define HAVE_INODE 
    24 #if !defined(ZEND_ENGINE_2_4) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 3 && PHP_RELEASE_VERSION >= 99 || PHP_MAJOR_VERSION > 5) 
     24#if !defined(ZEND_ENGINE_2_4) && (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 4 || PHP_MAJOR_VERSION > 5) 
    2525#   define ZEND_ENGINE_2_4 
    2626#endif 
     
    450450    zend_arg_info *arg_info; 
    451451#endif 
    452     zend_uint last; 
    453452    zend_op *opcodes; 
    454453} xc_gc_op_array_t; 
Note: See TracChangeset for help on using the changeset viewer.