Ignore:
Timestamp:
2013-07-15T19:37:57+02:00 (16 months ago)
Author:
moo
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.