Changeset 1321 in svn for trunk/xcache/xc_utils.c


Ignore:
Timestamp:
2013-07-15T19:37:57+02:00 (23 months ago)
Author:
Xuefer
Message:

add back PHP_4 code for disassembler

File:
1 edited

Legend:

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