![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zend_opcode.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend|
Return to zend_opcode.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / Zend |
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | Zend Engine |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1998-2012 Zend Technologies Ltd. (http://www.zend.com) |
6: +----------------------------------------------------------------------+
7: | This source file is subject to version 2.00 of the Zend license, |
8: | that is bundled with this package in the file LICENSE, and is |
9: | available through the world-wide-web at the following url: |
10: | http://www.zend.com/license/2_00.txt. |
11: | If you did not receive a copy of the Zend license and are unable to |
12: | obtain it through the world-wide-web, please send a note to |
13: | license@zend.com so we can mail you a copy immediately. |
14: +----------------------------------------------------------------------+
15: | Authors: Andi Gutmans <andi@zend.com> |
16: | Zeev Suraski <zeev@zend.com> |
17: +----------------------------------------------------------------------+
18: */
19:
20: /* $Id: zend_opcode.c 321634 2012-01-01 13:15:04Z felipe $ */
21:
22: #include <stdio.h>
23:
24: #include "zend.h"
25: #include "zend_alloc.h"
26: #include "zend_compile.h"
27: #include "zend_extensions.h"
28: #include "zend_API.h"
29:
30: #include "zend_vm.h"
31:
32: static void zend_extension_op_array_ctor_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
33: {
34: if (extension->op_array_ctor) {
35: extension->op_array_ctor(op_array);
36: }
37: }
38:
39: static void zend_extension_op_array_dtor_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
40: {
41: if (extension->op_array_dtor) {
42: extension->op_array_dtor(op_array);
43: }
44: }
45:
46: static void op_array_alloc_ops(zend_op_array *op_array)
47: {
48: op_array->opcodes = erealloc(op_array->opcodes, (op_array->size)*sizeof(zend_op));
49: }
50:
51: void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size TSRMLS_DC)
52: {
53: op_array->type = type;
54:
55: op_array->backpatch_count = 0;
56: if (CG(interactive)) {
57: /* We must avoid a realloc() on the op_array in interactive mode, since pointers to constants
58: * will become invalid
59: */
60: initial_ops_size = 8192;
61: }
62:
63: op_array->refcount = (zend_uint *) emalloc(sizeof(zend_uint));
64: *op_array->refcount = 1;
65: op_array->size = initial_ops_size;
66: op_array->last = 0;
67: op_array->opcodes = NULL;
68: op_array_alloc_ops(op_array);
69:
70: op_array->size_var = 0; /* FIXME:??? */
71: op_array->last_var = 0;
72: op_array->vars = NULL;
73:
74: op_array->T = 0;
75:
76: op_array->function_name = NULL;
77: op_array->filename = zend_get_compiled_filename(TSRMLS_C);
78: op_array->doc_comment = NULL;
79: op_array->doc_comment_len = 0;
80:
81: op_array->arg_info = NULL;
82: op_array->num_args = 0;
83: op_array->required_num_args = 0;
84:
85: op_array->scope = NULL;
86:
87: op_array->brk_cont_array = NULL;
88: op_array->try_catch_array = NULL;
89: op_array->last_brk_cont = 0;
90: op_array->current_brk_cont = -1;
91:
92: op_array->static_variables = NULL;
93: op_array->last_try_catch = 0;
94:
95: op_array->return_reference = 0;
96: op_array->done_pass_two = 0;
97:
98: op_array->this_var = -1;
99:
100: op_array->start_op = NULL;
101:
102: op_array->fn_flags = CG(interactive)?ZEND_ACC_INTERACTIVE:0;
103:
104: op_array->early_binding = -1;
105:
106: memset(op_array->reserved, 0, ZEND_MAX_RESERVED_RESOURCES * sizeof(void*));
107:
108: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_ctor_handler, op_array TSRMLS_CC);
109: }
110:
111: ZEND_API void destroy_zend_function(zend_function *function TSRMLS_DC)
112: {
113: switch (function->type) {
114: case ZEND_USER_FUNCTION:
115: destroy_op_array((zend_op_array *) function TSRMLS_CC);
116: break;
117: case ZEND_INTERNAL_FUNCTION:
118: /* do nothing */
119: break;
120: }
121: }
122:
123: ZEND_API void zend_function_dtor(zend_function *function)
124: {
125: TSRMLS_FETCH();
126:
127: destroy_zend_function(function TSRMLS_CC);
128: }
129:
130: static void zend_cleanup_op_array_data(zend_op_array *op_array)
131: {
132: if (op_array->static_variables) {
133: zend_hash_clean(op_array->static_variables);
134: }
135: }
136:
137: ZEND_API int zend_cleanup_function_data(zend_function *function TSRMLS_DC)
138: {
139: if (function->type == ZEND_USER_FUNCTION) {
140: zend_cleanup_op_array_data((zend_op_array *) function);
141: return ZEND_HASH_APPLY_KEEP;
142: } else {
143: return ZEND_HASH_APPLY_STOP;
144: }
145: }
146:
147: ZEND_API int zend_cleanup_function_data_full(zend_function *function TSRMLS_DC)
148: {
149: if (function->type == ZEND_USER_FUNCTION) {
150: zend_cleanup_op_array_data((zend_op_array *) function);
151: }
152: return 0;
153: }
154:
155: ZEND_API int zend_cleanup_class_data(zend_class_entry **pce TSRMLS_DC)
156: {
157: if ((*pce)->type == ZEND_USER_CLASS) {
158: /* Clean all parts that can contain run-time data */
159: /* Note that only run-time accessed data need to be cleaned up, pre-defined data can
160: not contain objects and thus are not probelmatic */
161: zend_hash_apply(&(*pce)->function_table, (apply_func_t) zend_cleanup_function_data_full TSRMLS_CC);
162: if ((*pce)->static_members) {
163: zend_hash_clean((*pce)->static_members);
164: (*pce)->static_members = NULL;
165: }
166: } else if (CE_STATIC_MEMBERS(*pce)) {
167: zend_hash_destroy(CE_STATIC_MEMBERS(*pce));
168: FREE_HASHTABLE(CE_STATIC_MEMBERS(*pce));
169: #ifdef ZTS
170: CG(static_members)[(zend_intptr_t)((*pce)->static_members)] = NULL;
171: #else
172: (*pce)->static_members = NULL;
173: #endif
174: }
175: return 0;
176: }
177:
178: ZEND_API void destroy_zend_class(zend_class_entry **pce)
179: {
180: zend_class_entry *ce = *pce;
181:
182: if (--ce->refcount > 0) {
183: return;
184: }
185: switch (ce->type) {
186: case ZEND_USER_CLASS:
187: zend_hash_destroy(&ce->default_properties);
188: zend_hash_destroy(&ce->properties_info);
189: zend_hash_destroy(&ce->default_static_members);
190: efree(ce->name);
191: zend_hash_destroy(&ce->function_table);
192: zend_hash_destroy(&ce->constants_table);
193: if (ce->num_interfaces > 0 && ce->interfaces) {
194: efree(ce->interfaces);
195: }
196: if (ce->doc_comment) {
197: efree(ce->doc_comment);
198: }
199: efree(ce);
200: break;
201: case ZEND_INTERNAL_CLASS:
202: zend_hash_destroy(&ce->default_properties);
203: zend_hash_destroy(&ce->properties_info);
204: zend_hash_destroy(&ce->default_static_members);
205: free(ce->name);
206: zend_hash_destroy(&ce->function_table);
207: zend_hash_destroy(&ce->constants_table);
208: if (ce->num_interfaces > 0) {
209: free(ce->interfaces);
210: }
211: if (ce->doc_comment) {
212: free(ce->doc_comment);
213: }
214: free(ce);
215: break;
216: }
217: }
218:
219: void zend_class_add_ref(zend_class_entry **ce)
220: {
221: (*ce)->refcount++;
222: }
223:
224: ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
225: {
226: zend_op *opline = op_array->opcodes;
227: zend_op *end = op_array->opcodes+op_array->last;
228: zend_uint i;
229:
230: if (op_array->static_variables) {
231: zend_hash_destroy(op_array->static_variables);
232: FREE_HASHTABLE(op_array->static_variables);
233: }
234:
235: if (--(*op_array->refcount)>0) {
236: return;
237: }
238:
239: efree(op_array->refcount);
240:
241: if (op_array->vars) {
242: i = op_array->last_var;
243: while (i > 0) {
244: i--;
245: efree(op_array->vars[i].name);
246: }
247: efree(op_array->vars);
248: }
249:
250: while (opline<end) {
251: if (opline->op1.op_type==IS_CONST) {
252: #if DEBUG_ZEND>2
253: printf("Reducing refcount for %x 1=>0 (destroying)\n", &opline->op1.u.constant);
254: #endif
255: zval_dtor(&opline->op1.u.constant);
256: }
257: if (opline->op2.op_type==IS_CONST) {
258: #if DEBUG_ZEND>2
259: printf("Reducing refcount for %x 1=>0 (destroying)\n", &opline->op2.u.constant);
260: #endif
261: zval_dtor(&opline->op2.u.constant);
262: }
263: opline++;
264: }
265: efree(op_array->opcodes);
266:
267: if (op_array->function_name) {
268: efree(op_array->function_name);
269: }
270: if (op_array->doc_comment) {
271: efree(op_array->doc_comment);
272: }
273: if (op_array->brk_cont_array) {
274: efree(op_array->brk_cont_array);
275: }
276: if (op_array->try_catch_array) {
277: efree(op_array->try_catch_array);
278: }
279: if (op_array->done_pass_two) {
280: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_dtor_handler, op_array TSRMLS_CC);
281: }
282: if (op_array->arg_info) {
283: for (i=0; i<op_array->num_args; i++) {
284: efree((char*)op_array->arg_info[i].name);
285: if (op_array->arg_info[i].class_name) {
286: efree((char*)op_array->arg_info[i].class_name);
287: }
288: }
289: efree(op_array->arg_info);
290: }
291: }
292:
293: void init_op(zend_op *op TSRMLS_DC)
294: {
295: memset(op, 0, sizeof(zend_op));
296: op->lineno = CG(zend_lineno);
297: SET_UNUSED(op->result);
298: }
299:
300: zend_op *get_next_op(zend_op_array *op_array TSRMLS_DC)
301: {
302: zend_uint next_op_num = op_array->last++;
303: zend_op *next_op;
304:
305: if (next_op_num >= op_array->size) {
306: if (op_array->fn_flags & ZEND_ACC_INTERACTIVE) {
307: /* we messed up */
308: zend_printf("Ran out of opcode space!\n"
309: "You should probably consider writing this huge script into a file!\n");
310: zend_bailout();
311: }
312: op_array->size *= 4;
313: op_array_alloc_ops(op_array);
314: }
315:
316: next_op = &(op_array->opcodes[next_op_num]);
317:
318: init_op(next_op TSRMLS_CC);
319:
320: return next_op;
321: }
322:
323: int get_next_op_number(zend_op_array *op_array)
324: {
325: return op_array->last;
326: }
327:
328: zend_brk_cont_element *get_next_brk_cont_element(zend_op_array *op_array)
329: {
330: op_array->last_brk_cont++;
331: op_array->brk_cont_array = erealloc(op_array->brk_cont_array, sizeof(zend_brk_cont_element)*op_array->last_brk_cont);
332: return &op_array->brk_cont_array[op_array->last_brk_cont-1];
333: }
334:
335: static void zend_update_extended_info(zend_op_array *op_array TSRMLS_DC)
336: {
337: zend_op *opline = op_array->opcodes, *end=opline+op_array->last;
338:
339: while (opline<end) {
340: if (opline->opcode == ZEND_EXT_STMT) {
341: if (opline+1<end) {
342: if ((opline+1)->opcode == ZEND_EXT_STMT) {
343: opline->opcode = ZEND_NOP;
344: opline++;
345: continue;
346: }
347: if (opline+1<end) {
348: opline->lineno = (opline+1)->lineno;
349: }
350: } else {
351: opline->opcode = ZEND_NOP;
352: }
353: }
354: opline++;
355: }
356: }
357:
358: static void zend_extension_op_array_handler(zend_extension *extension, zend_op_array *op_array TSRMLS_DC)
359: {
360: if (extension->op_array_handler) {
361: extension->op_array_handler(op_array);
362: }
363: }
364:
365: ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
366: {
367: zend_op *opline, *end;
368:
369: if (op_array->type!=ZEND_USER_FUNCTION && op_array->type!=ZEND_EVAL_CODE) {
370: return 0;
371: }
372: if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
373: zend_update_extended_info(op_array TSRMLS_CC);
374: }
375: if (CG(compiler_options) & ZEND_COMPILE_HANDLE_OP_ARRAY) {
376: zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) zend_extension_op_array_handler, op_array TSRMLS_CC);
377: }
378:
379: if (!(op_array->fn_flags & ZEND_ACC_INTERACTIVE) && op_array->size != op_array->last) {
380: op_array->opcodes = (zend_op *) erealloc(op_array->opcodes, sizeof(zend_op)*op_array->last);
381: op_array->size = op_array->last;
382: }
383:
384: opline = op_array->opcodes;
385: end = opline + op_array->last;
386: while (opline < end) {
387: if (opline->op1.op_type == IS_CONST) {
388: Z_SET_ISREF(opline->op1.u.constant);
389: Z_SET_REFCOUNT(opline->op1.u.constant, 2); /* Make sure is_ref won't be reset */
390: }
391: if (opline->op2.op_type == IS_CONST) {
392: Z_SET_ISREF(opline->op2.u.constant);
393: Z_SET_REFCOUNT(opline->op2.u.constant, 2);
394: }
395: switch (opline->opcode) {
396: case ZEND_GOTO:
397: if (Z_TYPE(opline->op2.u.constant) != IS_LONG) {
398: zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC);
399: }
400: /* break omitted intentionally */
401: case ZEND_JMP:
402: opline->op1.u.jmp_addr = &op_array->opcodes[opline->op1.u.opline_num];
403: break;
404: case ZEND_JMPZ:
405: case ZEND_JMPNZ:
406: case ZEND_JMPZ_EX:
407: case ZEND_JMPNZ_EX:
408: case ZEND_JMP_SET:
409: opline->op2.u.jmp_addr = &op_array->opcodes[opline->op2.u.opline_num];
410: break;
411: }
412: ZEND_VM_SET_OPCODE_HANDLER(opline);
413: opline++;
414: }
415:
416: op_array->done_pass_two = 1;
417: return 0;
418: }
419:
420: int print_class(zend_class_entry *class_entry TSRMLS_DC)
421: {
422: printf("Class %s:\n", class_entry->name);
423: zend_hash_apply(&class_entry->function_table, (apply_func_t) pass_two TSRMLS_CC);
424: printf("End of class %s.\n\n", class_entry->name);
425: return 0;
426: }
427:
428: ZEND_API unary_op_type get_unary_op(int opcode)
429: {
430: switch (opcode) {
431: case ZEND_BW_NOT:
432: return (unary_op_type) bitwise_not_function;
433: break;
434: case ZEND_BOOL_NOT:
435: return (unary_op_type) boolean_not_function;
436: break;
437: default:
438: return (unary_op_type) NULL;
439: break;
440: }
441: }
442:
443: ZEND_API binary_op_type get_binary_op(int opcode)
444: {
445: switch (opcode) {
446: case ZEND_ADD:
447: case ZEND_ASSIGN_ADD:
448: return (binary_op_type) add_function;
449: break;
450: case ZEND_SUB:
451: case ZEND_ASSIGN_SUB:
452: return (binary_op_type) sub_function;
453: break;
454: case ZEND_MUL:
455: case ZEND_ASSIGN_MUL:
456: return (binary_op_type) mul_function;
457: break;
458: case ZEND_DIV:
459: case ZEND_ASSIGN_DIV:
460: return (binary_op_type) div_function;
461: break;
462: case ZEND_MOD:
463: case ZEND_ASSIGN_MOD:
464: return (binary_op_type) mod_function;
465: break;
466: case ZEND_SL:
467: case ZEND_ASSIGN_SL:
468: return (binary_op_type) shift_left_function;
469: break;
470: case ZEND_SR:
471: case ZEND_ASSIGN_SR:
472: return (binary_op_type) shift_right_function;
473: break;
474: case ZEND_CONCAT:
475: case ZEND_ASSIGN_CONCAT:
476: return (binary_op_type) concat_function;
477: break;
478: case ZEND_IS_IDENTICAL:
479: return (binary_op_type) is_identical_function;
480: break;
481: case ZEND_IS_NOT_IDENTICAL:
482: return (binary_op_type) is_not_identical_function;
483: break;
484: case ZEND_IS_EQUAL:
485: return (binary_op_type) is_equal_function;
486: break;
487: case ZEND_IS_NOT_EQUAL:
488: return (binary_op_type) is_not_equal_function;
489: break;
490: case ZEND_IS_SMALLER:
491: return (binary_op_type) is_smaller_function;
492: break;
493: case ZEND_IS_SMALLER_OR_EQUAL:
494: return (binary_op_type) is_smaller_or_equal_function;
495: break;
496: case ZEND_BW_OR:
497: case ZEND_ASSIGN_BW_OR:
498: return (binary_op_type) bitwise_or_function;
499: break;
500: case ZEND_BW_AND:
501: case ZEND_ASSIGN_BW_AND:
502: return (binary_op_type) bitwise_and_function;
503: break;
504: case ZEND_BW_XOR:
505: case ZEND_ASSIGN_BW_XOR:
506: return (binary_op_type) bitwise_xor_function;
507: break;
508: case ZEND_BOOL_XOR:
509: return (binary_op_type) boolean_xor_function;
510: break;
511: default:
512: return (binary_op_type) NULL;
513: break;
514: }
515: }
516:
517: /*
518: * Local variables:
519: * tab-width: 4
520: * c-basic-offset: 4
521: * indent-tabs-mode: t
522: * End:
523: */