source: trunk/processor/processor.m4 @ 710

Last change on this file since 710 was 710, checked in by moo, 4 years ago

partial fix for decompiling 5.3

  • Property svn:eol-style set to native
File size: 23.1 KB
RevLine 
[1]1dnl ================
2/* {{{ Pre-declare */
3DECL_STRUCT_P_FUNC(`zval')
4DECL_STRUCT_P_FUNC(`zval_ptr')
5DECL_STRUCT_P_FUNC(`zend_op_array')
6DECL_STRUCT_P_FUNC(`zend_class_entry')
[95]7#ifdef HAVE_XCACHE_CONSTANT
8DECL_STRUCT_P_FUNC(`zend_constant')
9#endif
[1]10DECL_STRUCT_P_FUNC(`zend_function')
11DECL_STRUCT_P_FUNC(`xc_entry_t')
12#ifdef ZEND_ENGINE_2
13DECL_STRUCT_P_FUNC(`zend_property_info')
14#endif
15/* }}} */
16dnl ====================================================
17dnl {{{ zend_compiled_variable
18#ifdef IS_CV
19DEF_STRUCT_P_FUNC(`zend_compiled_variable', , `
20    DISPATCH(int, name_len)
[103]21    PROC_ZSTRING_L(, name, name_len)
[1]22    DISPATCH(ulong, hash_value)
23')
24#endif
25dnl }}}
26dnl {{{ zend_uint
27DEF_STRUCT_P_FUNC(`zend_uint', , `
28    IFCOPY(`dst[0] = src[0];')
29    IFDPRINT(`
30        INDENT()
31        fprintf(stderr, "%u\n", src[0]);
32    ')
33    DONE_SIZE(sizeof(src[0]))
34')
35dnl }}}
36dnl {{{ int
37#ifndef ZEND_ENGINE_2
38DEF_STRUCT_P_FUNC(`int', , `
39    IFCOPY(`*dst = *src;')
40    IFDPRINT(`
41        INDENT()
42        fprintf(stderr, "%d\n", src[0]);
43    ')
44    DONE_SIZE(sizeof(src[0]))
45')
46#endif
47dnl }}}
48dnl {{{ zend_try_catch_element
49#ifdef ZEND_ENGINE_2
50DEF_STRUCT_P_FUNC(`zend_try_catch_element', , `
51    DISPATCH(zend_uint, try_op)
52    DISPATCH(zend_uint, catch_op)
53')
54#endif /* ifdef ZEND_ENGINE_2 */
55dnl }}}
56dnl {{{ zend_brk_cont_element
57DEF_STRUCT_P_FUNC(`zend_brk_cont_element', , `
[194]58#ifdef ZEND_ENGINE_2_2
59    DISPATCH(int, start)
60#endif
[1]61    DISPATCH(int, cont)
62    DISPATCH(int, brk)
63    DISPATCH(int, parent)
64')
65dnl }}}
66DEF_HASH_TABLE_FUNC(`HashTable_zval_ptr',           `zval_ptr')
67DEF_HASH_TABLE_FUNC(`HashTable_zend_function',      `zend_function')
68#ifdef ZEND_ENGINE_2
69DEF_HASH_TABLE_FUNC(`HashTable_zend_property_info', `zend_property_info')
70#endif
71DEF_STRUCT_P_FUNC(`zval', , `dnl {{{
72    IFDASM(`do {
73        zval_dtor(dst);
74        *dst = *src;
75        zval_copy_ctor(dst);
[487]76        Z_SET_REFCOUNT(*dst, 1);
[710]77        switch ((Z_TYPE_P(src) & IS_CONSTANT_TYPE_MASK)) {
78        case IS_CONSTANT:
79            dst->type = UNISW(IS_STRING, UG(unicode) ? IS_UNICODE : IS_STRING);
80            break;
81        case IS_CONSTANT_ARRAY:
82            dst->type = IS_ARRAY;
83            break;
84        }
[1]85        DONE(value)
86        DONE(type)
[485]87#ifdef ZEND_ENGINE_2_3
88        DONE(is_ref__gc)
89        DONE(refcount__gc)
90#else
[1]91        DONE(is_ref)
[485]92        DONE(refcount)
[482]93#endif
[1]94    } while(0);
95    return;
96    ', `
97        dnl IFDASM else
98        /* Variable information */
99dnl {{{ zvalue_value
100        DISABLECHECK(`
[491]101        switch ((Z_TYPE_P(src) & IS_CONSTANT_TYPE_MASK)) {
[1]102            case IS_LONG:
103            case IS_RESOURCE:
104            case IS_BOOL:
105                DISPATCH(long, value.lval)
106                break;
107            case IS_DOUBLE:
108                DISPATCH(double, value.dval)
109                break;
110            case IS_NULL:
111                IFDPRINT(`INDENT()`'fprintf(stderr, "\tNULL\n");')
112                break;
113
114            case IS_CONSTANT:
115#ifdef IS_UNICODE
116                if (UG(unicode)) {
117                    goto proc_unicode;
118                }
119#endif
120            case IS_STRING:
121#ifdef FLAG_IS_BC
122            case FLAG_IS_BC:
123#endif
124                DISPATCH(int, value.str.len)
125                PROC_STRING_L(value.str.val, value.str.len)
126                break;
127#ifdef IS_UNICODE
128            case IS_UNICODE:
129proc_unicode:
[103]130                DISPATCH(int32_t, value.uni.len)
131                PROC_ZSTRING_L(1, value.uni.val, value.uni.len)
[1]132                break;
133#endif
134
135            case IS_ARRAY:
136            case IS_CONSTANT_ARRAY:
137                STRUCT_P(HashTable, value.ht, HashTable_zval_ptr)
138                break;
139
140            case IS_OBJECT:
141                IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')')
142                dnl STRUCT(value.obj)
143#ifndef ZEND_ENGINE_2
144                STRUCT_P(zend_class_entry, value.obj.ce)
145                STRUCT_P(HashTable, value.obj.properties, HashTable_zval_ptr)
146#endif
147                break;
148
149            default:
150                assert(0);
151        }
152        ')
153dnl }}}
154        DONE(value)
155        DISPATCH(zval_data_type, type)
[485]156#ifdef ZEND_ENGINE_2_3
157        DISPATCH(zend_uchar, is_ref__gc)
158#else
[1]159        DISPATCH(zend_uchar, is_ref)
[485]160#endif
161
162#ifdef ZEND_ENGINE_2_3
163        DISPATCH(zend_uint, refcount__gc)
164#elif defined(ZEND_ENGINE_2)
[484]165        DISPATCH(zend_uint, refcount)
166#else
[1]167        DISPATCH(zend_ushort, refcount)
[484]168#endif
[1]169    ')dnl IFDASM
170')
171dnl }}}
172DEF_STRUCT_P_FUNC(`zval_ptr', , `dnl {{{
173    IFDASM(`
174        pushdefFUNC_NAME(`zval')
175        FUNC_NAME (dst, src[0] TSRMLS_CC);
176        popdef(`FUNC_NAME')
177    ', `
178        do {
179            IFCALCCOPY(`
180                if (processor->reference) {
181                    zval_ptr *ppzv;
[231]182                    if (zend_hash_find(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void **) &ppzv) == SUCCESS) {
[1]183                        IFCOPY(`
184                            dst[0] = *ppzv;
185                            /* *dst is updated */
[248]186                            dnl fprintf(stderr, "*dst is set to %p, KIND is_shm %d\n", dst[0], xc_is_shm(dst[0]));
[1]187                        ')
[233]188                        IFCALCSTORE(`processor->have_references = 1;')
[1]189                        IFSTORE(`assert(xc_is_shm(dst[0]));')
190                        IFRESTORE(`assert(!xc_is_shm(dst[0]));')
191                        break;
192                    }
193                }
194            ')
195           
196            ALLOC(dst[0], zval)
197            IFCALCCOPY(`
198                if (processor->reference) {
199                    IFCALC(`
200                        /* make dummy */
201                        zval_ptr pzv = (zval_ptr)-1;
202                    ', `
203                        zval_ptr pzv = dst[0];
[248]204                        FIXPOINTER_EX(zval, pzv)
[1]205                    ')
[231]206                    if (zend_hash_add(&processor->zvalptrs, (char *) &src[0], sizeof(src[0]), (void *) &pzv, sizeof(pzv), NULL) == SUCCESS) {
[1]207                        /* first add, go on */
208                        dnl fprintf(stderr, "mark[%p] = %p\n", src[0], pzv);
209                    }
210                    else {
211                        assert(0);
212                    }
213                }
214            ')
215            IFCOPY(`
216                dnl fprintf(stderr, "copy from %p to %p\n", src[0], dst[0]);
217            ')
[534]218            IFDPRINT(`INDENT()`'fprintf(stderr, "[%p] ", src[0]);')
[4]219            STRUCT_P_EX(zval, dst[0], src[0], `[0]', `', ` ')
[248]220            FIXPOINTER_EX(zval, dst[0])
[1]221        } while (0);
222    ')
223    DONE_SIZE(sizeof(zval_ptr))
224')
225dnl }}}
226dnl {{{ zend_arg_info
227#ifdef ZEND_ENGINE_2
228DEF_STRUCT_P_FUNC(`zend_arg_info', , `
229    DISPATCH(zend_uint, name_len)
[645]230    PROC_ZSTRING_L(, name, name_len)
[1]231    DISPATCH(zend_uint, class_name_len)
[645]232    PROC_ZSTRING_L(, class_name, class_name_len)
[1]233    DISPATCH(zend_bool, array_type_hint)
234    DISPATCH(zend_bool, allow_null)
235    DISPATCH(zend_bool, pass_by_reference)
236    DISPATCH(zend_bool, return_reference)
237    DISPATCH(int, required_num_args)
238')
239#endif
240dnl }}}
[95]241#ifdef HAVE_XCACHE_CONSTANT
242DEF_STRUCT_P_FUNC(`zend_constant', , `dnl {{{
243    STRUCT(zval, value)
244    DISPATCH(int, flags)
245    DISPATCH(uint, name_len)
[218]246    pushdef(`emalloc', `malloc($1)')
247    pushdef(`ecalloc', `calloc($1, $2)')
[505]248    PROC_ZSTRING_N(, name, name_len)
[218]249    popdef(`ecalloc')
250    popdef(`emalloc')
[95]251    DISPATCH(int, module_number)
252')
253dnl }}}
254#endif
[1]255DEF_STRUCT_P_FUNC(`zend_function', , `dnl {{{
256    DISABLECHECK(`
257    switch (src->type) {
258    case ZEND_INTERNAL_FUNCTION:
259    case ZEND_OVERLOADED_FUNCTION:
260        IFNOTMEMCPY(`IFCOPY(`memcpy(dst, src, sizeof(src[0]));')')
261        break;
262
263    case ZEND_USER_FUNCTION:
264    case ZEND_EVAL_CODE:
265        DONE(type)
266        STRUCT(zend_op_array, op_array)
267        break;
268
269    default:
270        assert(0);
271    }
272    ')
273    DONE_SIZE(sizeof(src[0]))
274')
275dnl }}}
276dnl {{{ zend_property_info
277#ifdef ZEND_ENGINE_2
278DEF_STRUCT_P_FUNC(`zend_property_info', , `
279    DISPATCH(zend_uint, flags)
280    DISPATCH(int, name_length)
[103]281    PROC_ZSTRING_L(, name, name_length)
[1]282    DISPATCH(ulong, h)
[56]283#ifdef ZEND_ENGINE_2_1
[1]284    DISPATCH(int, doc_comment_len)
[272]285    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
[56]286#endif
[78]287    dnl isnt in php6 yet
[504]288#if defined(ZEND_ENGINE_2_2)
[78]289    PROC_CLASS_ENTRY_P(ce)
290#endif
[1]291')
292#endif
293dnl }}}
294DEF_STRUCT_P_FUNC(`zend_class_entry', , `dnl {{{
[199]295    IFCALCCOPY(`
[1]296        processor->active_class_entry_src = src;
[199]297        IFCOPY(`processor->active_class_entry_dst = dst;')
[1]298    ')
299    DISPATCH(char, type)
300    DISPATCH(zend_uint, name_length)
[103]301    PROC_ZSTRING_L(, name, name_length)
[1]302    IFRESTORE(`
303#ifndef ZEND_ENGINE_2
304        /* just copy parent and resolve on install_class */
305        COPY(parent)
306#else
307        PROC_CLASS_ENTRY_P(parent)
308#endif
309    ', `
310        PROC_CLASS_ENTRY_P(parent)
311    ')
312#ifdef ZEND_ENGINE_2
313    DISPATCH(int, refcount)
314#else
315    STRUCT_P(int, refcount)
316#endif
317    DISPATCH(zend_bool, constants_updated)
318#ifdef ZEND_ENGINE_2
319    DISPATCH(zend_uint, ce_flags)
320#endif
321
322    STRUCT(HashTable, default_properties, HashTable_zval_ptr)
323    IFCOPY(`dst->builtin_functions = src->builtin_functions;')
324    DONE(builtin_functions)
325#ifdef ZEND_ENGINE_2
326    STRUCT(HashTable, properties_info, HashTable_zend_property_info)
327#   ifdef ZEND_ENGINE_2_1
[233]328    STRUCT(HashTable, default_static_members, HashTable_zval_ptr)
[1]329    IFCOPY(`dst->static_members = &dst->default_static_members;')
330    DONE(static_members)
331#   else
[233]332    STRUCT_P(HashTable, static_members, HashTable_zval_ptr)
[1]333#   endif
334    STRUCT(HashTable, constants_table, HashTable_zval_ptr)
335
336    dnl runtime binding: ADD_INTERFACE will deal with it
337    IFRESTORE(`
338        if (src->num_interfaces) {
339            CALLOC(dst->interfaces, zend_class_entry*, src->num_interfaces)
[4]340            DONE(`interfaces')
[1]341        }
342        else {
[4]343            COPYNULL(interfaces)
[1]344        }
345    ')
346    IFDASM(`
347        if (src->num_interfaces) {
348            /*
[662]349            int i;
[1]350            zval *arr;
351            ALLOC_INIT_ZVAL(arr);
352            array_init(arr);
353            for (i = 0; i < src->num_interfaces; i ++) {
354                zval *zv;
355                ALLOC_INIT_ZVAL(zv);
356                ZVAL_STRING(src->num_interfaces);
357            }
358            add_assoc_zval_ex(dst, ZEND_STRS("interfaces"), arr);
359            */
[4]360            DONE(`interfaces')
[1]361        }
362        else {
[4]363            COPYNULL(interfaces)
[1]364        }
365    ')
[4]366    IFRESTORE(`', `
367        IFDASM(`', `
368            DONE(`interfaces')
369        ')
370    ')
[1]371    DISPATCH(zend_uint, num_interfaces)
372
[687]373    IFRESTORE(`dst->filename = processor->entry_src->filepath;DONE(filename)', `PROC_STRING(filename)')
[1]374    DISPATCH(zend_uint, line_start)
375    DISPATCH(zend_uint, line_end)
376#ifdef ZEND_ENGINE_2_1
377    DISPATCH(zend_uint, doc_comment_len)
[272]378    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
[1]379#endif
380    /* # NOT DONE */
381    COPY(serialize_func)
382    COPY(unserialize_func)
383    COPY(iterator_funcs)
384    COPY(create_object)
385    COPY(get_iterator)
386    COPY(interface_gets_implemented)
[480]387#ifdef ZEND_ENGINE_2_3
388    COPY(get_static_method)
389#endif
[1]390    COPY(serialize)
391    COPY(unserialize)
392    /* deal with it inside xc_fix_method */
393    SETNULL(constructor)
394    COPY(destructor)
395    COPY(clone)
396    COPY(__get)
397    COPY(__set)
398/* should be >5.1 */
399#ifdef ZEND_ENGINE_2_1
400    COPY(__unset)
401    COPY(__isset)
[94]402# if defined(ZEND_ENGINE_2_2) || PHP_MAJOR_VERSION >= 6
[1]403    COPY(__tostring)
404# endif
405#endif
406    COPY(__call)
[480]407#ifdef ZEND_CALLSTATIC_FUNC_NAME
408    COPY(__callstatic)
409#endif
[1]410    /* # NOT DONE */
411    COPY(module)
412#else
413    COPY(handle_function_call)
414    COPY(handle_property_get)
415    COPY(handle_property_set)
416#endif
[89]417    dnl must do after SETNULL(constructor) and dst->parent
[1]418    STRUCT(HashTable, function_table, HashTable_zend_function)
[99]419    IFRESTORE(`dst->function_table.pDestructor = ZEND_FUNCTION_DTOR;')
[199]420    IFCALCCOPY(`
[89]421        processor->active_class_entry_src = NULL;
[199]422        IFCOPY(`processor->active_class_entry_dst = NULL;')
[89]423    ')
[1]424')
425dnl }}}
426DEF_STRUCT_P_FUNC(`znode', , `dnl {{{
427    DISPATCH(int, op_type)
428
429#ifdef IS_CV
[11]430#   define XCACHE_IS_CV IS_CV
[1]431#else
[11]432/* compatible with zend optimizer */
433#   define XCACHE_IS_CV 16
[1]434#endif
[11]435    assert(src->op_type == IS_CONST ||
436        src->op_type == IS_VAR ||
437        src->op_type == XCACHE_IS_CV ||
[1]438        src->op_type == IS_TMP_VAR ||
439        src->op_type == IS_UNUSED);
440    dnl dirty dispatch
441    DISABLECHECK(`
442    switch (src->op_type) {
443        case IS_CONST:
444            STRUCT(zval, u.constant)
445            break;
446        IFCOPY(`
447            IFNOTMEMCPY(`
448                default:
449                    memcpy(&dst->u, &src->u, sizeof(src->u));
450            ')
451        ', `
452        case IS_VAR:
453        case IS_TMP_VAR:
[310]454        case XCACHE_IS_CV:
[1]455            DISPATCH(zend_uint, u.var)
456            DISPATCH(zend_uint, u.EA.type)
457            break;
458        case IS_UNUSED:
459            IFDASM(`DISPATCH(zend_uint, u.var)')
460            DISPATCH(zend_uint, u.opline_num)
461#ifndef ZEND_ENGINE_2
462            DISPATCH(zend_uint, u.fetch_type)
463#endif
464            DISPATCH(zend_uint, u.EA.type)
465            break;
466        ')
467    }
468    ')
469    DONE(u)
[310]470#undef XCACHE_IS_CV
[1]471')
472dnl }}}
473DEF_STRUCT_P_FUNC(`zend_op', , `dnl {{{
474    DISPATCH(zend_uchar, opcode)
475    STRUCT(znode, result)
476    STRUCT(znode, op1)
477    STRUCT(znode, op2)
478    DISPATCH(ulong, extended_value)
479    DISPATCH(uint, lineno)
480#ifdef ZEND_ENGINE_2_1
481    IFCOPY(`
482        switch (src->opcode) {
[515]483#ifdef ZEND_GOTO
484            case ZEND_GOTO:
485#endif
[1]486            case ZEND_JMP:
487                dst->op1.u.jmp_addr = processor->active_opcodes_dst + (src->op1.u.jmp_addr - processor->active_opcodes_src);
488                break;
489
490            case ZEND_JMPZ:
491            case ZEND_JMPNZ:
492            case ZEND_JMPZ_EX:
493            case ZEND_JMPNZ_EX:
[485]494#ifdef ZEND_JMP_SET
495            case ZEND_JMP_SET:
496#endif
[1]497                dst->op2.u.jmp_addr = processor->active_opcodes_dst + (src->op2.u.jmp_addr - processor->active_opcodes_src);
498                break;
499
500            default:
501                break;
502        }
503    ')
504    DISPATCH(opcode_handler_t, handler)
505#endif
506')
507dnl }}}
508DEF_STRUCT_P_FUNC(`zend_op_array', , `dnl {{{
509    IFRESTORE(`
[662]510    const xc_op_array_info_t *op_array_info = &processor->active_op_array_infos_src[processor->active_op_array_index];
[212]511    dnl shadow copy must NOT meet:
512    dnl readonly_protection=on
513    dnl main op_array && have early binding
[548]514#ifdef ZEND_COMPILE_DELAYED_BINDING
515    zend_bool need_early_binding = 0;
516#else
517    zend_bool need_early_binding = processor->php_src->have_early_binding;
518#endif
[662]519    zend_bool shallow_copy = !processor->readonly_protection && !(src == processor->php_src->op_array && need_early_binding);
520    if (shallow_copy) {
521        zend_bool gc_arg_info = 0;
522        int gc_opcodes        = 0;
[1]523        /* really fast shallow copy */
524        memcpy(dst, src, sizeof(src[0]));
525        dst->refcount[0] = 1000;
526        /* deep */
527        STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
[508]528#ifdef ZEND_ENGINE_2
[662]529        STRUCT_ARRAY(num_args, zend_arg_info, arg_info)
530        gc_arg_info = 1;
[508]531#endif
[687]532        IFRESTORE(`dst->filename = processor->entry_src->filepath;')
[662]533        if (op_array_info->oplineinfo_cnt) {
534            gc_opcodes = 1;
535            COPY_N_EX(last, zend_op, opcodes)
536        }
537        if (gc_arg_info || gc_opcodes) {
538            xc_gc_op_array_t gc_op_array;
539#ifdef ZEND_ENGINE_2
540            gc_op_array.num_args = gc_arg_info ? dst->num_args : 0;
541            gc_op_array.arg_info = gc_arg_info ? dst->arg_info : NULL;
542#endif
543            gc_op_array.last     = gc_opcodes > 1 ? dst->last : 0;
544            gc_op_array.opcodes  = gc_opcodes ? dst->opcodes : NULL;
545            xc_gc_add_op_array(&gc_op_array TSRMLS_CC);
546        }
[1]547        define(`SKIPASSERT_ONCE')
548    }
549    else
550    ')
551    do {
552    dnl RESTORE is done above!
553
554    /* Common elements */
555    DISPATCH(zend_uchar, type)
[103]556    PROC_ZSTRING(, function_name)
[1]557#ifdef ZEND_ENGINE_2
558    DISPATCH(zend_uint, fn_flags)
[662]559    STRUCT_ARRAY(num_args, zend_arg_info, arg_info)
[1]560    DISPATCH(zend_uint, num_args)
561    DISPATCH(zend_uint, required_num_args)
562    DISPATCH(zend_bool, pass_rest_by_reference)
563#else
564    if (src->arg_types) {
565        ALLOC(dst->arg_types, zend_uchar, src->arg_types[0] + 1)
566        IFCOPY(`memcpy(dst->arg_types, src->arg_types, sizeof(src->arg_types[0]) * (src->arg_types[0]+1));')
567        IFDASM(`do {
568            int i;
569            zval *zv;
570            ALLOC_INIT_ZVAL(zv);
571            array_init(zv);
572            for (i = 0; i < src->arg_types[0]; i ++) {
573                add_next_index_long(zv, src->arg_types[i + 1]);
574            }
575            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
576        } while (0);')
577        DONE(arg_types)
578    }
579    else {
580        IFDASM(`do {
581            /* empty array */
582            zval *zv;
583            ALLOC_INIT_ZVAL(zv);
584            array_init(zv);
585            add_assoc_zval_ex(dst, ZEND_STRS("arg_types"), zv);
586        } while (0);
587        DONE(arg_types)
588        ', `
589        COPYNULL(arg_types)
590        ')
591    }
592#endif
593    DISPATCH(unsigned char, return_reference)
594    /* END of common elements */
595#ifdef IS_UNICODE
[103]596    dnl SETNULL(u_twin)
[1]597#endif
598
599    STRUCT_P(zend_uint, refcount)
600    UNFIXPOINTER(zend_uint, refcount)
[221]601    IFSTORE(`dst->refcount[0] = 1;')
[1]602
603    pushdef(`AFTER_ALLOC', `IFCOPY(`
604        processor->active_opcodes_dst = dst->opcodes;
605        processor->active_opcodes_src = src->opcodes;
606    ')')
[662]607    STRUCT_ARRAY(last, zend_op, opcodes)
[1]608    popdef(`AFTER_ALLOC')
609    DISPATCH(zend_uint, last)
610    IFCOPY(`dst->size = src->last;DONE(size)', `DISPATCH(zend_uint, size)')
611
612#ifdef IS_CV
613    STRUCT_ARRAY(last_var, zend_compiled_variable, vars)
614    DISPATCH(int, last_var)
615    IFCOPY(`dst->size_var = src->last_var;DONE(size_var)', `DISPATCH(zend_uint, size_var)')
616#else
617    dnl zend_cv.m4 is illegal to be made public, don not ask me for it
618    IFDASM(`
[4]619        sinclude(srcdir`/processor/zend_cv.m4')
[1]620        ')
621#endif
622
623    DISPATCH(zend_uint, T)
624
[662]625    STRUCT_ARRAY(last_brk_cont, zend_brk_cont_element, brk_cont_array)
[1]626    DISPATCH(zend_uint, last_brk_cont)
627    DISPATCH(zend_uint, current_brk_cont)
628#ifndef ZEND_ENGINE_2
629    DISPATCH(zend_bool, uses_globals)
630#endif
631
632#ifdef ZEND_ENGINE_2
633    STRUCT_ARRAY(last_try_catch, zend_try_catch_element, try_catch_array)
634    DISPATCH(int, last_try_catch)
635#endif
636
637    STRUCT_P(HashTable, static_variables, HashTable_zval_ptr)
638
[95]639    COPY(start_op)
[1]640    DISPATCH(int, backpatch_count)
[562]641#ifdef ZEND_ENGINE_2_3
642    DISPATCH(zend_uint, this_var)
643#endif
[1]644
645    DISPATCH(zend_bool, done_pass_two)
[562]646    /* 5.0 <= ver < 5.3 */
647#if defined(ZEND_ENGINE_2) && !defined(ZEND_ENGINE_2_3)
[1]648    DISPATCH(zend_bool, uses_this)
649#endif
650
[687]651    IFRESTORE(`dst->filename = processor->entry_src->filepath;DONE(filename)', `PROC_STRING(filename)')
[1]652#ifdef IS_UNICODE
[267]653    IFRESTORE(`
654        COPY(script_encoding)
655    ', `
656        PROC_STRING(script_encoding)
657    ')
[1]658#endif
659#ifdef ZEND_ENGINE_2
660    DISPATCH(zend_uint, line_start)
661    DISPATCH(zend_uint, line_end)
662    DISPATCH(int, doc_comment_len)
[272]663    PROC_ZSTRING_L(, doc_comment, doc_comment_len)
[1]664#endif
[548]665#ifdef ZEND_COMPILE_DELAYED_BINDING
666    DISPATCH(zend_uint, early_binding);
667#endif
[1]668
669    /* reserved */
670    DONE(reserved)
671#if defined(HARDENING_PATCH) && HARDENING_PATCH
672    DISPATCH(zend_bool, created_by_eval)
673#endif
674    } while (0);
[684]675    IFRESTORE(`xc_fix_op_array_info(processor->entry_src, processor->php_src, dst, !shallow_copy, op_array_info TSRMLS_CC);')
[189]676
[219]677#ifdef ZEND_ENGINE_2
678    dnl mark it as -1 on store, and lookup parent on restore
679    IFSTORE(`dst->prototype = (processor->active_class_entry_src && src->prototype) ? (zend_function *) -1 : NULL; DONE(prototype)', `
680            IFRESTORE(`do {
681                zend_function *parent;
682                if (src->prototype != NULL
683                 && zend_u_hash_find(&(processor->active_class_entry_dst->parent->function_table),
684                        UG(unicode) ? IS_UNICODE : IS_STRING,
[513]685                        src->function_name, xc_zstrlen(UG(unicode) ? IS_UNICODE : IS_STRING, src->function_name) + 1,
[219]686                        (void **) &parent) == SUCCESS) {
687                    /* see do_inherit_method_check() */
688                    if ((parent->common.fn_flags & ZEND_ACC_ABSTRACT)) {
689                      dst->prototype = parent;
690                    } else if (!(parent->common.fn_flags & ZEND_ACC_CTOR) || (parent->common.prototype && (parent->common.prototype->common.scope->ce_flags & ZEND_ACC_INTERFACE))) {
691                        /* ctors only have a prototype if it comes from an interface */
692                        dst->prototype = parent->common.prototype ? parent->common.prototype : parent;
693                    }
694                    else {
695                        dst->prototype = NULL;
696                    }
697                }
698                else {
699                    dst->prototype = NULL;
700                }
701                DONE(prototype)
702            } while (0);
703            ', `
704                COPYNULL(prototype)
705            ')
706    ')
707#endif
708
[189]709#ifdef ZEND_ENGINE_2
[507]710    PROC_CLASS_ENTRY_P(scope)
711    IFCOPY(`
[219]712        if (src->scope) {
[507]713            xc_fix_method(processor, dst TSRMLS_CC);
[189]714        }
715    ')
[507]716#endif
[189]717
718    IFRESTORE(`
719        if (xc_have_op_array_ctor) {
720            zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) xc_zend_extension_op_array_ctor_handler, dst TSRMLS_CC);
721        }
722    ')
[1]723')
724dnl }}}
725
[95]726#ifdef HAVE_XCACHE_CONSTANT
727DEF_STRUCT_P_FUNC(`xc_constinfo_t', , `dnl {{{
728    DISPATCH(zend_uint, key_size)
729#ifdef IS_UNICODE
730    DISPATCH(zend_uchar, type)
731#endif
732    IFRESTORE(`COPY(key)', `
[103]733        PROC_ZSTRING_N(type, key, key_size)
[95]734    ')
[506]735    DISPATCH(ulong, h)
[95]736    STRUCT(zend_constant, constant)
737')
738dnl }}}
739#endif
[662]740DEF_STRUCT_P_FUNC(`xc_op_array_info_t', , `dnl {{{
741    DISPATCH(zend_uint, oplineinfo_cnt)
742    DISPATCH_ARRAY(oplineinfo_cnt, int, oplineinfos)
743')
744dnl }}}
[1]745DEF_STRUCT_P_FUNC(`xc_funcinfo_t', , `dnl {{{
746    DISPATCH(zend_uint, key_size)
747#ifdef IS_UNICODE
748    DISPATCH(zend_uchar, type)
749#endif
750    IFRESTORE(`COPY(key)', `
[103]751        PROC_ZSTRING_N(type, key, key_size)
[1]752    ')
[506]753    DISPATCH(ulong, h)
[662]754    IFRESTORE(`COPY(op_array_info)', `
755        STRUCT(xc_op_array_info_t, op_array_info)
756    ')
757    IFRESTORE(`
[666]758        processor->active_op_array_infos_src = &src->op_array_info;
[662]759        processor->active_op_array_index = 0;
760    ')
[1]761    STRUCT(zend_function, func)
762')
763dnl }}}
764DEF_STRUCT_P_FUNC(`xc_classinfo_t', , `dnl {{{
765    DISPATCH(zend_uint, key_size)
766#ifdef IS_UNICODE
767    DISPATCH(zend_uchar, type)
768#endif
769    IFRESTORE(`COPY(key)', `
[103]770        PROC_ZSTRING_N(type, key, key_size)
[1]771    ')
[506]772    DISPATCH(ulong, h)
[662]773    DISPATCH(zend_uint, methodinfo_cnt)
774    IFRESTORE(`COPY(methodinfos)', `
775        STRUCT_ARRAY(methodinfo_cnt, xc_op_array_info_t, methodinfos)
776    ')
777    IFRESTORE(`
[666]778        processor->active_op_array_infos_src = src->methodinfos;
[662]779        processor->active_op_array_index = 0;
780    ')
[1]781#ifdef ZEND_ENGINE_2
782    STRUCT_P(zend_class_entry, cest)
783#else
784    STRUCT(zend_class_entry, cest)
785#endif
[548]786#ifndef ZEND_COMPILE_DELAYED_BINDING
[212]787    DISPATCH(int, oplineno)
[548]788#endif
[1]789')
790dnl }}}
[268]791#ifdef ZEND_ENGINE_2_1
792DEF_STRUCT_P_FUNC(`xc_autoglobal_t', , `dnl {{{
793    DISPATCH(zend_uint, key_len)
794#ifdef IS_UNICODE
795    DISPATCH(zend_uchar, type)
796#endif
797    IFRESTORE(`COPY(key)', `
798        PROC_ZSTRING_L(type, key, key_len)
799    ')
[506]800    DISPATCH(ulong, h)
[268]801')
802dnl }}}
803#endif
[496]804#ifdef E_STRICT
805DEF_STRUCT_P_FUNC(`xc_compilererror_t', , `dnl {{{
[648]806    DISPATCH(int, type)
[496]807    DISPATCH(uint, lineno)
808    DISPATCH(int, error_len)
809    PROC_STRING_L(error, error_len)
810')
811dnl }}}
812#endif
[1]813DEF_STRUCT_P_FUNC(`xc_entry_data_php_t', , `dnl {{{
[311]814    IFCOPY(`
815        processor->php_dst = dst;
816        processor->php_src = src;
817    ')
818
819    DISPATCH(xc_hash_value_t, hvalue)
820    /* skip */
821    DONE(next)
822    COPY(cache)
823    DISPATCH(xc_md5sum_t, md5)
824    DISPATCH(zend_ulong, refcount)
825
[1]826    DISPATCH(size_t, sourcesize)
[311]827    DISPATCH(zend_ulong, hits)
828    DISPATCH(size_t, size)
[1]829
[662]830    IFRESTORE(`COPY(op_array_info)', `
831        STRUCT(xc_op_array_info_t, op_array_info)
832    ')
833    IFRESTORE(`
834        processor->active_op_array_infos_src = &dst->op_array_info;
835        processor->active_op_array_index = 0;
836    ')
[1]837    STRUCT_P(zend_op_array, op_array)
838
[95]839#ifdef HAVE_XCACHE_CONSTANT
840    DISPATCH(zend_uint, constinfo_cnt)
[503]841    STRUCT_ARRAY(constinfo_cnt, xc_constinfo_t, constinfos)
[95]842#endif
843
[1]844    DISPATCH(zend_uint, funcinfo_cnt)
845    STRUCT_ARRAY(funcinfo_cnt, xc_funcinfo_t, funcinfos)
846
847    DISPATCH(zend_uint, classinfo_cnt)
[662]848    STRUCT_ARRAY(classinfo_cnt, xc_classinfo_t, classinfos, , IFRESTORE(`processor->active_class_index'))
[268]849#ifdef ZEND_ENGINE_2_1
850    DISPATCH(zend_uint, autoglobal_cnt)
[495]851    IFRESTORE(`
852        COPY(autoglobals)
853    ', `
854        STRUCT_ARRAY(autoglobal_cnt, xc_autoglobal_t, autoglobals)
855    ')
[268]856#endif
[496]857#ifdef E_STRICT
858    DISPATCH(zend_uint, compilererror_cnt)
859    IFRESTORE(`
860        COPY(compilererrors)
861    ', `
862        STRUCT_ARRAY(compilererror_cnt, xc_compilererror_t, compilererrors)
863    ')
864#endif
[548]865#ifndef ZEND_COMPILE_DELAYED_BINDING
[212]866    DISPATCH(zend_bool, have_early_binding)
[548]867#endif
[311]868    DISPATCH(zend_bool, have_references)
[1]869')
870dnl }}}
871DEF_STRUCT_P_FUNC(`xc_entry_data_var_t', , `dnl {{{
[230]872    IFDPRINT(`INDENT()`'fprintf(stderr, "zval:value");')
[4]873    STRUCT_P_EX(zval_ptr, dst->value, src->value, `value', `', `&')
[311]874    DISPATCH(zend_bool, have_references)
[1]875    DONE(value)
876')
877dnl }}}
878dnl {{{ xc_entry_t
879DEF_STRUCT_P_FUNC(`xc_entry_t', , `
880    DISPATCH(xc_entry_type_t, type)
881    DISPATCH(size_t, size)
882
883    DISPATCH(xc_hash_value_t, hvalue)
884    COPY(cache)
885    /* skip */
886    DONE(next)
887
888    IFSTORE(`dst->refcount = 0; DONE(refcount)', `DISPATCH(long, refcount)')
889
890    DISPATCH(time_t, ctime)
891    DISPATCH(time_t, atime)
892    DISPATCH(time_t, dtime)
[114]893    DISPATCH(long, ttl)
[1]894    DISPATCH(zend_ulong, hits)
895#ifdef IS_UNICODE
896    DISPATCH(zend_uchar, name_type)
897#endif
898    dnl {{{ name
899    DISABLECHECK(`
900#ifdef IS_UNICODE
901        if (src->name_type == IS_UNICODE) {
902            DISPATCH(int32_t, name.ustr.len)
903        }
904        else {
905            DISPATCH(int, name.str.len)
906        }
907#else
908        DISPATCH(int, name.str.len)
909#endif
[103]910        IFRESTORE(`COPY(name.str.val)', `
911#ifdef IS_UNICODE
912            PROC_ZSTRING_L(name_type, name.uni.val, name.uni.len)
913#else
914            PROC_STRING_L(name.str.val, name.str.len)
915#endif
916        ')
[1]917    ')
918    DONE(name)
919    dnl }}}
920
921    dnl {{{ data
922    DISABLECHECK(`
923        switch (src->type) {
924        case XC_TYPE_PHP:
[662]925            IFCALCCOPY(`COPY(data.php)', `STRUCT_P(xc_entry_data_php_t, data.php)')
[1]926            break;
[311]927
[1]928        case XC_TYPE_VAR:
929            STRUCT_P(xc_entry_data_var_t, data.var)
930            break;
[311]931
[1]932        default:
933            assert(0);
934        }
935    ')
936    DONE(data)
937    dnl }}}
[311]938    DISPATCH(time_t, mtime)
939#ifdef HAVE_INODE
940    DISPATCH(int, device)
941    DISPATCH(int, inode)
942#endif
[684]943
[688]944    if (src->type == XC_TYPE_PHP) {
945        DISPATCH(int, filepath_len)
946        IFRESTORE(`COPY(filepath)', `PROC_STRING_L(filepath, filepath_len)')
947        DISPATCH(int, dirpath_len)
948        IFRESTORE(`COPY(dirpath)', `PROC_STRING_L(dirpath, dirpath_len)')
[684]949#ifdef IS_UNICODE
[688]950        DISPATCH(int, ufilepath_len)
951        IFRESTORE(`COPY(ufilepath)', `PROC_USTRING_L(ufilepath, ufilepath_len)')
952        DISPATCH(int, udirpath_len)
953        IFRESTORE(`COPY(udirpath)', `PROC_USTRING_L(udirpath, udirpath_len)')
[684]954#endif
[688]955    }
956    else {
957        DONE(filepath_len)
958        DONE(filepath)
959        DONE(dirpath_len)
960        DONE(dirpath)
961#ifdef IS_UNICODE
962        DONE(ufilepath_len)
963        DONE(ufilepath)
964        DONE(udirpath_len)
965        DONE(udirpath)
966#endif
967    }
[1]968')
969dnl }}}
970dnl ====================================================
Note: See TracBrowser for help on using the repository browser.