Changeset 1321 in svn for trunk/xcache


Ignore:
Timestamp:
2013-07-15T17:37:57Z (6 years ago)
Author:
Xuefer
Message:

add back PHP_4 code for disassembler

Location:
trunk/xcache
Files:
10 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/xcache/xc_compatibility.c

    r1281 r1321  
    22
    33#ifndef ZEND_ENGINE_2_3
     4#include "ext/standard/php_string.h"
     5size_t xc_dirname(char *path, size_t len) /* {{{ */
     6{
     7#ifdef ZEND_ENGINE_2
     8    return php_dirname(path, len);
     9#else
     10    php_dirname(path, len);
     11    return strlen(path);
     12#endif
     13}
     14/* }}} */
     15
    416long xc_atol(const char *str, int str_len) /* {{{ */
    517{
  • trunk/xcache/xc_compatibility.h

    r1281 r1321  
    2828
    2929#define NOTHING
    30 /* ZendEngine version code Switcher */
     30/* ZendEngine code Switcher */
     31#ifndef ZEND_ENGINE_2
     32#   define ZESW(v1, v2) v1
     33#else
     34#   define ZESW(v1, v2) v2
     35#endif
    3136#ifdef ZEND_ENGINE_2_4
    3237#   define ZEND_24(pre24, v24) v24
     
    208213/* }}} */
    209214
     215/* the class entry type to be stored in class_table */
     216typedef ZESW(zend_class_entry, zend_class_entry*) xc_cest_t;
     217
     218/* xc_cest_t to (zend_class_entry*) */
     219#define CestToCePtr(st) (ZESW(\
     220            &(st), \
     221            st \
     222            ) )
     223
     224/* ZCEP=zend class entry ptr */
     225#define ZCEP_REFCOUNT_PTR(pce) (ZESW( \
     226            (pce)->refcount, \
     227            &((pce)->refcount) \
     228            ))
     229
    210230#ifndef ZEND_ENGINE_2_3
    211 #include "ext/standard/php_string.h"
    212 static inline size_t zend_dirname(char *path, size_t len) { return php_dirname(path, len); }
     231size_t xc_dirname(char *path, size_t len);
     232#define zend_dirname xc_dirname
    213233long xc_atol(const char *str, int len);
    214234#define zend_atol xc_atol
     
    220240
    221241#ifndef PHP_FE_END
    222 #   define PHP_FE_END {NULL, NULL, NULL, 0, 0}
     242#   ifdef ZEND_ENGINE_2
     243#       define PHP_FE_END {NULL, NULL, NULL, 0, 0}
     244#   else
     245#       define PHP_FE_END {NULL, NULL, NULL}
     246#   endif
    223247#endif
    224248
  • trunk/xcache/xc_const_string.c

    r1281 r1321  
    7272#elif defined(ZEND_ENGINE_2_1)
    7373#   include "xc_const_string_opcodes_php5.1.h"
     74#elif defined(ZEND_ENGINE_2)
     75#   include "xc_const_string_opcodes_php5.0.h"
    7476#else
    75 #   include "xc_const_string_opcodes_php5.0.h"
     77#   include "xc_const_string_opcodes_php4.x.h"
    7678#endif
    7779
  • trunk/xcache/xc_const_string_opcodes_php5.3.h

    r1281 r1321  
    152152/* 149 */   "HANDLE_EXCEPTION",
    153153/* 150 */   "USER_OPCODE",
    154 #ifdef ZEND_ENGINE_2_3
    155154/* 151 */   "UNDEF",
    156155/* 152 */   "JMP_SET",
    157156/* 153 */   "DECLARE_LAMBDA_FUNCTION"
    158 #endif
    159157};
  • trunk/xcache/xc_ini.h

    r1281 r1321  
    1313PHP_INI_MH(xcache_OnUpdateBool);
    1414PHP_INI_MH(xcache_OnUpdateString);
     15#ifndef ZEND_ENGINE_2
     16#define OnUpdateLong OnUpdateInt
     17#endif
    1518
    1619#endif /* XC_INI_H_E208B8E597E7FAD950D249BE9C6B6F53 */
  • trunk/xcache/xc_opcode_spec.c

    r1306 r1321  
    55/* {{{ opcode_spec */
    66#define OPSPEC(ext, op1, op2, res) { OPSPEC_##ext, OPSPEC_##op1, OPSPEC_##op2, OPSPEC_##res },
    7 #define OPSPEC_VAR_2 OPSPEC_STD
     7#ifdef ZEND_ENGINE_2
     8#   define OPSPEC_VAR_2 OPSPEC_STD
     9#else
     10#   define OPSPEC_VAR_2 OPSPEC_VAR
     11#endif
    812#ifdef ZEND_ENGINE_2_4
    913#undef OPSPEC_FETCH
  • trunk/xcache/xc_opcode_spec_def.h

    r1319 r1321  
    2323    OPSPEC(      CAST,        STD,     UNUSED,        TMP) /* 21 CAST                           */
    2424    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 22 QM_ASSIGN                      */
     25#ifdef ZEND_ENGINE_2
    2526    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 23 ASSIGN_ADD                     */
    2627    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 24 ASSIGN_SUB                     */
     
    3435    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 32 ASSIGN_BW_AND                  */
    3536    OPSPEC(    ASSIGN,        STD,        STD,        VAR) /* 33 ASSIGN_BW_XOR                  */
     37#else
     38    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     39    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     40    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     41    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     42    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     43    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     44    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     45    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     46    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     47    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     48    OPSPEC(    UNUSED,        VAR,        STD,        VAR)
     49#endif
    3650    OPSPEC(    UNUSED,        VAR,     UNUSED,        VAR) /* 34 PRE_INC                        */
    3751    OPSPEC(    UNUSED,        VAR,     UNUSED,        VAR) /* 35 PRE_DEC                        */
     
    4256    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 40 ECHO                           */
    4357    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 41 PRINT                          */
     58#ifdef ZEND_ENGINE_2
    4459    OPSPEC(    UNUSED,    JMPADDR,     UNUSED,     UNUSED) /* 42 JMP                            */
    4560    OPSPEC(    UNUSED,        STD,    JMPADDR,     UNUSED) /* 43 JMPZ                           */
    4661    OPSPEC(    UNUSED,        STD,    JMPADDR,     UNUSED) /* 44 JMPNZ                          */
     62#else
     63    OPSPEC(    UNUSED,     OPLINE,     UNUSED,     UNUSED)
     64    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED)
     65    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED)
     66#endif
    4767    OPSPEC(    OPLINE,        STD,     OPLINE,     UNUSED) /* 45 JMPZNZ                         */
     68#ifdef ZEND_ENGINE_2
    4869    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 46 JMPZ_EX                        */
    4970    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 47 JMPNZ_EX                       */
     71#else
     72    OPSPEC(    UNUSED,        STD,     OPLINE,        TMP)
     73    OPSPEC(    UNUSED,        STD,     OPLINE,        TMP)
     74#endif
    5075    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 48 CASE                           */
    5176    OPSPEC(       BIT,        STD,     UNUSED,     UNUSED) /* 49 SWITCH_FREE                    */
     
    6085    OPSPEC(    UNUSED,        TMP,     UNUSED,     UNUSED) /* 58 END_SILENCE                    */
    6186    OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 59 INIT_FCALL_BY_NAME             */
     87#ifdef ZEND_ENGINE_2
    6288    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 60 DO_FCALL                       */
    6389    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 61 DO_FCALL_BY_NAME               */
     90#else
     91    OPSPEC(     FCALL,        STD,     UNUSED,        VAR)
     92    OPSPEC(     FCALL,        STD,     UNUSED,        VAR)
     93#endif
    6494    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 62 RETURN                         */
    6595    OPSPEC(    UNUSED,        ARG,     UNUSED,        VAR) /* 63 RECV                           */
     
    6898    OPSPEC(      SEND,        VAR,        ARG,     UNUSED) /* 66 SEND_VAR                       */
    6999    OPSPEC(      SEND,        VAR,        ARG,     UNUSED) /* 67 SEND_REF                       */
     100#ifdef ZEND_ENGINE_2
    70101    OPSPEC(    UNUSED,      CLASS,     UNUSED,        VAR) /* 68 NEW                            */
     102#else
     103    OPSPEC(    UNUSED,        STD,     UNUSED,        VAR)
     104#endif
    71105#ifdef ZEND_ENGINE_2_3
    72106    OPSPEC(       STD,        STD,        STD,     UNUSED) /* 69 INIT_NS_FCALL_BY_NAME          */
     
    115149#ifdef ZEND_ENGINE_2_3
    116150    OPSPEC(    UNUSED,      VAR_2,        STD,        TMP) /* 99 FETCH_CONSTANT                 */
    117 #else
     151#elif defined(ZEND_ENGINE_2)
    118152    OPSPEC(    UNUSED,     UCLASS,        STD,        TMP) /* 99 FETCH_CONSTANT                 */
     153#else
     154    OPSPEC(    UNUSED,        STD,     UNUSED,        TMP) /* 99 FETCH_CONSTANT                 */
    119155#endif
    120156#ifdef ZEND_ENGINE_2_3
     
    129165    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 105 TICKS                          */
    130166    OPSPEC(SEND_NOREF,        VAR,        ARG,     UNUSED) /* 106 SEND_VAR_NO_REF                */
    131 #ifdef ZEND_ENGINE_2_4
     167#ifdef ZEND_ENGINE_2
     168#   ifdef ZEND_ENGINE_2_4
    132169    OPSPEC(    OPLINE,        STD,        STD,     UNUSED) /* 107 CATCH                          */
    133 #else
     170#   else
    134171    OPSPEC(    OPLINE,      CLASS,        STD,     UNUSED) /* 107 CATCH                          */
    135 #endif
     172#   endif
    136173    OPSPEC(    UNUSED,        STD,     OPLINE,     UNUSED) /* 108 THROW                          */
    137174    OPSPEC(    FCLASS,        STD,        STD,      CLASS) /* 109 FETCH_CLASS                    */
    138175    OPSPEC(    UNUSED,        STD,     UNUSED,        VAR) /* 110 CLONE                          */
    139176
    140 #ifdef ZEND_ENGINE_2_4
     177#   ifdef ZEND_ENGINE_2_4
    141178    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 111 RETURN_BY_REF                  */
    142 #else
     179#   else
    143180    OPSPEC(    UNUSED,        STD,     UNUSED,     UNUSED) /* 111 INIT_CTOR_CALL                 */
    144 #endif
     181#   endif
    145182
    146183    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 112 INIT_METHOD_CALL               */
    147 #ifdef ZEND_ENGINE_2_3
     184#   ifdef ZEND_ENGINE_2_3
    148185    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */
    149 #else
     186#   else
    150187    OPSPEC(    UNUSED,     UCLASS,        STD,     UNUSED) /* 113 INIT_STATIC_METHOD_CALL        */
    151 #endif
     188#   endif
    152189    OPSPEC(     ISSET,        STD,      FETCH,        TMP) /* 114 ISSET_ISEMPTY_VAR              */
    153190    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 115 ISSET_ISEMPTY_DIM_OBJ          */
     
    181218    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 141 DECLARE_FUNCTION               */
    182219    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 142 RAISE_ABSTRACT_ERROR           */
    183 #ifdef ZEND_ENGINE_2_3
     220#   ifdef ZEND_ENGINE_2_3
    184221    OPSPEC(   DECLARE,        STD,        STD,     UNUSED) /* 143 DECLARE_CONST                  */
    185 #else
     222#   else
    186223    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 143 UNDEF-143                      */
    187 #endif
    188 #ifdef ZEND_ENGINE_2_3
     224#   endif
     225#   ifdef ZEND_ENGINE_2_3
    189226    OPSPEC(     IFACE,      CLASS,        STD,     UNUSED) /* 144 ADD_INTERFACE                  */
    190 #else
     227#   else
    191228    OPSPEC(     IFACE,      CLASS,      CLASS,     UNUSED) /* 144 ADD_INTERFACE                  */
    192 #endif
    193 #ifdef ZEND_ENGINE_2_3
     229#   endif
     230#   ifdef ZEND_ENGINE_2_3
    194231    OPSPEC(     CLASS,        STD,        STD,     OPLINE) /* 145 DECLARE_INHERITED_CLASS_DELAYED */
    195 #else
     232#   else
    196233    OPSPEC(    UNUSED,      CLASS,        STD,     UNUSED) /* 145 VERIFY_INSTANCEOF              */
    197 #endif
     234#   endif
    198235    OPSPEC(    UNUSED,      CLASS,     UNUSED,     UNUSED) /* 146 VERIFY_ABSTRACT_CLASS          */
    199236    OPSPEC(    UNUSED,        STD,        STD,        VAR) /* 147 ASSIGN_DIM                     */
    200237    OPSPEC(     ISSET,        STD,        STD,        TMP) /* 148 ISSET_ISEMPTY_PROP_OBJ         */
    201238    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 149 HANDLE_EXCEPTION               */
    202 #ifdef ZEND_ENGINE_2_1
     239#   ifdef ZEND_ENGINE_2_1
    203240    OPSPEC(       STD,     UNUSED,     UNUSED,        STD) /* 150 USER_OPCODE                    */
    204 #endif
    205 #ifdef ZEND_ENGINE_2_3
     241#   endif
     242#   ifdef ZEND_ENGINE_2_3
    206243    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 151 UNDEF                          */
    207244    OPSPEC(    UNUSED,        STD,    JMPADDR,        TMP) /* 152 JMP_SET                        */
    208245    OPSPEC(    UNUSED,        STD,        STD,        TMP) /* 153 DECLARE_LAMBDA_FUNCTION        */
    209 #endif
    210 #ifdef ZEND_ENGINE_2_4
     246#   endif
     247#   ifdef ZEND_ENGINE_2_4
    211248    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 154 ADD_TRAIT                      */
    212249    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 155 BIND_TRAITS                    */
     
    214251    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 157 QM_ASSIGN_VAR                  */
    215252    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 158 JMP_SET_VAR                    */
    216 #endif
    217 #ifdef ZEND_ENGINE_2_5
     253#   endif
     254#   ifdef ZEND_ENGINE_2_5
    218255    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 159 DISCARD_EXCEPTION              */
    219256    OPSPEC(    UNUSED,        STD,        STD,     UNUSED) /* 160 YIELD                          */
     
    221258    OPSPEC(    UNUSED,    JMPADDR,     UNUSED,     UNUSED) /* 162 FAST_CALL                      */
    222259    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 163 FAST_RET                       */
    223 #endif
     260#   endif
     261#else /* ZEND_ENGINE_2 */
     262    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 107 UNDEF                          */
     263    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 108 UNDEF                          */
     264    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 109 UNDEF                          */
     265    OPSPEC(     FCALL,        STD,     OPLINE,        VAR) /* 61 DO_FCALL_BY_FUNC                */
     266    OPSPEC(INIT_FCALL,        STD,        STD,     UNUSED) /* 111 INIT_FCALL_BY_FUNC             */
     267    OPSPEC(    UNUSED,     UNUSED,     UNUSED,     UNUSED) /* 112 UNDEF                          */
     268#endif /* ZEND_ENGINE_2 */
    224269};
  • trunk/xcache/xc_sandbox.c

    r1281 r1321  
    195195#if 0 && TODO
    196196    {
    197         zend_class_entry *dummy_class_entry;
    198         zend_hash_copy(&TG(class_table), &XG(internal_class_table), NULL, (void *) &dummy_class_entry, sizeof(dummy_class_entry));
     197        xc_cest_t tmp_cest;
     198        zend_hash_copy(&TG(class_table), &XG(internal_class_table), NULL, (void *) &tmp_cest, sizeof(tmp_cest));
    199199    }
    200200#endif
     
    278278    /* install class */
    279279    while (b != NULL) {
    280         xc_install_class(sandbox->filename, *(zend_class_entry **)b->pData, -1,
     280        xc_install_class(sandbox->filename, (xc_cest_t*) b->pData, -1,
    281281                BUCKET_KEY_TYPE(b), ZSTR(BUCKET_KEY_S(b)), b->nKeyLength, b->h TSRMLS_CC);
    282282        b = b->pListNext;
  • trunk/xcache/xc_utils.c

    r1314 r1321  
    7878{
    7979    /* avoid duplicate apply for shadowed method */
     80#ifdef ZEND_ENGINE_2
    8081    if (mi->ce != zf->common.scope) {
    8182        /* fprintf(stderr, "avoided duplicate %s\n", zf->common.function_name); */
    8283        return 0;
    8384    }
     85#else
     86    char *name = zf->common.function_name;
     87    int name_s = strlen(name) + 1;
     88    zend_class_entry *ce;
     89    zend_function *ptr;
     90
     91    for (ce = mi->ce->parent; ce; ce = ce->parent) {
     92        if (zend_hash_find(&ce->function_table, name, name_s, (void **) &ptr) == SUCCESS) {
     93            if (ptr->op_array.refcount == zf->op_array.refcount) {
     94                return 0;
     95            }
     96        }
     97    }
     98#endif
    8499    return xc_apply_function(zf, &mi->fi TSRMLS_CC);
    85100}
    86101/* }}} */
    87 static int xc_apply_class(zend_class_entry **ce, xc_apply_func_info *fi TSRMLS_DC) /* {{{ */
     102static int xc_apply_cest(xc_cest_t *cest, xc_apply_func_info *fi TSRMLS_DC) /* {{{ */
    88103{
    89104    xc_apply_method_info mi;
    90105
    91106    mi.fi = *fi;
    92     mi.ce = *ce;
    93     zend_hash_apply_with_argument(&((*ce)->function_table), (apply_func_arg_t) xc_apply_method, &mi TSRMLS_CC);
     107    mi.ce = CestToCePtr(*cest);
     108    zend_hash_apply_with_argument(&(CestToCePtr(*cest)->function_table), (apply_func_arg_t) xc_apply_method, &mi TSRMLS_CC);
    94109    return 0;
    95110}
     
    100115    fi.applyer = applyer;
    101116    zend_hash_apply_with_argument(cr->function_table, (apply_func_arg_t) xc_apply_function, &fi TSRMLS_CC);
    102     zend_hash_apply_with_argument(cr->class_table, (apply_func_arg_t) xc_apply_class, &fi TSRMLS_CC);
     117    zend_hash_apply_with_argument(cr->class_table, (apply_func_arg_t) xc_apply_cest, &fi TSRMLS_CC);
    103118
    104119    return applyer(cr->op_array TSRMLS_CC);
     
    107122int xc_undo_pass_two(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    108123{
     124#ifdef ZEND_ENGINE_2
    109125    zend_op *opline, *opline_end;
     126#endif
    110127
    111128#ifdef ZEND_ENGINE_2_4
     
    119136#endif
    120137
     138#ifdef ZEND_ENGINE_2
    121139    opline = op_array->opcodes;
    122140    opline_end = opline + op_array->last;
    123141    while (opline < opline_end) {
    124 #ifdef ZEND_ENGINE_2_4
     142#   ifdef ZEND_ENGINE_2_4
    125143        if (opline->op1_type == IS_CONST) {
    126144            opline->op1.constant = opline->op1.literal - op_array->literals;
     
    129147            opline->op2.constant = opline->op2.literal - op_array->literals;
    130148        }
    131 #endif
     149#   endif
    132150
    133151        switch (opline->opcode) {
    134 #ifdef ZEND_GOTO
     152#   ifdef ZEND_GOTO
    135153            case ZEND_GOTO:
    136 #endif
     154#   endif
    137155            case ZEND_JMP:
    138 #ifdef ZEND_FAST_CALL
     156#   ifdef ZEND_FAST_CALL
    139157            case ZEND_FAST_CALL:
    140 #endif
     158#   endif
    141159                assert(Z_OP(opline->op1).jmp_addr >= op_array->opcodes && (zend_uint) (Z_OP(opline->op1).jmp_addr - op_array->opcodes) < op_array->last);
    142160                Z_OP(opline->op1).opline_num = Z_OP(opline->op1).jmp_addr - op_array->opcodes;
     
    146164            case ZEND_JMPZ_EX:
    147165            case ZEND_JMPNZ_EX:
    148 #ifdef ZEND_JMP_SET
     166#   ifdef ZEND_JMP_SET
    149167            case ZEND_JMP_SET:
    150 #endif
    151 #ifdef ZEND_JMP_SET_VAR
     168#   endif
     169#   ifdef ZEND_JMP_SET_VAR
    152170            case ZEND_JMP_SET_VAR:
    153 #endif
     171#   endif
    154172                assert(Z_OP(opline->op2).jmp_addr >= op_array->opcodes && (zend_uint) (Z_OP(opline->op2).jmp_addr - op_array->opcodes) < op_array->last);
    155173                Z_OP(opline->op2).opline_num = Z_OP(opline->op2).jmp_addr - op_array->opcodes;
     
    158176        opline++;
    159177    }
     178#endif /* ZEND_ENGINE_2 */
     179
    160180#ifdef ZEND_ENGINE_2_4
    161181    op_array->fn_flags &= ~ZEND_ACC_DONE_PASS_TWO;
     
    169189int xc_redo_pass_two(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    170190{
     191#ifdef ZEND_ENGINE_2
    171192    zend_op *opline, *opline_end;
     193#endif
    172194#ifdef ZEND_ENGINE_2_4
    173195    zend_literal *literal = op_array->literals;
     
    199221#endif
    200222
     223#ifdef ZEND_ENGINE_2
    201224    opline = op_array->opcodes;
    202225    opline_end = opline + op_array->last;
    203226    while (opline < opline_end) {
    204 #ifdef ZEND_ENGINE_2_4
     227#   ifdef ZEND_ENGINE_2_4
    205228        if (opline->op1_type == IS_CONST) {
    206229            opline->op1.literal = op_array->literals + opline->op1.constant;
     
    209232            opline->op2.literal = op_array->literals + opline->op2.constant;
    210233        }
    211 #else
     234#   else
    212235        if (Z_OP_TYPE(opline->op1) == IS_CONST) {
    213236            Z_SET_ISREF(Z_OP_CONSTANT(opline->op1));
     
    218241            Z_SET_REFCOUNT(Z_OP_CONSTANT(opline->op2), 2);
    219242        }
    220 #endif
     243#   endif
     244        switch (opline->opcode) {
     245#   ifdef ZEND_GOTO
     246            case ZEND_GOTO:
     247#   endif
     248            case ZEND_JMP:
     249#   ifdef ZEND_FAST_CALL
     250            case ZEND_FAST_CALL:
     251#   endif
     252                assert(Z_OP(opline->op1).opline_num < op_array->last);
     253                Z_OP(opline->op1).jmp_addr = op_array->opcodes + Z_OP(opline->op1).opline_num;
     254                break;
     255            case ZEND_JMPZ:
     256            case ZEND_JMPNZ:
     257            case ZEND_JMPZ_EX:
     258            case ZEND_JMPNZ_EX:
     259#   ifdef ZEND_JMP_SET
     260            case ZEND_JMP_SET:
     261#   endif
     262#   ifdef ZEND_JMP_SET_VAR
     263            case ZEND_JMP_SET_VAR:
     264#   endif
     265                assert(Z_OP(opline->op2).opline_num < op_array->last);
     266                Z_OP(opline->op2).jmp_addr = op_array->opcodes + Z_OP(opline->op2).opline_num;
     267                break;
     268        }
     269        /* ZEND_VM_SET_OPCODE_HANDLER(opline); this is not undone, don't redo. only do this for loader */
     270        opline++;
     271    }
     272#endif /* ZEND_ENGINE_2 */
     273
     274#ifdef ZEND_ENGINE_2_4
     275    op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO;
     276#else
     277    op_array->done_pass_two = 1;
     278#endif
     279    return 0;
     280}
     281/* }}} */
     282
     283static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, Z_OP_TYPEOF_TYPE *op_type, znode_op *op, int type TSRMLS_DC) /* {{{ */
     284{
     285#ifdef ZEND_ENGINE_2
     286    if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) ||
     287            spec == OPSPEC_FETCH) {
     288        if (tofix) {
     289            switch (*op_type) {
     290            case IS_VAR:
     291            case IS_TMP_VAR:
     292                break;
     293
     294            default:
     295                /* TODO: data lost, find a way to keep it */
     296                /* assert(*op_type == IS_CONST); */
     297                *op_type = IS_TMP_VAR;
     298            }
     299        }
     300    }
     301    switch (*op_type) {
     302    case IS_TMP_VAR:
     303    case IS_VAR:
     304        if (tofix) {
     305            Z_OP(*op).var /= sizeof(temp_variable);
     306        }
     307        else {
     308            Z_OP(*op).var *= sizeof(temp_variable);
     309        }
     310    }
     311#endif
     312}
     313/* }}} */
     314
     315static void xc_fix_opcode_ex(zend_op_array *op_array, int tofix TSRMLS_DC) /* {{{ */
     316{
     317    zend_op *opline;
     318    zend_uint i;
     319
     320    opline = op_array->opcodes;
     321    for (i = 0; i < op_array->last; i ++, opline ++) {
     322        /* 3rd optimizer may have ... */
     323        if (opline->opcode < xc_get_opcode_spec_count()) {
     324            const xc_opcode_spec_t *spec;
     325            spec = xc_get_opcode_spec(opline->opcode);
     326
     327            xc_fix_opcode_ex_znode(tofix, spec->op1, &Z_OP_TYPE(opline->op1),    &opline->op1, 0 TSRMLS_CC);
     328            xc_fix_opcode_ex_znode(tofix, spec->op2, &Z_OP_TYPE(opline->op2),    &opline->op2, 1 TSRMLS_CC);
     329            xc_fix_opcode_ex_znode(tofix, spec->res, &Z_OP_TYPE(opline->result), &opline->result, 2 TSRMLS_CC);
     330        }
     331    }
     332}
     333/* }}} */
     334int xc_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
     335{
     336    xc_fix_opcode_ex(op_array, 1 TSRMLS_CC);
     337    return 0;
     338}
     339/* }}} */
     340int xc_undo_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
     341{
     342    xc_fix_opcode_ex(op_array, 0 TSRMLS_CC);
     343
     344    return 0;
     345}
     346/* }}} */
     347
     348#ifndef ZEND_COMPILE_DELAYED_BINDING
     349int xc_foreach_early_binding_class(zend_op_array *op_array, xc_foreach_early_binding_class_cb callback, void *data TSRMLS_DC) /* {{{ */
     350{
     351    zend_op *opline, *begin, *opline_end, *next = NULL;
     352
     353    opline = begin = op_array->opcodes;
     354    opline_end = opline + op_array->last;
     355    while (opline < opline_end) {
    221356        switch (opline->opcode) {
    222357#ifdef ZEND_GOTO
     
    227362            case ZEND_FAST_CALL:
    228363#endif
    229                 assert(Z_OP(opline->op1).opline_num < op_array->last);
    230                 Z_OP(opline->op1).jmp_addr = op_array->opcodes + Z_OP(opline->op1).opline_num;
    231                 break;
     364                next = begin + Z_OP(opline->op1).opline_num;
     365                break;
     366
     367            case ZEND_JMPZNZ:
     368                next = begin + max(Z_OP(opline->op2).opline_num, opline->extended_value);
     369                break;
     370
    232371            case ZEND_JMPZ:
    233372            case ZEND_JMPNZ:
     
    240379            case ZEND_JMP_SET_VAR:
    241380#endif
    242                 assert(Z_OP(opline->op2).opline_num < op_array->last);
    243                 Z_OP(opline->op2).jmp_addr = op_array->opcodes + Z_OP(opline->op2).opline_num;
    244                 break;
    245         }
    246         /* ZEND_VM_SET_OPCODE_HANDLER(opline); this is not undone, don't redo. only do this for loader */
    247         opline++;
    248     }
    249 
    250 #ifdef ZEND_ENGINE_2_4
    251     op_array->fn_flags |= ZEND_ACC_DONE_PASS_TWO;
    252 #else
    253     op_array->done_pass_two = 1;
    254 #endif
    255     return 0;
    256 }
    257 /* }}} */
    258 
    259 static void xc_fix_opcode_ex_znode(int tofix, xc_op_spec_t spec, Z_OP_TYPEOF_TYPE *op_type, znode_op *op, int type TSRMLS_DC) /* {{{ */
    260 {
    261     if ((*op_type != IS_UNUSED && (spec == OPSPEC_UCLASS || spec == OPSPEC_CLASS)) ||
    262             spec == OPSPEC_FETCH) {
    263         if (tofix) {
    264             switch (*op_type) {
    265             case IS_VAR:
    266             case IS_TMP_VAR:
    267                 break;
    268 
    269             default:
    270                 /* TODO: data lost, find a way to keep it */
    271                 /* assert(*op_type == IS_CONST); */
    272                 *op_type = IS_TMP_VAR;
    273             }
    274         }
    275     }
    276     switch (*op_type) {
    277     case IS_TMP_VAR:
    278     case IS_VAR:
    279         if (tofix) {
    280             Z_OP(*op).var /= sizeof(temp_variable);
    281         }
    282         else {
    283             Z_OP(*op).var *= sizeof(temp_variable);
    284         }
    285     }
    286 }
    287 /* }}} */
    288 
    289 static void xc_fix_opcode_ex(zend_op_array *op_array, int tofix TSRMLS_DC) /* {{{ */
    290 {
    291     zend_op *opline;
    292     zend_uint i;
    293 
    294     opline = op_array->opcodes;
    295     for (i = 0; i < op_array->last; i ++, opline ++) {
    296         /* 3rd optimizer may have ... */
    297         if (opline->opcode < xc_get_opcode_spec_count()) {
    298             const xc_opcode_spec_t *spec;
    299             spec = xc_get_opcode_spec(opline->opcode);
    300 
    301             xc_fix_opcode_ex_znode(tofix, spec->op1, &Z_OP_TYPE(opline->op1),    &opline->op1, 0 TSRMLS_CC);
    302             xc_fix_opcode_ex_znode(tofix, spec->op2, &Z_OP_TYPE(opline->op2),    &opline->op2, 1 TSRMLS_CC);
    303             xc_fix_opcode_ex_znode(tofix, spec->res, &Z_OP_TYPE(opline->result), &opline->result, 2 TSRMLS_CC);
    304         }
    305     }
    306 }
    307 /* }}} */
    308 int xc_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    309 {
    310     xc_fix_opcode_ex(op_array, 1 TSRMLS_CC);
    311     return 0;
    312 }
    313 /* }}} */
    314 int xc_undo_fix_opcode(zend_op_array *op_array TSRMLS_DC) /* {{{ */
    315 {
    316     xc_fix_opcode_ex(op_array, 0 TSRMLS_CC);
    317 
    318     return 0;
    319 }
    320 /* }}} */
    321 
    322 #ifndef ZEND_COMPILE_DELAYED_BINDING
    323 int xc_foreach_early_binding_class(zend_op_array *op_array, xc_foreach_early_binding_class_cb callback, void *data TSRMLS_DC) /* {{{ */
    324 {
    325     zend_op *opline, *begin, *opline_end, *next = NULL;
    326 
    327     opline = begin = op_array->opcodes;
    328     opline_end = opline + op_array->last;
    329     while (opline < opline_end) {
    330         switch (opline->opcode) {
    331 #ifdef ZEND_GOTO
    332             case ZEND_GOTO:
    333 #endif
    334             case ZEND_JMP:
    335 #ifdef ZEND_FAST_CALL
    336             case ZEND_FAST_CALL:
    337 #endif
    338                 next = begin + Z_OP(opline->op1).opline_num;
    339                 break;
    340 
    341             case ZEND_JMPZNZ:
    342                 next = begin + max(Z_OP(opline->op2).opline_num, opline->extended_value);
    343                 break;
    344 
    345             case ZEND_JMPZ:
    346             case ZEND_JMPNZ:
    347             case ZEND_JMPZ_EX:
    348             case ZEND_JMPNZ_EX:
    349 #ifdef ZEND_JMP_SET
    350             case ZEND_JMP_SET:
    351 #endif
    352 #ifdef ZEND_JMP_SET_VAR
    353             case ZEND_JMP_SET_VAR:
    354 #endif
    355381                next = begin + Z_OP(opline->op2).opline_num;
    356382                break;
     
    360386                break;
    361387
     388#ifdef ZEND_ENGINE_2
    362389            case ZEND_DECLARE_INHERITED_CLASS:
    363390                callback(opline, opline - begin, data TSRMLS_CC);
    364391                break;
     392#else
     393            case ZEND_DECLARE_FUNCTION_OR_CLASS:
     394                if (opline->extended_value == ZEND_DECLARE_INHERITED_CLASS) {
     395                    callback(opline, opline - begin, data TSRMLS_CC);
     396                }
     397                break;
     398#endif
    365399        }
    366400
     
    386420
    387421    switch (opline->opcode) {
     422#ifdef ZEND_ENGINE_2
    388423    case ZEND_DECLARE_INHERITED_CLASS:
    389424        {
     
    434469            ZEND_VM_SET_OPCODE_HANDLER(abstract_op);
    435470        }
     471#else
     472    case ZEND_DECLARE_FUNCTION_OR_CLASS:
     473        if (do_bind_function_or_class(opline, NULL, class_table, 1) == FAILURE) {
     474            return FAILURE;
     475        }
     476#endif
    436477        break;
    437478
     
    495536                    NULL
    496537                    ) == FAILURE) {
    497             CG(zend_lineno) = func->op_array.line_start;
     538            CG(zend_lineno) = ZESW(func->op_array.opcodes[0].lineno, func->op_array.line_start);
    498539#ifdef IS_UNICODE
    499540            zend_error(E_ERROR, "Cannot redeclare %R()", type, key);
     
    505546}
    506547/* }}} */
    507 void xc_install_class(ZEND_24(NOTHING, const) char *filename, zend_class_entry *ce, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */
     548ZESW(xc_cest_t *, void) xc_install_class(ZEND_24(NOTHING, const) char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC) /* {{{ */
    508549{
    509550    zend_bool istmpkey;
     551    zend_class_entry *cep = CestToCePtr(*cest);
     552    ZESW(void *stored_ce_ptr, NOTHING);
    510553
    511554#ifdef IS_UNICODE
     
    516559    if (istmpkey) {
    517560        zend_u_hash_quick_update(CG(class_table), type, key, len, h,
    518                     &ce, sizeof(zend_class_entry *),
    519                     NULL
     561                    cest, sizeof(xc_cest_t),
     562                    ZESW(&stored_ce_ptr, NULL)
    520563                    );
    521564#ifndef ZEND_COMPILE_DELAYED_BINDING
     
    526569    }
    527570    else if (zend_u_hash_quick_add(CG(class_table), type, key, len, h,
    528                 &ce, sizeof(zend_class_entry *),
    529                 NULL
     571                cest, sizeof(xc_cest_t),
     572                ZESW(&stored_ce_ptr, NULL)
    530573                ) == FAILURE) {
    531         CG(zend_lineno) = Z_CLASS_INFO(*ce).line_start;
     574        CG(zend_lineno) = ZESW(0, Z_CLASS_INFO(*cep).line_start);
    532575#ifdef IS_UNICODE
    533         zend_error(E_ERROR, "Cannot redeclare class %R", type, ce->name);
    534 #else
    535         zend_error(E_ERROR, "Cannot redeclare class %s", ce->name);
     576        zend_error(E_ERROR, "Cannot redeclare class %R", type, cep->name);
     577#else
     578        zend_error(E_ERROR, "Cannot redeclare class %s", cep->name);
    536579#endif
    537580        assert(oplineno == -1);
    538581    }
     582    ZESW(return (xc_cest_t *) stored_ce_ptr, NOTHING);
    539583}
    540584/* }}} */
  • trunk/xcache/xc_utils.h

    r1313 r1321  
    4343#endif
    4444void xc_install_function(ZEND_24(NOTHING, const) char *filename, zend_function *func, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC);
    45 void xc_install_class(ZEND_24(NOTHING, const) char *filename, zend_class_entry *class_entry, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC);
     45ZESW(xc_cest_t *, void) xc_install_class(ZEND_24(NOTHING, const) char *filename, xc_cest_t *cest, int oplineno, zend_uchar type, const24_zstr key, uint len, ulong h TSRMLS_DC);
    4646
    4747typedef zend_bool (*xc_if_func_t)(void *data);
Note: See TracChangeset for help on using the changeset viewer.