From d8f62ea5a6ced3b29709c54cf3d4a6a90a0e9549 Mon Sep 17 00:00:00 2001 From: Andi Gutmans Date: Sun, 30 Sep 2001 17:12:41 +0000 Subject: - At last I've had some time to move all execute() locals into one struct. - No immediate gain but it makes it more clear what variables are temps - and which ones are execute() locals. --- Zend/zend_compile.h | 2 +- Zend/zend_execute.c | 840 ++++++++++++++++++++++++++-------------------------- 2 files changed, 425 insertions(+), 417 deletions(-) diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 755d4ea739..e900990051 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -32,7 +32,7 @@ #define DEBUG_ZEND 0 #define FREE_PNODE(znode) zval_dtor(&znode->u.constant); -#define FREE_OP(op, should_free) if (should_free) zval_dtor(&Ts[(op)->u.var].tmp_var); +#define FREE_OP(Ts, op, should_free) if (should_free) zval_dtor(&Ts[(op)->u.var].tmp_var); #define SET_UNUSED(op) (op).op_type = IS_UNUSED diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 9b1bc63161..ff5812c868 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -219,7 +219,7 @@ static inline zval **zend_fetch_property_address_inner(HashTable *ht, znode *op2 if (prop_ptr == &tmp) { zval_dtor(prop_ptr); } - FREE_OP(op2, EG(free_op2)); + FREE_OP(Ts, op2, EG(free_op2)); return retval; } @@ -231,7 +231,7 @@ static inline void zend_switch_free(zend_op *opline, temp_variable *Ts TSRMLS_DC case IS_VAR: if (!Ts[opline->op1.u.var].var.ptr_ptr) { get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); - FREE_OP(&opline->op1, EG(free_op1)); + FREE_OP(Ts, &opline->op1, EG(free_op1)); } else { zval_ptr_dtor(&Ts[opline->op1.u.var].var.ptr); if (opline->extended_value) { /* foreach() free */ @@ -578,7 +578,7 @@ static void zend_fetch_var_address(znode *result, znode *op1, znode *op2, temp_v } } if (op2->u.fetch_type == ZEND_FETCH_LOCAL) { - FREE_OP(op1, free_op1); + FREE_OP(Ts, op1, free_op1); } else if (op2->u.fetch_type == ZEND_FETCH_STATIC) { zval_update_constant(retval, (void *) 1 TSRMLS_CC); } @@ -671,7 +671,7 @@ fetch_string_dim: } break; } - FREE_OP(op2, EG(free_op2)); + FREE_OP(Ts, op2, EG(free_op2)); return retval; } @@ -767,7 +767,7 @@ static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R); *retval = &EG(uninitialized_zval_ptr); SELECTIVE_PZVAL_LOCK(**retval, result); - FREE_OP(op2, EG(free_op2)); + FREE_OP(Ts, op2, EG(free_op2)); if (type==BP_VAR_W || type==BP_VAR_RW) { zend_error(E_WARNING, "Cannot use a NULL value as an array"); } @@ -796,7 +796,7 @@ static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, PZVAL_LOCK(container); Ts[result->u.var].EA.data.str_offset.offset = offset->value.lval; Ts[result->u.var].EA.type = IS_STRING_OFFSET; - FREE_OP(op2, EG(free_op2)); + FREE_OP(Ts, op2, EG(free_op2)); *retval = NULL; return; } @@ -810,7 +810,7 @@ static void zend_fetch_dimension_address(znode *result, znode *op1, znode *op2, } else { *retval = &EG(error_zval_ptr); } - FREE_OP(op2, EG(free_op2)); + FREE_OP(Ts, op2, EG(free_op2)); SELECTIVE_PZVAL_LOCK(**retval, result); if (type==BP_VAR_W || type==BP_VAR_RW) { zend_error(E_WARNING, "Cannot use a scalar value as an array"); @@ -896,7 +896,7 @@ static void zend_fetch_property_address(znode *result, znode *op1, znode *op2, t zval *offset; offset = get_zval_ptr(op2, Ts, &EG(free_op2), BP_VAR_R); - FREE_OP(op2, EG(free_op2)); + FREE_OP(Ts, op2, EG(free_op2)); if (type==BP_VAR_R || type==BP_VAR_IS) { *retval = &EG(uninitialized_zval_ptr); } else { @@ -986,47 +986,55 @@ static int zend_check_symbol(zval **pz TSRMLS_DC) #define NEXT_OPCODE() \ CHECK_SYMBOL_TABLES() \ - opline++; \ + EX(opline)++; \ continue; -#define RETURN_FROM_EXECUTE_LOOP() \ - free_alloca(Ts); \ - EG(in_execution) = original_in_execution; \ +#define RETURN_FROM_EXECUTE_LOOP(execute_data) \ + free_alloca(EX(Ts)); \ + EG(in_execution) = EX(original_in_execution); \ return; typedef struct _object_info { zval *ptr; } object_info; -ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) -{ +typedef struct _zend_execute_data { zend_op *opline; zend_function_state function_state; - zend_function *fbc=NULL; /* Function Being Called */ - object_info object = {NULL}; -#if ZEND_DEBUG || (!defined (__GNUC__) || __GNUC__ < 2) - temp_variable *Ts = (temp_variable *) do_alloca(sizeof(temp_variable)*op_array->T); -#else - temp_variable Ts[op_array->T]; -#endif - zend_bool original_in_execution=EG(in_execution); + zend_function *fbc; /* Function Being Called */ + object_info object; + temp_variable *Ts; + zend_bool original_in_execution; +} zend_execute_data; + +#define EX(element) execute_data.element + +ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) +{ + zend_execute_data execute_data; + + /* Initialize execute_data */ + EX(fbc) = NULL; + EX(object).ptr = NULL; + EX(Ts) = (temp_variable *) do_alloca(sizeof(temp_variable)*op_array->T); + EX(original_in_execution)=EG(in_execution); EG(in_execution) = 1; if (op_array->start_op) { - opline = op_array->start_op; + EX(opline) = op_array->start_op; } else { - opline = op_array->opcodes; + EX(opline) = op_array->opcodes; } - EG(opline_ptr) = &opline; + EG(opline_ptr) = &EX(opline); - function_state.function = (zend_function *) op_array; - EG(function_state_ptr) = &function_state; + EX(function_state).function = (zend_function *) op_array; + EG(function_state_ptr) = &EX(function_state); #if ZEND_DEBUG /* function_state.function_symbol_table is saved as-is to a stack, * which is an intentional UMR. Shut it up if we're in DEBUG. */ - function_state.function_symbol_table = NULL; + EX(function_state).function_symbol_table = NULL; #endif if (op_array->uses_globals) { @@ -1051,7 +1059,7 @@ ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) zend_clean_garbage(TSRMLS_C); - switch(opline->opcode) { + switch(EX(opline)->opcode) { case ZEND_ADD: EG(binary_op) = add_function; goto binary_op_addr; @@ -1107,18 +1115,18 @@ ZEND_API void execute(zend_op_array *op_array TSRMLS_DC) EG(binary_op) = boolean_xor_function; /* Fall through */ binary_op_addr: - EG(binary_op)(&Ts[opline->result.u.var].tmp_var, - get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R), - get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R) TSRMLS_CC); - FREE_OP(&opline->op1, EG(free_op1)); - FREE_OP(&opline->op2, EG(free_op2)); + EG(binary_op)(&EX(Ts)[EX(opline)->result.u.var].tmp_var, + get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R), + get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); NEXT_OPCODE(); case ZEND_BW_NOT: case ZEND_BOOL_NOT: - EG(unary_op) = get_unary_op(opline->opcode); - EG(unary_op)(&Ts[opline->result.u.var].tmp_var, - get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R) ); - FREE_OP(&opline->op1, EG(free_op1)); + EG(unary_op) = get_unary_op(EX(opline)->opcode); + EG(unary_op)(&EX(Ts)[EX(opline)->result.u.var].tmp_var, + get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R) ); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); NEXT_OPCODE(); case ZEND_ASSIGN_ADD: EG(binary_op) = add_function; @@ -1154,26 +1162,26 @@ binary_op_addr: EG(binary_op) = bitwise_xor_function; /* Fall through */ binary_assign_op_addr: { - zval **var_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_RW); + zval **var_ptr = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_RW); if (!var_ptr) { zend_error(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets"); } if (*var_ptr == EG(error_zval_ptr)) { - Ts[opline->result.u.var].var.ptr_ptr = &EG(uninitialized_zval_ptr); - SELECTIVE_PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr, &opline->result); - AI_USE_PTR(Ts[opline->result.u.var].var); - opline++; + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = &EG(uninitialized_zval_ptr); + SELECTIVE_PZVAL_LOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr, &EX(opline)->result); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); + EX(opline)++; continue; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); - EG(binary_op)(*var_ptr, *var_ptr, get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R) TSRMLS_CC); - Ts[opline->result.u.var].var.ptr_ptr = var_ptr; - SELECTIVE_PZVAL_LOCK(*var_ptr, &opline->result); - FREE_OP(&opline->op2, EG(free_op2)); - AI_USE_PTR(Ts[opline->result.u.var].var); + EG(binary_op)(*var_ptr, *var_ptr, get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC); + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = var_ptr; + SELECTIVE_PZVAL_LOCK(*var_ptr, &EX(opline)->result); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); } NEXT_OPCODE(); case ZEND_PRE_INC: @@ -1181,279 +1189,279 @@ binary_assign_op_addr: { case ZEND_POST_INC: case ZEND_POST_DEC: { int (*incdec_op)(zval *op); - zval **var_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_RW); + zval **var_ptr = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_RW); if (!var_ptr) { zend_error(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets"); } if (*var_ptr == EG(error_zval_ptr)) { - Ts[opline->result.u.var].var.ptr_ptr = &EG(uninitialized_zval_ptr); - SELECTIVE_PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr, &opline->result); - AI_USE_PTR(Ts[opline->result.u.var].var); - opline++; + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = &EG(uninitialized_zval_ptr); + SELECTIVE_PZVAL_LOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr, &EX(opline)->result); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); + EX(opline)++; continue; } - get_incdec_op(incdec_op, opline->opcode); + get_incdec_op(incdec_op, EX(opline)->opcode); - switch (opline->opcode) { + switch (EX(opline)->opcode) { case ZEND_POST_INC: case ZEND_POST_DEC: - Ts[opline->result.u.var].tmp_var = **var_ptr; - zendi_zval_copy_ctor(Ts[opline->result.u.var].tmp_var); + EX(Ts)[EX(opline)->result.u.var].tmp_var = **var_ptr; + zendi_zval_copy_ctor(EX(Ts)[EX(opline)->result.u.var].tmp_var); break; } SEPARATE_ZVAL_IF_NOT_REF(var_ptr); incdec_op(*var_ptr); - switch (opline->opcode) { + switch (EX(opline)->opcode) { case ZEND_PRE_INC: case ZEND_PRE_DEC: - Ts[opline->result.u.var].var.ptr_ptr = var_ptr; - SELECTIVE_PZVAL_LOCK(*var_ptr, &opline->result); - AI_USE_PTR(Ts[opline->result.u.var].var); + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = var_ptr; + SELECTIVE_PZVAL_LOCK(*var_ptr, &EX(opline)->result); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); break; } } NEXT_OPCODE(); case ZEND_PRINT: - zend_print_variable(get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R)); - Ts[opline->result.u.var].tmp_var.value.lval = 1; - Ts[opline->result.u.var].tmp_var.type = IS_LONG; - FREE_OP(&opline->op1, EG(free_op1)); + zend_print_variable(get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R)); + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.lval = 1; + EX(Ts)[EX(opline)->result.u.var].tmp_var.type = IS_LONG; + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); NEXT_OPCODE(); case ZEND_ECHO: - zend_print_variable(get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R)); - FREE_OP(&opline->op1, EG(free_op1)); + zend_print_variable(get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R)); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); NEXT_OPCODE(); case ZEND_FETCH_R: - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_FETCH_W: - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC); NEXT_OPCODE(); case ZEND_FETCH_RW: - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW TSRMLS_CC); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_RW TSRMLS_CC); NEXT_OPCODE(); case ZEND_FETCH_FUNC_ARG: - if (ARG_SHOULD_BE_SENT_BY_REF(opline->extended_value, fbc, fbc->common.arg_types)) { + if (ARG_SHOULD_BE_SENT_BY_REF(EX(opline)->extended_value, EX(fbc), EX(fbc)->common.arg_types)) { /* Behave like FETCH_W */ - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC); } else { /* Behave like FETCH_R */ - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); } NEXT_OPCODE(); case ZEND_FETCH_UNSET: - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr); - if (Ts[opline->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(Ts[opline->result.u.var].var.ptr_ptr); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + PZVAL_UNLOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); + if (EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) { + SEPARATE_ZVAL_IF_NOT_REF(EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); } - PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr); + PZVAL_LOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); NEXT_OPCODE(); case ZEND_FETCH_IS: - zend_fetch_var_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_var_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_IS TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_FETCH_DIM_R: - if (opline->extended_value == ZEND_FETCH_ADD_LOCK) { - PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr); + if (EX(opline)->extended_value == ZEND_FETCH_ADD_LOCK) { + PZVAL_LOCK(*EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr); } - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_FETCH_DIM_W: - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC); NEXT_OPCODE(); case ZEND_FETCH_DIM_RW: - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW TSRMLS_CC); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_RW TSRMLS_CC); NEXT_OPCODE(); case ZEND_FETCH_DIM_IS: - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_IS TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_FETCH_DIM_FUNC_ARG: - if (ARG_SHOULD_BE_SENT_BY_REF(opline->extended_value, fbc, fbc->common.arg_types)) { + if (ARG_SHOULD_BE_SENT_BY_REF(EX(opline)->extended_value, EX(fbc), EX(fbc)->common.arg_types)) { /* Behave like FETCH_DIM_W */ - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC); } else { /* Behave like FETCH_DIM_R, except for locking used for list() */ - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); } NEXT_OPCODE(); case ZEND_FETCH_DIM_UNSET: /* Not needed in DIM_UNSET - if (opline->extended_value == ZEND_FETCH_ADD_LOCK) { - PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr); + if (EX(opline)->extended_value == ZEND_FETCH_ADD_LOCK) { + PZVAL_LOCK(*EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr); } */ - zend_fetch_dimension_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr); - if (Ts[opline->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(Ts[opline->result.u.var].var.ptr_ptr); + zend_fetch_dimension_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + PZVAL_UNLOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); + if (EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) { + SEPARATE_ZVAL_IF_NOT_REF(EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); } - PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr); + PZVAL_LOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); NEXT_OPCODE(); case ZEND_FETCH_OBJ_R: - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_FETCH_OBJ_W: - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC); NEXT_OPCODE(); case ZEND_FETCH_OBJ_RW: - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_RW TSRMLS_CC); NEXT_OPCODE(); case ZEND_FETCH_OBJ_IS: - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_IS TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_IS TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_FETCH_OBJ_FUNC_ARG: - if (ARG_SHOULD_BE_SENT_BY_REF(opline->extended_value, fbc, fbc->common.arg_types)) { + if (ARG_SHOULD_BE_SENT_BY_REF(EX(opline)->extended_value, EX(fbc), EX(fbc)->common.arg_types)) { /* Behave like FETCH_OBJ_W */ - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_W TSRMLS_CC); } else { - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); } NEXT_OPCODE(); case ZEND_FETCH_OBJ_UNSET: - zend_fetch_property_address(&opline->result, &opline->op1, &opline->op2, Ts, BP_VAR_R TSRMLS_CC); + zend_fetch_property_address(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts), BP_VAR_R TSRMLS_CC); - PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr); - if (Ts[opline->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) { - SEPARATE_ZVAL_IF_NOT_REF(Ts[opline->result.u.var].var.ptr_ptr); + PZVAL_UNLOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); + if (EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr != &EG(uninitialized_zval_ptr)) { + SEPARATE_ZVAL_IF_NOT_REF(EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); } - PZVAL_LOCK(*Ts[opline->result.u.var].var.ptr_ptr); + PZVAL_LOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); NEXT_OPCODE(); case ZEND_FETCH_DIM_TMP_VAR: - zend_fetch_dimension_address_from_tmp_var(&opline->result, &opline->op1, &opline->op2, Ts TSRMLS_CC); - AI_USE_PTR(Ts[opline->result.u.var].var); + zend_fetch_dimension_address_from_tmp_var(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, EX(Ts) TSRMLS_CC); + AI_USE_PTR(EX(Ts)[EX(opline)->result.u.var].var); NEXT_OPCODE(); case ZEND_ASSIGN: { zval *value; - value = get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R); + value = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R); - zend_assign_to_variable(&opline->result, &opline->op1, &opline->op2, value, (EG(free_op2)?IS_TMP_VAR:opline->op2.op_type), Ts TSRMLS_CC); + zend_assign_to_variable(&EX(opline)->result, &EX(opline)->op1, &EX(opline)->op2, value, (EG(free_op2)?IS_TMP_VAR:EX(opline)->op2.op_type), EX(Ts) TSRMLS_CC); /* zend_assign_to_variable() always takes care of op2, never free it! */ } NEXT_OPCODE(); case ZEND_ASSIGN_REF: - zend_assign_to_variable_reference(&opline->result, get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W), get_zval_ptr_ptr(&opline->op2, Ts, BP_VAR_W), Ts TSRMLS_CC); + zend_assign_to_variable_reference(&EX(opline)->result, get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_W), get_zval_ptr_ptr(&EX(opline)->op2, EX(Ts), BP_VAR_W), EX(Ts) TSRMLS_CC); NEXT_OPCODE(); case ZEND_JMP: #if DEBUG_ZEND>=2 - printf("Jumping to %d\n", opline->op1.u.opline_num); + printf("Jumping to %d\n", EX(opline)->op1.u.opline_num); #endif - opline = &op_array->opcodes[opline->op1.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op1.u.opline_num]; continue; break; case ZEND_JMPZ: { - znode *op1 = &opline->op1; + znode *op1 = &EX(opline)->op1; - if (!i_zend_is_true(get_zval_ptr(op1, Ts, &EG(free_op1), BP_VAR_R))) { + if (!i_zend_is_true(get_zval_ptr(op1, EX(Ts), &EG(free_op1), BP_VAR_R))) { #if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.u.opline_num); + printf("Conditional jmp to %d\n", EX(opline)->op2.u.opline_num); #endif - opline = &op_array->opcodes[opline->op2.u.opline_num]; - FREE_OP(op1, EG(free_op1)); + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; + FREE_OP(EX(Ts), op1, EG(free_op1)); continue; } - FREE_OP(op1, EG(free_op1)); + FREE_OP(EX(Ts), op1, EG(free_op1)); } NEXT_OPCODE(); case ZEND_JMPNZ: { - znode *op1 = &opline->op1; + znode *op1 = &EX(opline)->op1; - if (zend_is_true(get_zval_ptr(op1, Ts, &EG(free_op1), BP_VAR_R))) { + if (zend_is_true(get_zval_ptr(op1, EX(Ts), &EG(free_op1), BP_VAR_R))) { #if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.u.opline_num); + printf("Conditional jmp to %d\n", EX(opline)->op2.u.opline_num); #endif - opline = &op_array->opcodes[opline->op2.u.opline_num]; - FREE_OP(op1, EG(free_op1)); + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; + FREE_OP(EX(Ts), op1, EG(free_op1)); continue; } - FREE_OP(op1, EG(free_op1)); + FREE_OP(EX(Ts), op1, EG(free_op1)); } NEXT_OPCODE(); case ZEND_JMPZNZ: { - znode *res = &opline->op1; + znode *res = &EX(opline)->op1; - if (zend_is_true(get_zval_ptr(res, Ts, &EG(free_op1), BP_VAR_R))) { + if (zend_is_true(get_zval_ptr(res, EX(Ts), &EG(free_op1), BP_VAR_R))) { #if DEBUG_ZEND>=2 - printf("Conditional jmp on true to %d\n", opline->extended_value); + printf("Conditional jmp on true to %d\n", EX(opline)->extended_value); #endif - opline = &op_array->opcodes[opline->extended_value]; + EX(opline) = &op_array->opcodes[EX(opline)->extended_value]; } else { #if DEBUG_ZEND>=2 - printf("Conditional jmp on false to %d\n", opline->op2.u.opline_num); + printf("Conditional jmp on false to %d\n", EX(opline)->op2.u.opline_num); #endif - opline = &op_array->opcodes[opline->op2.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; } - FREE_OP(res, EG(free_op1)); + FREE_OP(EX(Ts), res, EG(free_op1)); } continue; break; case ZEND_JMPZ_EX: { - zend_op *original_opline = opline; - int retval = zend_is_true(get_zval_ptr(&original_opline->op1, Ts, &EG(free_op1), BP_VAR_R)); + zend_op *original_opline = EX(opline); + int retval = zend_is_true(get_zval_ptr(&original_opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R)); - FREE_OP(&original_opline->op1, EG(free_op1)); - Ts[original_opline->result.u.var].tmp_var.value.lval = retval; - Ts[original_opline->result.u.var].tmp_var.type = IS_BOOL; + FREE_OP(EX(Ts), &original_opline->op1, EG(free_op1)); + EX(Ts)[original_opline->result.u.var].tmp_var.value.lval = retval; + EX(Ts)[original_opline->result.u.var].tmp_var.type = IS_BOOL; if (!retval) { #if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.u.opline_num); + printf("Conditional jmp to %d\n", EX(opline)->op2.u.opline_num); #endif - opline = &op_array->opcodes[opline->op2.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; continue; } } NEXT_OPCODE(); case ZEND_JMPNZ_EX: { - zend_op *original_opline = opline; - int retval = zend_is_true(get_zval_ptr(&original_opline->op1, Ts, &EG(free_op1), BP_VAR_R)); + zend_op *original_opline = EX(opline); + int retval = zend_is_true(get_zval_ptr(&original_opline->op1, EX(Ts), &EG(free_op1), BP_VAR_R)); - FREE_OP(&original_opline->op1, EG(free_op1)); - Ts[original_opline->result.u.var].tmp_var.value.lval = retval; - Ts[original_opline->result.u.var].tmp_var.type = IS_BOOL; + FREE_OP(EX(Ts), &original_opline->op1, EG(free_op1)); + EX(Ts)[original_opline->result.u.var].tmp_var.value.lval = retval; + EX(Ts)[original_opline->result.u.var].tmp_var.type = IS_BOOL; if (retval) { #if DEBUG_ZEND>=2 - printf("Conditional jmp to %d\n", opline->op2.u.opline_num); + printf("Conditional jmp to %d\n", EX(opline)->op2.u.opline_num); #endif - opline = &op_array->opcodes[opline->op2.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; continue; } } NEXT_OPCODE(); case ZEND_FREE: - zendi_zval_dtor(Ts[opline->op1.u.var].tmp_var); + zendi_zval_dtor(EX(Ts)[EX(opline)->op1.u.var].tmp_var); NEXT_OPCODE(); case ZEND_INIT_STRING: - Ts[opline->result.u.var].tmp_var.value.str.val = emalloc(1); - Ts[opline->result.u.var].tmp_var.value.str.val[0] = 0; - Ts[opline->result.u.var].tmp_var.value.str.len = 0; - Ts[opline->result.u.var].tmp_var.refcount = 1; + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.str.val = emalloc(1); + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.str.val[0] = 0; + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.str.len = 0; + EX(Ts)[EX(opline)->result.u.var].tmp_var.refcount = 1; NEXT_OPCODE(); case ZEND_ADD_CHAR: - add_char_to_string( &Ts[opline->result.u.var].tmp_var, - get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_NA), - &opline->op2.u.constant); + add_char_to_string( &EX(Ts)[EX(opline)->result.u.var].tmp_var, + get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_NA), + &EX(opline)->op2.u.constant); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ NEXT_OPCODE(); case ZEND_ADD_STRING: - add_string_to_string( &Ts[opline->result.u.var].tmp_var, - get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_NA), - &opline->op2.u.constant); + add_string_to_string( &EX(Ts)[EX(opline)->result.u.var].tmp_var, + get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_NA), + &EX(opline)->op2.u.constant); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ NEXT_OPCODE(); case ZEND_ADD_VAR: { - zval *var = get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R); + zval *var = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R); zval var_copy; int use_copy; @@ -1461,8 +1469,8 @@ binary_assign_op_addr: { if (use_copy) { var = &var_copy; } - add_string_to_string( &Ts[opline->result.u.var].tmp_var, - get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_NA), + add_string_to_string( &EX(Ts)[EX(opline)->result.u.var].tmp_var, + get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_NA), var); if (use_copy) { zval_dtor(var); @@ -1470,10 +1478,10 @@ binary_assign_op_addr: { /* original comment, possibly problematic: * FREE_OP is missing intentionally here - we're always working on the same temporary variable * (Zeev): I don't think it's problematic, we only use variables - * which aren't affected by FREE_OP()'s anyway, unless they're + * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're * string offsets or overloaded objects */ - FREE_OP(&opline->op2, EG(free_op2)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); } NEXT_OPCODE(); case ZEND_INIT_FCALL_BY_NAME: { @@ -1482,18 +1490,18 @@ binary_assign_op_addr: { HashTable *active_function_table; zval tmp; - zend_ptr_stack_n_push(&EG(arg_types_stack), 2, fbc, object.ptr); - if (opline->extended_value & ZEND_CTOR_CALL) { + zend_ptr_stack_n_push(&EG(arg_types_stack), 2, EX(fbc), EX(object).ptr); + if (EX(opline)->extended_value & ZEND_CTOR_CALL) { /* constructor call */ - if (opline->op1.op_type == IS_VAR) { - SELECTIVE_PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr, &opline->op1); + if (EX(opline)->op1.op_type == IS_VAR) { + SELECTIVE_PZVAL_LOCK(*EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr, &EX(opline)->op1); } - if (opline->op2.op_type == IS_VAR) { - PZVAL_LOCK(*Ts[opline->op2.u.var].var.ptr_ptr); + if (EX(opline)->op2.op_type == IS_VAR) { + PZVAL_LOCK(*EX(Ts)[EX(opline)->op2.u.var].var.ptr_ptr); } } - function_name = get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R); + function_name = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R); tmp = *function_name; zval_copy_ctor(&tmp); @@ -1501,185 +1509,185 @@ binary_assign_op_addr: { function_name = &tmp; zend_str_tolower(tmp.value.str.val, tmp.value.str.len); - if (opline->op1.op_type != IS_UNUSED) { - if (opline->op1.op_type==IS_CONST) { /* used for class_name::function() */ + if (EX(opline)->op1.op_type != IS_UNUSED) { + if (EX(opline)->op1.op_type==IS_CONST) { /* used for class_name::function() */ zend_class_entry *ce; zval **object_ptr_ptr; if (zend_hash_find(EG(active_symbol_table), "this", sizeof("this"), (void **) &object_ptr_ptr)==FAILURE) { - object.ptr=NULL; + EX(object).ptr=NULL; } else { /* We assume that "this" is already is_ref and pointing to the object. If it isn't then tough */ - object.ptr = *object_ptr_ptr; - object.ptr->refcount++; /* For this pointer */ + EX(object).ptr = *object_ptr_ptr; + EX(object).ptr->refcount++; /* For this pointer */ } - if (zend_hash_find(EG(class_table), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len+1, (void **) &ce)==FAILURE) { /* class doesn't exist */ - zend_error(E_ERROR, "Undefined class name '%s'", opline->op1.u.constant.value.str.val); + if (zend_hash_find(EG(class_table), EX(opline)->op1.u.constant.value.str.val, EX(opline)->op1.u.constant.value.str.len+1, (void **) &ce)==FAILURE) { /* class doesn't exist */ + zend_error(E_ERROR, "Undefined class name '%s'", EX(opline)->op1.u.constant.value.str.val); } active_function_table = &ce->function_table; } else { /* used for member function calls */ - object.ptr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + EX(object).ptr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); - if ((!object.ptr && Ts[opline->op1.u.var].EA.type==IS_OVERLOADED_OBJECT) - || ((object.ptr && object.ptr->type==IS_OBJECT) && Z_OBJCE_P(object.ptr)->handle_function_call)) { /* overloaded function call */ + if ((!EX(object).ptr && EX(Ts)[EX(opline)->op1.u.var].EA.type==IS_OVERLOADED_OBJECT) + || ((EX(object).ptr && EX(object).ptr->type==IS_OBJECT) && Z_OBJCE_P(EX(object).ptr)->handle_function_call)) { /* overloaded function call */ zend_overloaded_element overloaded_element; overloaded_element.element = *function_name; overloaded_element.type = OE_IS_METHOD; - if (object.ptr) { - Ts[opline->op1.u.var].EA.data.overloaded_element.object = object.ptr; - Ts[opline->op1.u.var].EA.data.overloaded_element.type = BP_VAR_NA; - Ts[opline->op1.u.var].EA.data.overloaded_element.elements_list = (zend_llist *) emalloc(sizeof(zend_llist)); - zend_llist_init(Ts[opline->op1.u.var].EA.data.overloaded_element.elements_list, sizeof(zend_overloaded_element), NULL, 0); + if (EX(object).ptr) { + EX(Ts)[EX(opline)->op1.u.var].EA.data.overloaded_element.object = EX(object).ptr; + EX(Ts)[EX(opline)->op1.u.var].EA.data.overloaded_element.type = BP_VAR_NA; + EX(Ts)[EX(opline)->op1.u.var].EA.data.overloaded_element.elements_list = (zend_llist *) emalloc(sizeof(zend_llist)); + zend_llist_init(EX(Ts)[EX(opline)->op1.u.var].EA.data.overloaded_element.elements_list, sizeof(zend_overloaded_element), NULL, 0); } - zend_llist_add_element(Ts[opline->op1.u.var].EA.data.overloaded_element.elements_list, &overloaded_element); - fbc = (zend_function *) emalloc(sizeof(zend_function)); - fbc->type = ZEND_OVERLOADED_FUNCTION; - fbc->common.arg_types = NULL; - fbc->overloaded_function.var = opline->op1.u.var; + zend_llist_add_element(EX(Ts)[EX(opline)->op1.u.var].EA.data.overloaded_element.elements_list, &overloaded_element); + EX(fbc) = (zend_function *) emalloc(sizeof(zend_function)); + EX(fbc)->type = ZEND_OVERLOADED_FUNCTION; + EX(fbc)->common.arg_types = NULL; + EX(fbc)->overloaded_function.var = EX(opline)->op1.u.var; goto overloaded_function_call_cont; } - if (object.ptr && object.ptr->type == IS_OBJECT) { - active_function_table = &Z_OBJCE_P(object.ptr)->function_table; + if (EX(object).ptr && EX(object).ptr->type == IS_OBJECT) { + active_function_table = &Z_OBJCE_P(EX(object).ptr)->function_table; } else { zend_error(E_ERROR, "Call to a member function on a non-object"); } - if (!PZVAL_IS_REF(object.ptr)) { - object.ptr->refcount++; /* For $this pointer */ + if (!PZVAL_IS_REF(EX(object).ptr)) { + EX(object).ptr->refcount++; /* For $this pointer */ } else { zval *this_ptr; ALLOC_ZVAL(this_ptr); - *this_ptr = *object.ptr; + *this_ptr = *EX(object).ptr; INIT_PZVAL(this_ptr); zval_copy_ctor(this_ptr); - object.ptr = this_ptr; + EX(object).ptr = this_ptr; } - active_function_table = &Z_OBJCE_P(object.ptr)->function_table; + active_function_table = &Z_OBJCE_P(EX(object).ptr)->function_table; } } else { /* function pointer */ - object.ptr = NULL; + EX(object).ptr = NULL; active_function_table = EG(function_table); } if (zend_hash_find(active_function_table, function_name->value.str.val, function_name->value.str.len+1, (void **) &function)==FAILURE) { zend_error(E_ERROR, "Call to undefined function: %s()", function_name->value.str.val); } zval_dtor(&tmp); - fbc = function; + EX(fbc) = function; overloaded_function_call_cont: - FREE_OP(&opline->op2, EG(free_op2)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); } NEXT_OPCODE(); case ZEND_DO_FCALL_BY_NAME: - function_state.function = fbc; + EX(function_state).function = EX(fbc); goto do_fcall_common; case ZEND_DO_FCALL: { - zval *fname = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + zval *fname = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); - if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &function_state.function)==FAILURE) { + if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE) { zend_error(E_ERROR, "Unknown function: %s()\n", fname->value.str.val); } - FREE_OP(&opline->op1, EG(free_op1)); - zend_ptr_stack_push(&EG(arg_types_stack), object.ptr); - object.ptr = NULL; + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); + zend_ptr_stack_push(&EG(arg_types_stack), EX(object).ptr); + EX(object).ptr = NULL; goto do_fcall_common; } do_fcall_common: { zval **original_return_value; - int return_value_used = RETURN_VALUE_USED(opline); + int return_value_used = RETURN_VALUE_USED(EX(opline)); - zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) opline->extended_value, NULL); + zend_ptr_stack_n_push(&EG(argument_stack), 2, (void *) EX(opline)->extended_value, NULL); - Ts[opline->result.u.var].var.ptr_ptr = &Ts[opline->result.u.var].var.ptr; + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = &EX(Ts)[EX(opline)->result.u.var].var.ptr; - if (function_state.function->type==ZEND_INTERNAL_FUNCTION) { - ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr); - INIT_ZVAL(*(Ts[opline->result.u.var].var.ptr)); - ((zend_internal_function *) function_state.function)->handler(opline->extended_value, Ts[opline->result.u.var].var.ptr, object.ptr, return_value_used TSRMLS_CC); - if (object.ptr) { - zval_ptr_dtor(&object.ptr); + if (EX(function_state).function->type==ZEND_INTERNAL_FUNCTION) { + ALLOC_ZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + INIT_ZVAL(*(EX(Ts)[EX(opline)->result.u.var].var.ptr)); + ((zend_internal_function *) EX(function_state).function)->handler(EX(opline)->extended_value, EX(Ts)[EX(opline)->result.u.var].var.ptr, EX(object).ptr, return_value_used TSRMLS_CC); + if (EX(object).ptr) { + zval_ptr_dtor(&EX(object).ptr); } - Ts[opline->result.u.var].var.ptr->is_ref = 0; - Ts[opline->result.u.var].var.ptr->refcount = 1; + EX(Ts)[EX(opline)->result.u.var].var.ptr->is_ref = 0; + EX(Ts)[EX(opline)->result.u.var].var.ptr->refcount = 1; if (!return_value_used) { - zval_ptr_dtor(&Ts[opline->result.u.var].var.ptr); + zval_ptr_dtor(&EX(Ts)[EX(opline)->result.u.var].var.ptr); } - } else if (function_state.function->type==ZEND_USER_FUNCTION) { + } else if (EX(function_state).function->type==ZEND_USER_FUNCTION) { HashTable *calling_symbol_table; - Ts[opline->result.u.var].var.ptr = NULL; + EX(Ts)[EX(opline)->result.u.var].var.ptr = NULL; if (EG(symtable_cache_ptr)>=EG(symtable_cache)) { /*printf("Cache hit! Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/ - function_state.function_symbol_table = *(EG(symtable_cache_ptr)--); + EX(function_state).function_symbol_table = *(EG(symtable_cache_ptr)--); } else { - ALLOC_HASHTABLE(function_state.function_symbol_table); - zend_hash_init(function_state.function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0); + ALLOC_HASHTABLE(EX(function_state).function_symbol_table); + zend_hash_init(EX(function_state).function_symbol_table, 0, NULL, ZVAL_PTR_DTOR, 0); /*printf("Cache miss! Initialized %x\n", function_state.function_symbol_table);*/ } calling_symbol_table = EG(active_symbol_table); - EG(active_symbol_table) = function_state.function_symbol_table; - if (opline->opcode==ZEND_DO_FCALL_BY_NAME - && object.ptr - && fbc->type!=ZEND_OVERLOADED_FUNCTION) { + EG(active_symbol_table) = EX(function_state).function_symbol_table; + if (EX(opline)->opcode==ZEND_DO_FCALL_BY_NAME + && EX(object).ptr + && EX(fbc)->type!=ZEND_OVERLOADED_FUNCTION) { zval **this_ptr; zval *null_ptr = NULL; - zend_hash_update(function_state.function_symbol_table, "this", sizeof("this"), &null_ptr, sizeof(zval *), (void **) &this_ptr); - *this_ptr = object.ptr; - object.ptr = NULL; + zend_hash_update(EX(function_state).function_symbol_table, "this", sizeof("this"), &null_ptr, sizeof(zval *), (void **) &this_ptr); + *this_ptr = EX(object).ptr; + EX(object).ptr = NULL; } original_return_value = EG(return_value_ptr_ptr); - EG(return_value_ptr_ptr) = Ts[opline->result.u.var].var.ptr_ptr; - EG(active_op_array) = (zend_op_array *) function_state.function; + EG(return_value_ptr_ptr) = EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr; + EG(active_op_array) = (zend_op_array *) EX(function_state).function; zend_execute(EG(active_op_array) TSRMLS_CC); - if (return_value_used && !Ts[opline->result.u.var].var.ptr) { + if (return_value_used && !EX(Ts)[EX(opline)->result.u.var].var.ptr) { if (!EG(exception)) { - ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr); - INIT_ZVAL(*Ts[opline->result.u.var].var.ptr); + ALLOC_ZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + INIT_ZVAL(*EX(Ts)[EX(opline)->result.u.var].var.ptr); } - } else if (!return_value_used && Ts[opline->result.u.var].var.ptr) { - zval_ptr_dtor(&Ts[opline->result.u.var].var.ptr); + } else if (!return_value_used && EX(Ts)[EX(opline)->result.u.var].var.ptr) { + zval_ptr_dtor(&EX(Ts)[EX(opline)->result.u.var].var.ptr); } - EG(opline_ptr) = &opline; + EG(opline_ptr) = &EX(opline); EG(active_op_array) = op_array; EG(return_value_ptr_ptr)=original_return_value; if (EG(symtable_cache_ptr)>=EG(symtable_cache_limit)) { - zend_hash_destroy(function_state.function_symbol_table); - FREE_HASHTABLE(function_state.function_symbol_table); + zend_hash_destroy(EX(function_state).function_symbol_table); + FREE_HASHTABLE(EX(function_state).function_symbol_table); } else { - *(++EG(symtable_cache_ptr)) = function_state.function_symbol_table; + *(++EG(symtable_cache_ptr)) = EX(function_state).function_symbol_table; zend_hash_clean(*EG(symtable_cache_ptr)); } EG(active_symbol_table) = calling_symbol_table; } else { /* ZEND_OVERLOADED_FUNCTION */ - ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr); - INIT_ZVAL(*(Ts[opline->result.u.var].var.ptr)); - call_overloaded_function(&Ts[fbc->overloaded_function.var], opline->extended_value, Ts[opline->result.u.var].var.ptr TSRMLS_CC); - efree(fbc); + ALLOC_ZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + INIT_ZVAL(*(EX(Ts)[EX(opline)->result.u.var].var.ptr)); + call_overloaded_function(&EX(Ts)[EX(fbc)->overloaded_function.var], EX(opline)->extended_value, EX(Ts)[EX(opline)->result.u.var].var.ptr TSRMLS_CC); + efree(EX(fbc)); if (!return_value_used) { - zval_ptr_dtor(&Ts[opline->result.u.var].var.ptr); + zval_ptr_dtor(&EX(Ts)[EX(opline)->result.u.var].var.ptr); } } - if (opline->opcode == ZEND_DO_FCALL_BY_NAME) { - zend_ptr_stack_n_pop(&EG(arg_types_stack), 2, &object.ptr, &fbc); + if (EX(opline)->opcode == ZEND_DO_FCALL_BY_NAME) { + zend_ptr_stack_n_pop(&EG(arg_types_stack), 2, &EX(object).ptr, &EX(fbc)); } else { - object.ptr = zend_ptr_stack_pop(&EG(arg_types_stack)); + EX(object).ptr = zend_ptr_stack_pop(&EG(arg_types_stack)); } - function_state.function = (zend_function *) op_array; - EG(function_state_ptr) = &function_state; + EX(function_state).function = (zend_function *) op_array; + EG(function_state_ptr) = &EX(function_state); zend_ptr_stack_clear_multiple(TSRMLS_C); if (EG(exception)) { - if (opline->op2.u.opline_num == -1) { - RETURN_FROM_EXECUTE_LOOP(); + if (EX(opline)->op2.u.opline_num == -1) { + RETURN_FROM_EXECUTE_LOOP(execute_data); } else { - opline = &op_array->opcodes[opline->op2.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; continue; } } @@ -1690,17 +1698,17 @@ do_fcall_common: zval **retval_ptr_ptr; if ((EG(active_op_array)->return_reference == ZEND_RETURN_REF) && - (opline->op1.op_type != IS_CONST) && - (opline->op1.op_type != IS_TMP_VAR)) { + (EX(opline)->op1.op_type != IS_CONST) && + (EX(opline)->op1.op_type != IS_TMP_VAR)) { - retval_ptr_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W); + retval_ptr_ptr = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_W); SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr); (*retval_ptr_ptr)->refcount++; (*EG(return_value_ptr_ptr)) = (*retval_ptr_ptr); } else { - retval_ptr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + retval_ptr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); if (!EG(free_op1)) { /* Not a temp var */ if (PZVAL_IS_REF(retval_ptr) && retval_ptr->refcount > 0) { @@ -1720,7 +1728,7 @@ do_fcall_common: (*EG(return_value_ptr_ptr))->is_ref = 0; } } - RETURN_FROM_EXECUTE_LOOP(); + RETURN_FROM_EXECUTE_LOOP(execute_data); } break; case ZEND_THROW: @@ -1728,7 +1736,7 @@ do_fcall_common: zval *value; zval *exception; - value = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + value = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); /* Not sure if a complete copy is what we want here */ MAKE_STD_ZVAL(exception); @@ -1739,10 +1747,10 @@ do_fcall_common: INIT_PZVAL(exception); EG(exception) = exception; - if (opline->op2.u.opline_num == -1) { - RETURN_FROM_EXECUTE_LOOP(); + if (EX(opline)->op2.u.opline_num == -1) { + RETURN_FROM_EXECUTE_LOOP(execute_data); } else { - opline = &op_array->opcodes[opline->op2.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; continue; } } @@ -1750,18 +1758,18 @@ do_fcall_common: case ZEND_CATCH: /* Check if this is really an exception, if not, jump over code */ if (EG(exception) == NULL) { - opline = &op_array->opcodes[opline->op2.u.opline_num]; + EX(opline) = &op_array->opcodes[EX(opline)->op2.u.opline_num]; continue; } - zend_hash_update(EG(active_symbol_table), opline->op1.u.constant.value.str.val, - opline->op1.u.constant.value.str.len+1, &EG(exception), sizeof(zval *), (void **) NULL); + zend_hash_update(EG(active_symbol_table), EX(opline)->op1.u.constant.value.str.val, + EX(opline)->op1.u.constant.value.str.len+1, &EG(exception), sizeof(zval *), (void **) NULL); EG(exception) = NULL; NEXT_OPCODE(); case ZEND_NAMESPACE: { zend_namespace *namespace_ptr; - if (zend_hash_find(EG(namespaces), opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len + 1, (void **) &namespace_ptr) == FAILURE) { + if (zend_hash_find(EG(namespaces), EX(opline)->op1.u.constant.value.str.val, EX(opline)->op1.u.constant.value.str.len + 1, (void **) &namespace_ptr) == FAILURE) { zend_error(E_ERROR, "Internal namespaces error. Please report this!"); } EG(function_table) = namespace_ptr->function_table; @@ -1769,15 +1777,15 @@ do_fcall_common: NEXT_OPCODE(); } case ZEND_SEND_VAL: - if (opline->extended_value==ZEND_DO_FCALL_BY_NAME - && ARG_SHOULD_BE_SENT_BY_REF(opline->op2.u.opline_num, fbc, fbc->common.arg_types)) { - zend_error(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num); + if (EX(opline)->extended_value==ZEND_DO_FCALL_BY_NAME + && ARG_SHOULD_BE_SENT_BY_REF(EX(opline)->op2.u.opline_num, EX(fbc), EX(fbc)->common.arg_types)) { + zend_error(E_ERROR, "Cannot pass parameter %d by reference", EX(opline)->op2.u.opline_num); } { zval *valptr; zval *value; - value = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + value = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); ALLOC_ZVAL(valptr); *valptr = *value; @@ -1789,16 +1797,16 @@ do_fcall_common: } NEXT_OPCODE(); case ZEND_SEND_VAR_NO_REF: - if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */ - if (!(opline->extended_value & ZEND_ARG_SEND_BY_REF)) { + if (EX(opline)->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */ + if (!(EX(opline)->extended_value & ZEND_ARG_SEND_BY_REF)) { goto send_by_var; } - } else if (!ARG_SHOULD_BE_SENT_BY_REF(opline->op2.u.opline_num, fbc, fbc->common.arg_types)) { + } else if (!ARG_SHOULD_BE_SENT_BY_REF(EX(opline)->op2.u.opline_num, EX(fbc), EX(fbc)->common.arg_types)) { goto send_by_var; } { zval *varptr; - varptr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + varptr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); if (varptr != &EG(uninitialized_zval) && (PZVAL_IS_REF(varptr) || varptr->refcount == 1)) { varptr->is_ref = 1; @@ -1810,14 +1818,14 @@ do_fcall_common: } NEXT_OPCODE(); case ZEND_SEND_VAR: - if ((opline->extended_value == ZEND_DO_FCALL_BY_NAME) - && ARG_SHOULD_BE_SENT_BY_REF(opline->op2.u.opline_num, fbc, fbc->common.arg_types)) { + if ((EX(opline)->extended_value == ZEND_DO_FCALL_BY_NAME) + && ARG_SHOULD_BE_SENT_BY_REF(EX(opline)->op2.u.opline_num, EX(fbc), EX(fbc)->common.arg_types)) { goto send_by_ref; } send_by_var: { zval *varptr; - varptr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + varptr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); if (varptr == &EG(uninitialized_zval)) { ALLOC_ZVAL(varptr); @@ -1834,14 +1842,14 @@ send_by_var: } varptr->refcount++; zend_ptr_stack_push(&EG(argument_stack), varptr); - FREE_OP(&opline->op1, EG(free_op1)); /* for string offsets */ + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); /* for string offsets */ } NEXT_OPCODE(); send_by_ref: case ZEND_SEND_REF: { zval **varptr_ptr; zval *varptr; - varptr_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_W); + varptr_ptr = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_W); if (!varptr_ptr) { zend_error(E_ERROR, "Only variables can be passed by reference"); @@ -1856,28 +1864,28 @@ send_by_ref: case ZEND_RECV: { zval **param; - if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) ¶m TSRMLS_CC)==FAILURE) { - zend_error(E_WARNING, "Missing argument %d for %s()\n", opline->op1.u.constant.value.lval, get_active_function_name(TSRMLS_C)); - if (opline->result.op_type == IS_VAR) { - PZVAL_UNLOCK(*Ts[opline->result.u.var].var.ptr_ptr); + if (zend_ptr_stack_get_arg(EX(opline)->op1.u.constant.value.lval, (void **) ¶m TSRMLS_CC)==FAILURE) { + zend_error(E_WARNING, "Missing argument %d for %s()\n", EX(opline)->op1.u.constant.value.lval, get_active_function_name(TSRMLS_C)); + if (EX(opline)->result.op_type == IS_VAR) { + PZVAL_UNLOCK(*EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr); } } else if (PZVAL_IS_REF(*param)) { - zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL TSRMLS_CC); + zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&EX(opline)->result, EX(Ts), BP_VAR_W), param, NULL TSRMLS_CC); } else { - zend_assign_to_variable(NULL, &opline->result, NULL, *param, IS_VAR, Ts TSRMLS_CC); + zend_assign_to_variable(NULL, &EX(opline)->result, NULL, *param, IS_VAR, EX(Ts) TSRMLS_CC); } } NEXT_OPCODE(); case ZEND_RECV_INIT: { zval **param, *assignment_value; - if (zend_ptr_stack_get_arg(opline->op1.u.constant.value.lval, (void **) ¶m TSRMLS_CC)==FAILURE) { - if (opline->op2.u.constant.type == IS_CONSTANT || opline->op2.u.constant.type==IS_CONSTANT_ARRAY) { + if (zend_ptr_stack_get_arg(EX(opline)->op1.u.constant.value.lval, (void **) ¶m TSRMLS_CC)==FAILURE) { + if (EX(opline)->op2.u.constant.type == IS_CONSTANT || EX(opline)->op2.u.constant.type==IS_CONSTANT_ARRAY) { zval *default_value; ALLOC_ZVAL(default_value); - *default_value = opline->op2.u.constant; - if (opline->op2.u.constant.type==IS_CONSTANT_ARRAY) { + *default_value = EX(opline)->op2.u.constant; + if (EX(opline)->op2.u.constant.type==IS_CONSTANT_ARRAY) { zval_copy_ctor(default_value); } default_value->refcount=1; @@ -1888,28 +1896,28 @@ send_by_ref: assignment_value = default_value; } else { param = NULL; - assignment_value = &opline->op2.u.constant; + assignment_value = &EX(opline)->op2.u.constant; } } else { assignment_value = *param; } if (PZVAL_IS_REF(assignment_value) && param) { - zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&opline->result, Ts, BP_VAR_W), param, NULL TSRMLS_CC); + zend_assign_to_variable_reference(NULL, get_zval_ptr_ptr(&EX(opline)->result, EX(Ts), BP_VAR_W), param, NULL TSRMLS_CC); } else { - zend_assign_to_variable(NULL, &opline->result, NULL, assignment_value, IS_VAR, Ts TSRMLS_CC); + zend_assign_to_variable(NULL, &EX(opline)->result, NULL, assignment_value, IS_VAR, EX(Ts) TSRMLS_CC); } } NEXT_OPCODE(); case ZEND_BOOL: /* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */ - Ts[opline->result.u.var].tmp_var.value.lval = zend_is_true(get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R)); - Ts[opline->result.u.var].tmp_var.type = IS_BOOL; - FREE_OP(&opline->op1, EG(free_op1)); + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.lval = zend_is_true(get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R)); + EX(Ts)[EX(opline)->result.u.var].tmp_var.type = IS_BOOL; + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); NEXT_OPCODE(); case ZEND_BRK: case ZEND_CONT: { - zval *nest_levels_zval = get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R); + zval *nest_levels_zval = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R); zval tmp; int array_offset, nest_levels, original_nest_levels; zend_brk_cont_element *jmp_to; @@ -1923,7 +1931,7 @@ send_by_ref: nest_levels = nest_levels_zval->value.lval; } original_nest_levels = nest_levels; - array_offset = opline->op1.u.opline_num; + array_offset = EX(opline)->op1.u.opline_num; do { if (array_offset==-1) { zend_error(E_ERROR, "Cannot break/continue %d levels\n", original_nest_levels); @@ -1934,60 +1942,60 @@ send_by_ref: switch (brk_opline->opcode) { case ZEND_SWITCH_FREE: - zend_switch_free(brk_opline, Ts TSRMLS_CC); + zend_switch_free(brk_opline, EX(Ts) TSRMLS_CC); break; case ZEND_FREE: - zendi_zval_dtor(Ts[brk_opline->op1.u.var].tmp_var); + zendi_zval_dtor(EX(Ts)[brk_opline->op1.u.var].tmp_var); break; } } array_offset = jmp_to->parent; } while (--nest_levels > 0); - if (opline->opcode == ZEND_BRK) { - opline = op_array->opcodes+jmp_to->brk; + if (EX(opline)->opcode == ZEND_BRK) { + EX(opline) = op_array->opcodes+jmp_to->brk; } else { - opline = op_array->opcodes+jmp_to->cont; + EX(opline) = op_array->opcodes+jmp_to->cont; } - FREE_OP(&opline->op2, EG(free_op2)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); continue; } /* Never reaches this point */ case ZEND_CASE: { int switch_expr_is_overloaded=0; - if (opline->op1.op_type==IS_VAR) { - if (Ts[opline->op1.u.var].var.ptr_ptr) { - PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr); + if (EX(opline)->op1.op_type==IS_VAR) { + if (EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr) { + PZVAL_LOCK(*EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr); } else { switch_expr_is_overloaded = 1; - if (Ts[opline->op1.u.var].EA.type==IS_STRING_OFFSET) { - Ts[opline->op1.u.var].EA.data.str_offset.str->refcount++; + if (EX(Ts)[EX(opline)->op1.u.var].EA.type==IS_STRING_OFFSET) { + EX(Ts)[EX(opline)->op1.u.var].EA.data.str_offset.str->refcount++; } } } - is_equal_function(&Ts[opline->result.u.var].tmp_var, - get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R), - get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R) TSRMLS_CC); + is_equal_function(&EX(Ts)[EX(opline)->result.u.var].tmp_var, + get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R), + get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R) TSRMLS_CC); - FREE_OP(&opline->op2, EG(free_op2)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); if (switch_expr_is_overloaded) { /* We only free op1 if this is a string offset, * Since if it is a TMP_VAR, it'll be reused by * other CASE opcodes (whereas string offsets * are allocated at each get_zval_ptr()) */ - FREE_OP(&opline->op1, EG(free_op1)); - Ts[opline->op1.u.var].var.ptr_ptr = NULL; - AI_USE_PTR(Ts[opline->op1.u.var].var); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); + EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr = NULL; + AI_USE_PTR(EX(Ts)[EX(opline)->op1.u.var].var); } } NEXT_OPCODE(); case ZEND_SWITCH_FREE: - zend_switch_free(opline, Ts TSRMLS_CC); + zend_switch_free(EX(opline), EX(Ts) TSRMLS_CC); NEXT_OPCODE(); case ZEND_NEW: { - zval *tmp = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + zval *tmp = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); zval class_name; zend_class_entry *ce; @@ -1999,44 +2007,44 @@ send_by_ref: if (zend_hash_find(EG(class_table), class_name.value.str.val, class_name.value.str.len+1, (void **) &ce)==FAILURE) { zend_error(E_ERROR, "Cannot instantiate non-existent class: %s", class_name.value.str.val); } - Ts[opline->result.u.var].var.ptr_ptr = &Ts[opline->result.u.var].var.ptr; - ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr); - object_init_ex(Ts[opline->result.u.var].var.ptr, ce); - Ts[opline->result.u.var].var.ptr->refcount=1; - Ts[opline->result.u.var].var.ptr->is_ref=1; + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = &EX(Ts)[EX(opline)->result.u.var].var.ptr; + ALLOC_ZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + object_init_ex(EX(Ts)[EX(opline)->result.u.var].var.ptr, ce); + EX(Ts)[EX(opline)->result.u.var].var.ptr->refcount=1; + EX(Ts)[EX(opline)->result.u.var].var.ptr->is_ref=1; zval_dtor(&class_name); - FREE_OP(&opline->op1, EG(free_op1)); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); } NEXT_OPCODE(); case ZEND_FETCH_CONSTANT: - if (!zend_get_constant(opline->op1.u.constant.value.str.val, opline->op1.u.constant.value.str.len, &Ts[opline->result.u.var].tmp_var TSRMLS_CC)) { + if (!zend_get_constant(EX(opline)->op1.u.constant.value.str.val, EX(opline)->op1.u.constant.value.str.len, &EX(Ts)[EX(opline)->result.u.var].tmp_var TSRMLS_CC)) { zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", - opline->op1.u.constant.value.str.val, - opline->op1.u.constant.value.str.val); - Ts[opline->result.u.var].tmp_var = opline->op1.u.constant; - zval_copy_ctor(&Ts[opline->result.u.var].tmp_var); + EX(opline)->op1.u.constant.value.str.val, + EX(opline)->op1.u.constant.value.str.val); + EX(Ts)[EX(opline)->result.u.var].tmp_var = EX(opline)->op1.u.constant; + zval_copy_ctor(&EX(Ts)[EX(opline)->result.u.var].tmp_var); } NEXT_OPCODE(); case ZEND_INIT_ARRAY: case ZEND_ADD_ARRAY_ELEMENT: { - zval *array_ptr = &Ts[opline->result.u.var].tmp_var; + zval *array_ptr = &EX(Ts)[EX(opline)->result.u.var].tmp_var; zval *expr_ptr, **expr_ptr_ptr = NULL; - zval *offset=get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R); + zval *offset=get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R); - if (opline->extended_value) { - expr_ptr_ptr=get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_R); + if (EX(opline)->extended_value) { + expr_ptr_ptr=get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_R); expr_ptr = *expr_ptr_ptr; } else { - expr_ptr=get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + expr_ptr=get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); } - if (opline->opcode==ZEND_INIT_ARRAY) { + if (EX(opline)->opcode==ZEND_INIT_ARRAY) { array_init(array_ptr); if (!expr_ptr) { NEXT_OPCODE(); } } - if (!opline->extended_value && EG(free_op1)) { /* temporary variable */ + if (!EX(opline)->extended_value && EG(free_op1)) { /* temporary variable */ zval *new_expr; ALLOC_ZVAL(new_expr); @@ -2044,7 +2052,7 @@ send_by_ref: expr_ptr = new_expr; INIT_PZVAL(expr_ptr); } else { - if (opline->extended_value) { + if (EX(opline)->extended_value) { SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr); expr_ptr = *expr_ptr_ptr; expr_ptr->refcount++; @@ -2079,21 +2087,21 @@ send_by_ref: /* do nothing */ break; } - FREE_OP(&opline->op2, EG(free_op2)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); } else { zend_hash_next_index_insert(array_ptr->value.ht, &expr_ptr, sizeof(zval *), NULL); } } NEXT_OPCODE(); case ZEND_CAST: { - zval *expr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); - zval *result = &Ts[opline->result.u.var].tmp_var; + zval *expr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); + zval *result = &EX(Ts)[EX(opline)->result.u.var].tmp_var; *result = *expr; if (!EG(free_op1)) { zendi_zval_copy_ctor(*result); } - switch (opline->extended_value) { + switch (EX(opline)->extended_value) { case IS_NULL: convert_to_null(result); break; @@ -2122,7 +2130,7 @@ send_by_ref: zend_op_array *new_op_array=NULL; zval **original_return_value = EG(return_value_ptr_ptr); int return_value_used; - zval *inc_filename = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + zval *inc_filename = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); zval tmp_inc_filename; zend_bool failure_retval=0; @@ -2133,9 +2141,9 @@ send_by_ref: inc_filename = &tmp_inc_filename; } - return_value_used = RETURN_VALUE_USED(opline); + return_value_used = RETURN_VALUE_USED(EX(opline)); - switch (opline->op2.u.constant.value.lval) { + switch (EX(opline)->op2.u.constant.value.lval) { case ZEND_INCLUDE_ONCE: case ZEND_REQUIRE_ONCE: { char *opened_path=NULL; @@ -2150,7 +2158,7 @@ send_by_ref: if (file_handle.handle.fp) { if (!opened_path || zend_hash_add(&EG(included_files), opened_path, strlen(opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) { - new_op_array = zend_compile_file(&file_handle, (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); + new_op_array = zend_compile_file(&file_handle, (EX(opline)->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC); zend_destroy_file_handle(&file_handle TSRMLS_CC); opened_path = NULL; /* zend_destroy_file_handle() already frees it */ } else { @@ -2158,7 +2166,7 @@ send_by_ref: failure_retval=1; } } else { - if (opline->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE) { + if (EX(opline)->op2.u.constant.value.lval==ZEND_INCLUDE_ONCE) { zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle.filename); } else { zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle.filename); @@ -2172,7 +2180,7 @@ send_by_ref: break; case ZEND_INCLUDE: case ZEND_REQUIRE: - new_op_array = compile_filename(opline->op2.u.constant.value.lval, inc_filename TSRMLS_CC); + new_op_array = compile_filename(EX(opline)->op2.u.constant.value.lval, inc_filename TSRMLS_CC); break; case ZEND_EVAL: { char *eval_desc = zend_make_compiled_string_description("eval()'d code" TSRMLS_CC); @@ -2186,46 +2194,46 @@ send_by_ref: if (inc_filename==&tmp_inc_filename) { zval_dtor(&tmp_inc_filename); } - FREE_OP(&opline->op1, EG(free_op1)); - Ts[opline->result.u.var].var.ptr_ptr = &Ts[opline->result.u.var].var.ptr; + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = &EX(Ts)[EX(opline)->result.u.var].var.ptr; if (new_op_array) { - EG(return_value_ptr_ptr) = Ts[opline->result.u.var].var.ptr_ptr; + EG(return_value_ptr_ptr) = EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr; EG(active_op_array) = new_op_array; - Ts[opline->result.u.var].var.ptr = NULL; + EX(Ts)[EX(opline)->result.u.var].var.ptr = NULL; zend_execute(new_op_array TSRMLS_CC); if (!return_value_used) { - if (Ts[opline->result.u.var].var.ptr) { - zval_ptr_dtor(&Ts[opline->result.u.var].var.ptr); + if (EX(Ts)[EX(opline)->result.u.var].var.ptr) { + zval_ptr_dtor(&EX(Ts)[EX(opline)->result.u.var].var.ptr); } } else { /* return value is used */ - if (!Ts[opline->result.u.var].var.ptr) { /* there was no return statement */ - ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr); - INIT_PZVAL(Ts[opline->result.u.var].var.ptr); - Ts[opline->result.u.var].var.ptr->value.lval = 1; - Ts[opline->result.u.var].var.ptr->type = IS_BOOL; + if (!EX(Ts)[EX(opline)->result.u.var].var.ptr) { /* there was no return statement */ + ALLOC_ZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + INIT_PZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + EX(Ts)[EX(opline)->result.u.var].var.ptr->value.lval = 1; + EX(Ts)[EX(opline)->result.u.var].var.ptr->type = IS_BOOL; } } - EG(opline_ptr) = &opline; + EG(opline_ptr) = &EX(opline); EG(active_op_array) = op_array; - EG(function_state_ptr) = &function_state; + EG(function_state_ptr) = &EX(function_state); destroy_op_array(new_op_array); efree(new_op_array); } else { if (return_value_used) { - ALLOC_ZVAL(Ts[opline->result.u.var].var.ptr); - INIT_ZVAL(*Ts[opline->result.u.var].var.ptr); - Ts[opline->result.u.var].var.ptr->value.lval = failure_retval; - Ts[opline->result.u.var].var.ptr->type = IS_BOOL; + ALLOC_ZVAL(EX(Ts)[EX(opline)->result.u.var].var.ptr); + INIT_ZVAL(*EX(Ts)[EX(opline)->result.u.var].var.ptr); + EX(Ts)[EX(opline)->result.u.var].var.ptr->value.lval = failure_retval; + EX(Ts)[EX(opline)->result.u.var].var.ptr->type = IS_BOOL; } } EG(return_value_ptr_ptr) = original_return_value; } NEXT_OPCODE(); case ZEND_UNSET_VAR: { - zval tmp, *variable = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + zval tmp, *variable = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); zval **object; zend_bool unset_object; @@ -2236,7 +2244,7 @@ send_by_ref: variable = &tmp; } - unset_object = (opline->extended_value == ZEND_UNSET_OBJ); + unset_object = (EX(opline)->extended_value == ZEND_UNSET_OBJ); if (unset_object) { if (zend_hash_find(EG(active_symbol_table), variable->value.str.val, variable->value.str.len+1, (void **)&object) == FAILURE) { @@ -2253,16 +2261,16 @@ send_by_ref: if (variable == &tmp) { zval_dtor(&tmp); } - FREE_OP(&opline->op1, EG(free_op1)); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); } NEXT_OPCODE(); case ZEND_UNSET_DIM_OBJ: { - zval **container = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_R); - zval *offset = get_zval_ptr(&opline->op2, Ts, &EG(free_op2), BP_VAR_R); + zval **container = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_R); + zval *offset = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R); zend_bool unset_object; zval **object; - unset_object = (opline->extended_value == ZEND_UNSET_OBJ); + unset_object = (EX(opline)->extended_value == ZEND_UNSET_OBJ); if (container) { HashTable *ht; @@ -2340,15 +2348,15 @@ send_by_ref: } else { /* overloaded element */ } - FREE_OP(&opline->op2, EG(free_op2)); + FREE_OP(EX(Ts), &EX(opline)->op2, EG(free_op2)); } NEXT_OPCODE(); case ZEND_FE_RESET: { zval *array_ptr, **array_ptr_ptr; HashTable *fe_ht; - if (opline->extended_value) { - array_ptr_ptr = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_R); + if (EX(opline)->extended_value) { + array_ptr_ptr = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_R); if (array_ptr_ptr == NULL) { MAKE_STD_ZVAL(array_ptr); } else { @@ -2357,7 +2365,7 @@ send_by_ref: array_ptr->refcount++; } } else { - array_ptr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + array_ptr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); if (EG(free_op1)) { /* IS_TMP_VAR */ zval *tmp; @@ -2370,8 +2378,8 @@ send_by_ref: } } PZVAL_LOCK(array_ptr); - Ts[opline->result.u.var].var.ptr = array_ptr; - Ts[opline->result.u.var].var.ptr_ptr = &Ts[opline->result.u.var].var.ptr; + EX(Ts)[EX(opline)->result.u.var].var.ptr = array_ptr; + EX(Ts)[EX(opline)->result.u.var].var.ptr_ptr = &EX(Ts)[EX(opline)->result.u.var].var.ptr; if ((fe_ht = HASH_OF(array_ptr)) != NULL) { /* probably redundant */ @@ -2382,8 +2390,8 @@ send_by_ref: } NEXT_OPCODE(); case ZEND_FE_FETCH: { - zval *array = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); - zval *result = &Ts[opline->result.u.var].tmp_var; + zval *array = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); + zval *result = &EX(Ts)[EX(opline)->result.u.var].tmp_var; zval **value, *key; char *str_key; ulong int_key; @@ -2394,10 +2402,10 @@ send_by_ref: fe_ht = HASH_OF(array); if (!fe_ht) { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); - opline = op_array->opcodes+opline->op2.u.opline_num; + EX(opline) = op_array->opcodes+EX(opline)->op2.u.opline_num; continue; } else if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) { - opline = op_array->opcodes+opline->op2.u.opline_num; + EX(opline) = op_array->opcodes+EX(opline)->op2.u.opline_num; continue; } array_init(result); @@ -2428,36 +2436,36 @@ send_by_ref: zval *object_zval; zend_object *object; - if (opline->op1.op_type == IS_VAR) { - PZVAL_LOCK(*Ts[opline->op1.u.var].var.ptr_ptr); + if (EX(opline)->op1.op_type == IS_VAR) { + PZVAL_LOCK(*EX(Ts)[EX(opline)->op1.u.var].var.ptr_ptr); } - object_zval = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + object_zval = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); object = object_zval->value.obj.handlers->get_address(object_zval->value.obj.handle); if (!object->ce->handle_function_call && !zend_hash_exists(&object->ce->function_table, object->ce->name, object->ce->name_length+1)) { - opline = op_array->opcodes + opline->op2.u.opline_num; + EX(opline) = op_array->opcodes + EX(opline)->op2.u.opline_num; continue; } } NEXT_OPCODE(); case ZEND_ISSET_ISEMPTY: { - zval **var = get_zval_ptr_ptr(&opline->op1, Ts, BP_VAR_IS); + zval **var = get_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_IS); zval *value; int isset; if (!var) { - if (Ts[opline->op1.u.var].EA.type == IS_STRING_OFFSET) { - PZVAL_LOCK(Ts[opline->op1.u.var].EA.data.str_offset.str); - value = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_IS); + if (EX(Ts)[EX(opline)->op1.u.var].EA.type == IS_STRING_OFFSET) { + PZVAL_LOCK(EX(Ts)[EX(opline)->op1.u.var].EA.data.str_offset.str); + value = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_IS); if (value->value.str.val == empty_string) { isset = 0; } else { isset = 1; } } else { /* IS_OVERLOADED_OBJECT */ - value = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_IS); + value = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_IS); if (value->type == IS_NULL) { isset = 0; } else { @@ -2472,51 +2480,51 @@ send_by_ref: isset = 1; } - switch (opline->op2.u.constant.value.lval) { + switch (EX(opline)->op2.u.constant.value.lval) { case ZEND_ISSET: - Ts[opline->result.u.var].tmp_var.value.lval = isset; + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.lval = isset; break; case ZEND_ISEMPTY: if (!isset || !zend_is_true(value)) { - Ts[opline->result.u.var].tmp_var.value.lval = 1; + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.lval = 1; } else { - Ts[opline->result.u.var].tmp_var.value.lval = 0; + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.lval = 0; } break; } - Ts[opline->result.u.var].tmp_var.type = IS_BOOL; + EX(Ts)[EX(opline)->result.u.var].tmp_var.type = IS_BOOL; if (!var) { - FREE_OP(&opline->op1, EG(free_op1)); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); } } NEXT_OPCODE(); case ZEND_EXIT: - if (opline->op1.op_type != IS_UNUSED) { + if (EX(opline)->op1.op_type != IS_UNUSED) { zval *ptr; - ptr = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + ptr = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); if (Z_TYPE_P(ptr) == IS_LONG) { EG(exit_status) = Z_LVAL_P(ptr); } zend_print_variable(ptr); - FREE_OP(&opline->op1, EG(free_op1)); + FREE_OP(EX(Ts), &EX(opline)->op1, EG(free_op1)); } zend_bailout(); NEXT_OPCODE(); case ZEND_BEGIN_SILENCE: - Ts[opline->result.u.var].tmp_var.value.lval = EG(error_reporting); - Ts[opline->result.u.var].tmp_var.type = IS_LONG; /* shouldn't be necessary */ + EX(Ts)[EX(opline)->result.u.var].tmp_var.value.lval = EG(error_reporting); + EX(Ts)[EX(opline)->result.u.var].tmp_var.type = IS_LONG; /* shouldn't be necessary */ EG(error_reporting) = 0; NEXT_OPCODE(); case ZEND_END_SILENCE: - EG(error_reporting) = Ts[opline->op1.u.var].tmp_var.value.lval; + EG(error_reporting) = EX(Ts)[EX(opline)->op1.u.var].tmp_var.value.lval; NEXT_OPCODE(); case ZEND_QM_ASSIGN: { - zval *value = get_zval_ptr(&opline->op1, Ts, &EG(free_op1), BP_VAR_R); + zval *value = get_zval_ptr(&EX(opline)->op1, EX(Ts), &EG(free_op1), BP_VAR_R); - Ts[opline->result.u.var].tmp_var = *value; + EX(Ts)[EX(opline)->result.u.var].tmp_var = *value; if (!EG(free_op1)) { - zval_copy_ctor(&Ts[opline->result.u.var].tmp_var); + zval_copy_ctor(&EX(Ts)[EX(opline)->result.u.var].tmp_var); } } NEXT_OPCODE(); @@ -2536,13 +2544,13 @@ send_by_ref: } NEXT_OPCODE(); case ZEND_DECLARE_FUNCTION_OR_CLASS: - do_bind_function_or_class(opline, EG(function_table), EG(class_table), 0); + do_bind_function_or_class(EX(opline), EG(function_table), EG(class_table), 0); NEXT_OPCODE(); case ZEND_TICKS: - if (++EG(ticks_count)==opline->op1.u.constant.value.lval) { + if (++EG(ticks_count)==EX(opline)->op1.u.constant.value.lval) { EG(ticks_count)=0; if (zend_ticks_function) { - zend_ticks_function(opline->op1.u.constant.value.lval); + zend_ticks_function(EX(opline)->op1.u.constant.value.lval); } } NEXT_OPCODE(); -- cgit v1.2.1