From bd5c5d372916375981f76ed7800b2f4600acae05 Mon Sep 17 00:00:00 2001 From: Xinchen Hui Date: Thu, 11 Dec 2014 00:03:31 -0500 Subject: Save one xor instr --- Zend/zend_vm_def.h | 4 +++- Zend/zend_vm_execute.h | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 792beaee34..aa8ddd3520 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2847,7 +2847,7 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY) zend_vm_stack_free_call_frame(call TSRMLS_CC); } else { - zval *return_value = NULL; + zval *return_value; call->symbol_table = NULL; if (RETURN_VALUE_USED(opline)) { @@ -2855,6 +2855,8 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY) ZVAL_NULL(return_value); Z_VAR_FLAGS_P(return_value) = 0; + } else { + return_value = NULL; } call->prev_execute_data = execute_data; diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 7ea4293915..51dd045b2e 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -590,7 +590,7 @@ static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_vm_stack_free_call_frame(call TSRMLS_CC); } else { - zval *return_value = NULL; + zval *return_value; call->symbol_table = NULL; if (RETURN_VALUE_USED(opline)) { @@ -598,6 +598,8 @@ static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) ZVAL_NULL(return_value); Z_VAR_FLAGS_P(return_value) = 0; + } else { + return_value = NULL; } call->prev_execute_data = execute_data; -- cgit v1.2.1 From 634448e2de17af236357c4c6e9b2c4e6e324c22e Mon Sep 17 00:00:00 2001 From: Xinchen Hui Date: Thu, 11 Dec 2014 03:19:33 -0500 Subject: Revert "Save one xor instr" This reverts commit bd5c5d372916375981f76ed7800b2f4600acae05. --- Zend/zend_vm_def.h | 4 +--- Zend/zend_vm_execute.h | 4 +--- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index e03c7379eb..7490e577d7 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2848,7 +2848,7 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY) zend_vm_stack_free_call_frame(call TSRMLS_CC); } else { - zval *return_value; + zval *return_value = NULL; call->symbol_table = NULL; if (RETURN_VALUE_USED(opline)) { @@ -2856,8 +2856,6 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, ANY, ANY) ZVAL_NULL(return_value); Z_VAR_FLAGS_P(return_value) = 0; - } else { - return_value = NULL; } call->prev_execute_data = execute_data; diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 7ec9522444..e542fd538d 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -590,7 +590,7 @@ static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_vm_stack_free_call_frame(call TSRMLS_CC); } else { - zval *return_value; + zval *return_value = NULL; call->symbol_table = NULL; if (RETURN_VALUE_USED(opline)) { @@ -598,8 +598,6 @@ static int ZEND_FASTCALL ZEND_DO_FCALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) ZVAL_NULL(return_value); Z_VAR_FLAGS_P(return_value) = 0; - } else { - return_value = NULL; } call->prev_execute_data = execute_data; -- cgit v1.2.1 From 27dc5986dfad5f1b59581d654ade52457cd116ba Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Thu, 11 Dec 2014 13:18:40 +0300 Subject: Moved zend_is_true() from zend_execute.h/zend_execute_API.c into zend_operators.h/zend_operators.c. Splited the most expensive part of inline i_zend_is_true() into a separate zend_object_is_true(). Replaced zendi_convert_to_long() with cals to zend_is_true(). --- Zend/zend_execute.h | 67 ----------------------------------- Zend/zend_execute_API.c | 6 ---- Zend/zend_operators.c | 94 +++++++++++++++++-------------------------------- Zend/zend_operators.h | 56 ++++++++++++++++++++++++++++- 4 files changed, 88 insertions(+), 135 deletions(-) diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index d4a46db043..f13624be47 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -40,7 +40,6 @@ ZEND_API zend_execute_data *zend_create_generator_execute_data(zend_execute_data ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value TSRMLS_DC); ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC); ZEND_API void execute_internal(zend_execute_data *execute_data, zval *return_value TSRMLS_DC); -ZEND_API int zend_is_true(zval *op TSRMLS_DC); ZEND_API zend_class_entry *zend_lookup_class(zend_string *name TSRMLS_DC); ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload TSRMLS_DC); ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC); @@ -52,72 +51,6 @@ ZEND_API char * zend_verify_internal_arg_class_kind(const zend_internal_arg_info ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, char **class_name, zend_class_entry **pce TSRMLS_DC); ZEND_API void zend_verify_arg_error(int error_type, const zend_function *zf, uint32_t arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind, zval *arg TSRMLS_DC); -static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC) -{ - int result; - -again: - switch (Z_TYPE_P(op)) { - case IS_UNDEF: - case IS_NULL: - case IS_FALSE: - result = 0; - break; - case IS_TRUE: - result = 1; - break; - case IS_LONG: - result = (Z_LVAL_P(op)?1:0); - break; - case IS_RESOURCE: - result = (Z_RES_HANDLE_P(op)?1:0); - break; - case IS_DOUBLE: - result = (Z_DVAL_P(op) ? 1 : 0); - break; - case IS_STRING: - if (Z_STRLEN_P(op) == 0 - || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { - result = 0; - } else { - result = 1; - } - break; - case IS_ARRAY: - result = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); - break; - case IS_OBJECT: - if (Z_OBJ_HT_P(op)->cast_object) { - zval tmp; - if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, _IS_BOOL TSRMLS_CC) == SUCCESS) { - result = Z_TYPE(tmp) == IS_TRUE; - break; - } - zend_error(E_RECOVERABLE_ERROR, "Object of class %s could not be converted to boolean", Z_OBJ_P(op)->ce->name->val); - } else if (Z_OBJ_HT_P(op)->get) { - zval rv; - zval *tmp = Z_OBJ_HT_P(op)->get(op, &rv TSRMLS_CC); - if (Z_TYPE_P(tmp) != IS_OBJECT) { - /* for safety - avoid loop */ - convert_to_boolean(tmp); - result = Z_TYPE_P(tmp) == IS_TRUE; - zval_ptr_dtor(tmp); - break; - } - } - result = 1; - break; - case IS_REFERENCE: - op = Z_REFVAL_P(op); - goto again; - break; - default: - result = 0; - break; - } - return result; -} - static zend_always_inline zval* zend_assign_to_variable(zval *variable_ptr, zval *value, zend_uchar value_type TSRMLS_DC) { do { diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 7d5af4e9aa..2496f59136 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -501,12 +501,6 @@ ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ * } /* }}} */ -ZEND_API int zend_is_true(zval *op TSRMLS_DC) /* {{{ */ -{ - return i_zend_is_true(op TSRMLS_CC); -} -/* }}} */ - #define IS_VISITED_CONSTANT 0x80 #define IS_CONSTANT_VISITED(p) (Z_TYPE_P(p) & IS_VISITED_CONSTANT) #define MARK_CONSTANT_VISITED(p) Z_TYPE_INFO_P(p) |= IS_VISITED_CONSTANT diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index c045086520..5576937e61 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -259,49 +259,6 @@ try_again: /* }}} */ -/* {{{ zendi_convert_to_boolean */ -#define zendi_convert_to_boolean(op, holder, result) \ - if (op==result) { \ - convert_to_boolean(op); \ - } else if (Z_TYPE_P(op) != IS_FALSE && \ - Z_TYPE_P(op) != IS_TRUE) { \ - switch (Z_TYPE_P(op)) { \ - case IS_NULL: \ - ZVAL_BOOL(&holder, 0); \ - break; \ - case IS_RESOURCE: \ - ZVAL_BOOL(&holder, Z_RES_HANDLE_P(op) ? 1 : 0); \ - break; \ - case IS_LONG: \ - ZVAL_BOOL(&holder, Z_LVAL_P(op) ? 1 : 0); \ - break; \ - case IS_DOUBLE: \ - ZVAL_BOOL(&holder, Z_DVAL_P(op) ? 1 : 0); \ - break; \ - case IS_STRING: \ - if (Z_STRLEN_P(op) == 0 \ - || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { \ - ZVAL_BOOL(&holder, 0); \ - } else { \ - ZVAL_BOOL(&holder, 1); \ - } \ - break; \ - case IS_ARRAY: \ - ZVAL_BOOL(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \ - break; \ - case IS_OBJECT: \ - ZVAL_DUP(&(holder), (op)); \ - convert_to_boolean(&(holder)); \ - break; \ - default: \ - ZVAL_BOOL(&holder, 0); \ - break; \ - } \ - (op) = &(holder); \ - } - -/* }}} */ - /* {{{ convert_object_to_type */ #define convert_object_to_type(op, dst, ctype, conv_func) \ ZVAL_UNDEF(dst); \ @@ -1263,8 +1220,7 @@ ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) } } ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BOOL_XOR, boolean_xor_function); - zendi_convert_to_boolean(op1, op1_copy, result); - op1_val = (Z_TYPE_P(op1) == IS_TRUE); + op1_val = zval_is_true(op1); } } while (0); do { @@ -1284,8 +1240,7 @@ ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) } } ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BOOL_XOR); - zendi_convert_to_boolean(op2, op2_copy, result); - op2_val = (Z_TYPE_P(op2) == IS_TRUE); + op2_val = zval_is_true(op2); } } while (0); @@ -1315,9 +1270,7 @@ ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */ } ZEND_TRY_UNARY_OBJECT_OPERATION(ZEND_BOOL_NOT); - zendi_convert_to_boolean(op1, op1_copy, result); - - ZVAL_BOOL(result, Z_TYPE_P(op1) == IS_FALSE); + ZVAL_BOOL(result, !zval_is_true(op1)); } return SUCCESS; } @@ -1953,20 +1906,16 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* { } if (!converted) { if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) { - zendi_convert_to_boolean(op2, op2_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0); + ZVAL_LONG(result, zval_is_true(op2) ? -1 : 0); return SUCCESS; } else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) { - zendi_convert_to_boolean(op1, op1_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0); + ZVAL_LONG(result, zval_is_true(op1) ? 1 : 0); return SUCCESS; } else if (Z_TYPE_P(op1) == IS_TRUE) { - zendi_convert_to_boolean(op2, op2_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1); + ZVAL_LONG(result, zval_is_true(op2) ? 0 : 1); return SUCCESS; } else if (Z_TYPE_P(op2) == IS_TRUE) { - zendi_convert_to_boolean(op1, op1_copy, result); - ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1); + ZVAL_LONG(result, zval_is_true(op1) ? 0 : -1); return SUCCESS; } else { zendi_convert_scalar_to_number(op1, op1_copy, result); @@ -2384,10 +2333,33 @@ try_again: } /* }}} */ -ZEND_API int zval_is_true(zval *op) /* {{{ */ +ZEND_API int zend_is_true(zval *op TSRMLS_DC) /* {{{ */ { - convert_to_boolean(op); - return (Z_TYPE_P(op) == IS_TRUE ? 1 : 0); + return i_zend_is_true(op TSRMLS_CC); +} +/* }}} */ + +ZEND_API int zend_object_is_true(zval *op TSRMLS_DC) /* {{{ */ +{ + if (Z_OBJ_HT_P(op)->cast_object) { + zval tmp; + if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, _IS_BOOL TSRMLS_CC) == SUCCESS) { + return Z_TYPE(tmp) == IS_TRUE; + } + zend_error(E_RECOVERABLE_ERROR, "Object of class %s could not be converted to boolean", Z_OBJ_P(op)->ce->name->val); + } else if (Z_OBJ_HT_P(op)->get) { + int result; + zval rv; + zval *tmp = Z_OBJ_HT_P(op)->get(op, &rv TSRMLS_CC); + + if (Z_TYPE_P(tmp) != IS_OBJECT) { + /* for safety - avoid loop */ + result = i_zend_is_true(tmp TSRMLS_CC); + zval_ptr_dtor(tmp); + return result; + } + } + return 1; } /* }}} */ diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index f95e856e68..d7967c458a 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -252,7 +252,61 @@ ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2 #define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op) ZEND_FILE_LINE_CC); } #define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); } -ZEND_API int zval_is_true(zval *op); + +ZEND_API int zend_is_true(zval *op TSRMLS_DC); +ZEND_API int zend_object_is_true(zval *op TSRMLS_DC); + +#define zval_is_true(op) \ + zend_is_true(op TSRMLS_CC) + +static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC) +{ + int result; + +again: + switch (Z_TYPE_P(op)) { + case IS_UNDEF: + case IS_NULL: + case IS_FALSE: + result = 0; + break; + case IS_TRUE: + result = 1; + break; + case IS_LONG: + result = (Z_LVAL_P(op)?1:0); + break; + case IS_RESOURCE: + result = (Z_RES_HANDLE_P(op)?1:0); + break; + case IS_DOUBLE: + result = (Z_DVAL_P(op) ? 1 : 0); + break; + case IS_STRING: + if (Z_STRLEN_P(op) == 0 + || (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) { + result = 0; + } else { + result = 1; + } + break; + case IS_ARRAY: + result = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); + break; + case IS_OBJECT: + result = zend_object_is_true(op TSRMLS_CC); + break; + case IS_REFERENCE: + op = Z_REFVAL_P(op); + goto again; + break; + default: + result = 0; + break; + } + return result; +} + ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC); ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC); ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC); -- cgit v1.2.1 From 73458e8f19525c7814482161e86ab8bc266633fe Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Thu, 11 Dec 2014 15:01:06 +0300 Subject: Replaced zendi_convert_to_long() with _zval_get_long_func() --- Zend/zend_operators.c | 201 ++++++++++++++++++++++++-------------------------- 1 file changed, 96 insertions(+), 105 deletions(-) diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 5576937e61..9e43a87ba8 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -220,45 +220,6 @@ try_again: /* }}} */ -/* {{{ zendi_convert_to_long */ -#define zendi_convert_to_long(op, holder, result) \ - if (op == result) { \ - convert_to_long(op); \ - } else if (Z_TYPE_P(op) != IS_LONG) { \ - switch (Z_TYPE_P(op)) { \ - case IS_NULL: \ - case IS_FALSE: \ - ZVAL_LONG(&(holder), 0); \ - break; \ - case IS_TRUE: \ - ZVAL_LONG(&(holder), 1); \ - break; \ - case IS_DOUBLE: \ - ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\ - break; \ - case IS_STRING: \ - ZVAL_LONG(&holder, ZEND_STRTOL(Z_STRVAL_P(op), NULL, 10));\ - break; \ - case IS_ARRAY: \ - ZVAL_LONG(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0); \ - break; \ - case IS_OBJECT: \ - ZVAL_DUP(&(holder), (op)); \ - convert_to_long_base(&(holder), 10); \ - break; \ - case IS_RESOURCE: \ - ZVAL_LONG(&holder, Z_RES_HANDLE_P(op)); \ - break; \ - default: \ - zend_error(E_WARNING, "Cannot convert to ordinal value"); \ - ZVAL_LONG(&holder, 0); \ - break; \ - } \ - (op) = &(holder); \ - } - -/* }}} */ - /* {{{ convert_object_to_type */ #define convert_object_to_type(op, dst, ctype, conv_func) \ ZVAL_UNDEF(dst); \ @@ -1156,44 +1117,52 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - zend_long op1_lval; + zend_long op1_lval, op2_lval; do { if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) { if (Z_ISREF_P(op1)) { op1 = Z_REFVAL_P(op1); - if (Z_TYPE_P(op1) == IS_LONG) break; + if (Z_TYPE_P(op1) == IS_LONG) { + op1_lval = Z_LVAL_P(op1); + break; + } } ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_MOD, mod_function); - zendi_convert_to_long(op1, op1_copy, result); + op1_lval = _zval_get_long_func(op1 TSRMLS_CC); + } else { + op1_lval = Z_LVAL_P(op1); } } while (0); - op1_lval = Z_LVAL_P(op1); do { if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) { if (Z_ISREF_P(op2)) { op2 = Z_REFVAL_P(op2); - if (Z_TYPE_P(op2) == IS_LONG) break; + if (Z_TYPE_P(op2) == IS_LONG) { + op2_lval = Z_LVAL_P(op2); + break; + } } ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_MOD); - zendi_convert_to_long(op2, op2_copy, result); + op2_lval = _zval_get_long_func(op2 TSRMLS_CC); + } else { + op2_lval = Z_LVAL_P(op2); } } while (0); - if (Z_LVAL_P(op2) == 0) { + if (op2_lval == 0) { zend_error(E_WARNING, "Division by zero"); ZVAL_BOOL(result, 0); return FAILURE; /* modulus by zero */ } - if (Z_LVAL_P(op2) == -1) { + if (op2_lval == -1) { /* Prevent overflow error/crash if op1==LONG_MIN */ ZVAL_LONG(result, 0); return SUCCESS; } - ZVAL_LONG(result, op1_lval % Z_LVAL_P(op2)); + ZVAL_LONG(result, op1_lval % op2_lval); return SUCCESS; } /* }}} */ @@ -1310,8 +1279,7 @@ try_again: ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - zend_long op1_lval; + zend_long op1_lval, op2_lval; if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { ZVAL_LONG(result, Z_LVAL_P(op1) | Z_LVAL_P(op2)); @@ -1348,23 +1316,25 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) / if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) { ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_OR, bitwise_or_function); - zendi_convert_to_long(op1, op1_copy, result); + op1_lval = _zval_get_long_func(op1 TSRMLS_CC); + } else { + op1_lval = Z_LVAL_P(op1); } - op1_lval = Z_LVAL_P(op1); if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) { ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BW_OR); - zendi_convert_to_long(op2, op2_copy, result); + op2_lval = _zval_get_long_func(op2 TSRMLS_CC); + } else { + op2_lval = Z_LVAL_P(op2); } - ZVAL_LONG(result, op1_lval | Z_LVAL_P(op2)); + ZVAL_LONG(result, op1_lval | op2_lval); return SUCCESS; } /* }}} */ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - zend_long op1_lval; + zend_long op1_lval, op2_lval; if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { ZVAL_LONG(result, Z_LVAL_P(op1) & Z_LVAL_P(op2)); @@ -1400,24 +1370,26 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) } if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) { - ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_AND, bitwise_and_function); - zendi_convert_to_long(op1, op1_copy, result); + ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_AND, bitwise_or_function); + op1_lval = _zval_get_long_func(op1 TSRMLS_CC); + } else { + op1_lval = Z_LVAL_P(op1); } - op1_lval = Z_LVAL_P(op1); if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) { ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BW_AND); - zendi_convert_to_long(op2, op2_copy, result); + op2_lval = _zval_get_long_func(op2 TSRMLS_CC); + } else { + op2_lval = Z_LVAL_P(op2); } - ZVAL_LONG(result, op1_lval & Z_LVAL_P(op2)); + ZVAL_LONG(result, op1_lval & op2_lval); return SUCCESS; } /* }}} */ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - zend_long op1_lval; + zend_long op1_lval, op2_lval; if (EXPECTED(Z_TYPE_P(op1) == IS_LONG) && EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { ZVAL_LONG(result, Z_LVAL_P(op1) ^ Z_LVAL_P(op2)); @@ -1453,104 +1425,123 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) } if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) { - ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_XOR, bitwise_xor_function); - zendi_convert_to_long(op1, op1_copy, result); + ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_BW_XOR, bitwise_or_function); + op1_lval = _zval_get_long_func(op1 TSRMLS_CC); + } else { + op1_lval = Z_LVAL_P(op1); } - op1_lval = Z_LVAL_P(op1); if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) { ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_BW_XOR); - zendi_convert_to_long(op2, op2_copy, result); + op2_lval = _zval_get_long_func(op2 TSRMLS_CC); + } else { + op2_lval = Z_LVAL_P(op2); } - ZVAL_LONG(result, op1_lval ^ Z_LVAL_P(op2)); + ZVAL_LONG(result, op1_lval ^ op2_lval); return SUCCESS; } /* }}} */ ZEND_API int shift_left_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - zend_long op1_lval; + zend_long op1_lval, op2_lval; do { if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) { if (Z_ISREF_P(op1)) { op1 = Z_REFVAL_P(op1); - if (Z_TYPE_P(op1) == IS_LONG) break; + if (Z_TYPE_P(op1) == IS_LONG) { + op1_lval = Z_LVAL_P(op1); + break; + } } - ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_SL, shift_left_function); - zendi_convert_to_long(op1, op1_copy, result); + ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_SL, mod_function); + op1_lval = _zval_get_long_func(op1 TSRMLS_CC); + } else { + op1_lval = Z_LVAL_P(op1); } } while (0); - op1_lval = Z_LVAL_P(op1); do { if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) { if (Z_ISREF_P(op2)) { op2 = Z_REFVAL_P(op2); - if (Z_TYPE_P(op2) == IS_LONG) break; + if (Z_TYPE_P(op2) == IS_LONG) { + op2_lval = Z_LVAL_P(op2); + break; + } } ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_SL); - zendi_convert_to_long(op2, op2_copy, result); + op2_lval = _zval_get_long_func(op2 TSRMLS_CC); + } else { + op2_lval = Z_LVAL_P(op2); } } while (0); /* prevent wrapping quirkiness on some processors where << 64 + x == << x */ - if (Z_LVAL_P(op2) >= SIZEOF_ZEND_LONG * 8) { - ZVAL_LONG(result, 0); - return SUCCESS; - } - - if (Z_LVAL_P(op2) < 0) { - zend_error(E_WARNING, "Bit shift by negative number"); - ZVAL_FALSE(result); - return FAILURE; + if (UNEXPECTED((zend_ulong)op2_lval >= SIZEOF_ZEND_LONG * 8)) { + if (EXPECTED(op2_lval > 0)) { + ZVAL_LONG(result, 0); + return SUCCESS; + } else { + zend_error(E_WARNING, "Bit shift by negative number"); + ZVAL_FALSE(result); + return FAILURE; + } } - ZVAL_LONG(result, op1_lval << Z_LVAL_P(op2)); + ZVAL_LONG(result, op1_lval << op2_lval); return SUCCESS; } /* }}} */ ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; - zend_long op1_lval; + zend_long op1_lval, op2_lval; do { if (UNEXPECTED(Z_TYPE_P(op1) != IS_LONG)) { if (Z_ISREF_P(op1)) { op1 = Z_REFVAL_P(op1); - if (Z_TYPE_P(op1) == IS_LONG) break; + if (Z_TYPE_P(op1) == IS_LONG) { + op1_lval = Z_LVAL_P(op1); + break; + } } - ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_SR, shift_right_function); - zendi_convert_to_long(op1, op1_copy, result); + ZEND_TRY_BINARY_OP1_OBJECT_OPERATION(ZEND_SR, mod_function); + op1_lval = _zval_get_long_func(op1 TSRMLS_CC); + } else { + op1_lval = Z_LVAL_P(op1); } } while (0); - op1_lval = Z_LVAL_P(op1); do { if (UNEXPECTED(Z_TYPE_P(op2) != IS_LONG)) { if (Z_ISREF_P(op2)) { op2 = Z_REFVAL_P(op2); - if (Z_TYPE_P(op2) == IS_LONG) break; + if (Z_TYPE_P(op2) == IS_LONG) { + op2_lval = Z_LVAL_P(op2); + break; + } } ZEND_TRY_BINARY_OP2_OBJECT_OPERATION(ZEND_SR); - zendi_convert_to_long(op2, op2_copy, result); + op2_lval = _zval_get_long_func(op2 TSRMLS_CC); + } else { + op2_lval = Z_LVAL_P(op2); } } while (0); /* prevent wrapping quirkiness on some processors where >> 64 + x == >> x */ - if (Z_LVAL_P(op2) >= SIZEOF_ZEND_LONG * 8) { - ZVAL_LONG(result, (Z_LVAL_P(op1) < 0) ? -1 : 0); - return SUCCESS; - } - - if (Z_LVAL_P(op2) < 0) { - zend_error(E_WARNING, "Bit shift by negative number"); - ZVAL_FALSE(result); - return FAILURE; + if (UNEXPECTED((zend_ulong)op2_lval >= SIZEOF_ZEND_LONG * 8)) { + if (EXPECTED(op2_lval > 0)) { + ZVAL_LONG(result, (op1_lval < 0) ? -1 : 0); + return SUCCESS; + } else { + zend_error(E_WARNING, "Bit shift by negative number"); + ZVAL_FALSE(result); + return FAILURE; + } } - ZVAL_LONG(result, op1_lval >> Z_LVAL_P(op2)); + ZVAL_LONG(result, op1_lval >> op2_lval); return SUCCESS; } /* }}} */ -- cgit v1.2.1 From 381438e5df4534d5b2f0d5c7008289d35d4c372a Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Thu, 11 Dec 2014 19:18:31 +0300 Subject: Improved array_merge() and array_replace() (1-st array may be added using simple procedure). --- ext/standard/array.c | 228 +++++++++++++++++++++++++++++++---------------- ext/standard/php_array.h | 3 +- 2 files changed, 151 insertions(+), 80 deletions(-) diff --git a/ext/standard/array.c b/ext/standard/array.c index bacd98cf30..1f03e5acb8 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -2348,99 +2348,104 @@ PHP_FUNCTION(array_slice) } /* }}} */ -PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS_DC) /* {{{ */ +PHPAPI int php_array_merge_recursive(HashTable *dest, HashTable *src TSRMLS_DC) /* {{{ */ { zval *src_entry, *dest_entry; zend_string *string_key; - if (recursive) { - ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) { - if (string_key) { - if ((dest_entry = zend_hash_find(dest, string_key)) != NULL) { - zval *src_zval = src_entry; - zval *dest_zval = dest_entry; - HashTable *thash; - zval tmp; - int ret; - - ZVAL_DEREF(src_zval); - ZVAL_DEREF(dest_zval); - thash = Z_TYPE_P(dest_zval) == IS_ARRAY ? Z_ARRVAL_P(dest_zval) : NULL; - if ((thash && thash->u.v.nApplyCount > 1) || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) { - php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); - return 0; - } + ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) { + if (string_key) { + if ((dest_entry = zend_hash_find(dest, string_key)) != NULL) { + zval *src_zval = src_entry; + zval *dest_zval = dest_entry; + HashTable *thash; + zval tmp; + int ret; - if (Z_ISREF_P(dest_entry)) { - if (Z_REFCOUNT_P(dest_entry) == 1) { - ZVAL_UNREF(dest_entry); - } else { - Z_DELREF_P(dest_entry); - ZVAL_DUP(dest_entry, dest_zval); - } - dest_zval = dest_entry; - } else { - SEPARATE_ZVAL(dest_zval); - } + ZVAL_DEREF(src_zval); + ZVAL_DEREF(dest_zval); + thash = Z_TYPE_P(dest_zval) == IS_ARRAY ? Z_ARRVAL_P(dest_zval) : NULL; + if ((thash && thash->u.v.nApplyCount > 1) || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) { + php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected"); + return 0; + } - if (Z_TYPE_P(dest_zval) == IS_NULL) { - convert_to_array_ex(dest_zval); - add_next_index_null(dest_zval); + if (Z_ISREF_P(dest_entry)) { + if (Z_REFCOUNT_P(dest_entry) == 1) { + ZVAL_UNREF(dest_entry); } else { - convert_to_array_ex(dest_zval); + Z_DELREF_P(dest_entry); + ZVAL_DUP(dest_entry, dest_zval); + } + dest_zval = dest_entry; + } else { + SEPARATE_ZVAL(dest_zval); + } + if (Z_TYPE_P(dest_zval) == IS_NULL) { + convert_to_array_ex(dest_zval); + add_next_index_null(dest_zval); + } else { + convert_to_array_ex(dest_zval); + } + ZVAL_UNDEF(&tmp); + if (Z_TYPE_P(src_zval) == IS_OBJECT) { + ZVAL_DUP(&tmp, src_zval); + convert_to_array(&tmp); + src_zval = &tmp; + } + if (Z_TYPE_P(src_zval) == IS_ARRAY) { + if (thash && ZEND_HASH_APPLY_PROTECTION(thash)) { + thash->u.v.nApplyCount++; } - ZVAL_UNDEF(&tmp); - if (Z_TYPE_P(src_zval) == IS_OBJECT) { - ZVAL_DUP(&tmp, src_zval); - convert_to_array(&tmp); - src_zval = &tmp; + ret = php_array_merge_recursive(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval) TSRMLS_CC); + if (thash && ZEND_HASH_APPLY_PROTECTION(thash)) { + thash->u.v.nApplyCount--; } - if (Z_TYPE_P(src_zval) == IS_ARRAY) { - if (thash && ZEND_HASH_APPLY_PROTECTION(thash)) { - thash->u.v.nApplyCount++; - } - ret = php_array_merge(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval), 1 TSRMLS_CC); - if (thash && ZEND_HASH_APPLY_PROTECTION(thash)) { - thash->u.v.nApplyCount--; - } - if (!ret) { - return 0; - } - } else { - if (Z_REFCOUNTED_P(src_entry)) { - Z_ADDREF_P(src_entry); - } - zend_hash_next_index_insert(Z_ARRVAL_P(dest_zval), src_zval); + if (!ret) { + return 0; } - zval_ptr_dtor(&tmp); } else { if (Z_REFCOUNTED_P(src_entry)) { Z_ADDREF_P(src_entry); } - zend_hash_add_new(dest, string_key, src_entry); + zend_hash_next_index_insert(Z_ARRVAL_P(dest_zval), src_zval); } + zval_ptr_dtor(&tmp); } else { if (Z_REFCOUNTED_P(src_entry)) { Z_ADDREF_P(src_entry); } - zend_hash_next_index_insert_new(dest, src_entry); + zend_hash_add_new(dest, string_key, src_entry); } - } ZEND_HASH_FOREACH_END(); - } else { - ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) { - if (string_key) { - if (Z_REFCOUNTED_P(src_entry)) { - Z_ADDREF_P(src_entry); - } - zend_hash_update(dest, string_key, src_entry); - } else { - if (Z_REFCOUNTED_P(src_entry)) { - Z_ADDREF_P(src_entry); - } - zend_hash_next_index_insert_new(dest, src_entry); + } else { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); } - } ZEND_HASH_FOREACH_END(); - } + zend_hash_next_index_insert_new(dest, src_entry); + } + } ZEND_HASH_FOREACH_END(); + return 1; +} +/* }}} */ + +PHPAPI int php_array_merge(HashTable *dest, HashTable *src TSRMLS_DC) /* {{{ */ +{ + zval *src_entry; + zend_string *string_key; + + ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) { + if (string_key) { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); + } + zend_hash_update(dest, string_key, src_entry); + } else { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); + } + zend_hash_next_index_insert_new(dest, src_entry); + } + } ZEND_HASH_FOREACH_END(); return 1; } /* }}} */ @@ -2521,6 +2526,7 @@ PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC static void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETERS, int recursive, int replace) /* {{{ */ { zval *args = NULL; + zval *arg; int argc, i, init_size = 0; #ifndef FAST_ZPP @@ -2551,16 +2557,80 @@ static void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETERS, int array_init_size(return_value, init_size); - for (i = 0; i < argc; i++) { - zval *arg = args + i; + if (replace) { + zend_string *string_key; + zval *src_entry; + zend_ulong idx; + HashTable *src, *dest; + /* copy first array */ + arg = args; ZVAL_DEREF(arg); - if (!replace) { - php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg), recursive TSRMLS_CC); - } else if (recursive && i > 0) { /* First array will be copied directly instead */ - php_array_replace_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg) TSRMLS_CC); + src = Z_ARRVAL_P(arg); + dest = Z_ARRVAL_P(return_value); + ZEND_HASH_FOREACH_KEY_VAL(src, idx, string_key, src_entry) { + if (string_key) { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); + } + zend_hash_add_new(dest, string_key, src_entry); + } else { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); + } + zend_hash_index_add_new(dest, idx, src_entry); + } + } ZEND_HASH_FOREACH_END(); + + if (recursive) { + for (i = 1; i < argc; i++) { + arg = args + i; + ZVAL_DEREF(arg); + php_array_replace_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg) TSRMLS_CC); + } } else { - zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg), zval_add_ref, 1); + for (i = 1; i < argc; i++) { + arg = args + i; + ZVAL_DEREF(arg); + zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg), zval_add_ref, 1); + } + } + } else { + zend_string *string_key; + zval *src_entry; + HashTable *src, *dest; + + /* copy first array */ + arg = args; + ZVAL_DEREF(arg); + src = Z_ARRVAL_P(arg); + dest = Z_ARRVAL_P(return_value); + ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) { + if (string_key) { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); + } + zend_hash_add_new(dest, string_key, src_entry); + } else { + if (Z_REFCOUNTED_P(src_entry)) { + Z_ADDREF_P(src_entry); + } + zend_hash_next_index_insert_new(dest, src_entry); + } + } ZEND_HASH_FOREACH_END(); + + if (recursive) { + for (i = 1; i < argc; i++) { + arg = args + i; + ZVAL_DEREF(arg); + php_array_merge_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg) TSRMLS_CC); + } + } else { + for (i = 1; i < argc; i++) { + arg = args + i; + ZVAL_DEREF(arg); + php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg) TSRMLS_CC); + } } } } diff --git a/ext/standard/php_array.h b/ext/standard/php_array.h index d86121b277..31955042eb 100644 --- a/ext/standard/php_array.h +++ b/ext/standard/php_array.h @@ -104,7 +104,8 @@ PHP_FUNCTION(array_chunk); PHP_FUNCTION(array_combine); PHPAPI HashTable* php_splice(HashTable *, int, int, zval *, int, HashTable *); -PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS_DC); +PHPAPI int php_array_merge(HashTable *dest, HashTable *src TSRMLS_DC); +PHPAPI int php_array_merge_recursive(HashTable *dest, HashTable *src TSRMLS_DC); PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC); PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC); PHPAPI zend_long php_count_recursive(zval *array, zend_long mode TSRMLS_DC); -- cgit v1.2.1 From 2ea5f7aea4fe0ab7fe7f931040aebb52d3112999 Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Fri, 12 Dec 2014 08:09:42 +0300 Subject: Removed unused variables --- Zend/zend_operators.c | 3 --- 1 file changed, 3 deletions(-) diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index 9e43a87ba8..bdb4ea8861 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -1169,7 +1169,6 @@ ZEND_API int mod_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ * ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */ { - zval op1_copy, op2_copy; int op1_val, op2_val; do { @@ -1220,8 +1219,6 @@ ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */ { - zval op1_copy; - if (Z_TYPE_P(op1) < IS_TRUE) { ZVAL_TRUE(result); } else if (EXPECTED(Z_TYPE_P(op1) == IS_TRUE)) { -- cgit v1.2.1 From 9ea35a37b9425fc0dc392a754dac7e53791f5521 Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Fri, 12 Dec 2014 09:01:42 +0300 Subject: Make ZEND_INIT_FCALL keep predcalculted size of necessary stack space in opline->op1.num to avoid its recalculation on each execution. --- Zend/zend_compile.c | 6 +++++- Zend/zend_execute.h | 29 +++++++++++++++++++++-------- Zend/zend_vm_def.h | 4 ++-- Zend/zend_vm_execute.h | 4 ++-- ext/opcache/Optimizer/optimize_func_calls.c | 13 ++----------- 5 files changed, 32 insertions(+), 24 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 086c7d0db1..44ee16a574 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -2509,6 +2509,10 @@ void zend_compile_call_common(znode *result, zend_ast *args_ast, zend_function * opline = &CG(active_op_array)->opcodes[opnum_init]; opline->extended_value = arg_count; + if (opline->opcode == ZEND_INIT_FCALL) { + opline->op1.num = zend_vm_calc_used_stack(arg_count, fbc); + } + call_flags = (opline->opcode == ZEND_NEW ? ZEND_CALL_CTOR : 0); opline = zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL TSRMLS_CC); opline->op1.num = call_flags; @@ -2662,7 +2666,7 @@ static int zend_try_compile_ct_bound_init_user_func(zend_ast *name_ast, uint32_t opline = zend_emit_op(NULL, ZEND_INIT_FCALL, NULL, NULL TSRMLS_CC); opline->extended_value = num_args; - + opline->op1.num = zend_vm_calc_used_stack(num_args, fbc); opline->op2_type = IS_CONST; LITERAL_STR(opline->op2, lcname); zend_alloc_cache_slot(opline->op2.constant TSRMLS_CC); diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index f13624be47..5ab083e9f2 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -143,15 +143,10 @@ static zend_always_inline zval* zend_vm_stack_alloc(size_t size TSRMLS_DC) return (zval*)top; } -static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame(uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev TSRMLS_DC) +static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame_ex(uint32_t call_info, zend_function *func, uint32_t used_stack, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev TSRMLS_DC) { - uint32_t used_stack = ZEND_CALL_FRAME_SLOT + num_args; - zend_execute_data *call; - - if (ZEND_USER_CODE(func->type)) { - used_stack += func->op_array.last_var + func->op_array.T - MIN(func->op_array.num_args, num_args); - } - call = (zend_execute_data*)zend_vm_stack_alloc(used_stack * sizeof(zval) TSRMLS_CC); + zend_execute_data *call = (zend_execute_data*)zend_vm_stack_alloc(used_stack TSRMLS_CC); + call->func = func; Z_OBJ(call->This) = object; ZEND_SET_CALL_INFO(call, call_info); @@ -161,6 +156,24 @@ static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame(uint3 return call; } +static zend_always_inline uint32_t zend_vm_calc_used_stack(uint32_t num_args, zend_function *func) +{ + uint32_t used_stack = ZEND_CALL_FRAME_SLOT + num_args; + + if (ZEND_USER_CODE(func->type)) { + used_stack += func->op_array.last_var + func->op_array.T - MIN(func->op_array.num_args, num_args); + } + return used_stack * sizeof(zval); +} + +static zend_always_inline zend_execute_data *zend_vm_stack_push_call_frame(uint32_t call_info, zend_function *func, uint32_t num_args, zend_class_entry *called_scope, zend_object *object, zend_execute_data *prev TSRMLS_DC) +{ + uint32_t used_stack = zend_vm_calc_used_stack(num_args, func); + + return zend_vm_stack_push_call_frame_ex(call_info, + func, used_stack, called_scope, object, prev TSRMLS_CC); +} + static zend_always_inline void zend_vm_stack_free_extra_args(zend_execute_data *call TSRMLS_DC) { uint32_t first_extra_arg = call->func->op_array.num_args - ((call->func->common.fn_flags & ZEND_ACC_VARIADIC) != 0); diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 7490e577d7..c40574c902 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2736,8 +2736,8 @@ ZEND_VM_HANDLER(61, ZEND_INIT_FCALL, ANY, CONST) CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc); } - EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, - fbc, opline->extended_value, NULL, NULL, EX(call) TSRMLS_CC); + EX(call) = zend_vm_stack_push_call_frame_ex(ZEND_CALL_NESTED_FUNCTION, + fbc, opline->op1.num, NULL, NULL, EX(call) TSRMLS_CC); FREE_OP2(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index e542fd538d..64d7789185 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -1656,8 +1656,8 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER CACHE_PTR(Z_CACHE_SLOT_P(fname), fbc); } - EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, - fbc, opline->extended_value, NULL, NULL, EX(call) TSRMLS_CC); + EX(call) = zend_vm_stack_push_call_frame_ex(ZEND_CALL_NESTED_FUNCTION, + fbc, opline->op1.num, NULL, NULL, EX(call) TSRMLS_CC); ZEND_VM_NEXT_OPCODE(); } diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c index 9031a38f56..5c765cef4e 100644 --- a/ext/opcache/Optimizer/optimize_func_calls.c +++ b/ext/opcache/Optimizer/optimize_func_calls.c @@ -80,11 +80,13 @@ void optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx TSRMLS if (fcall->opcode == ZEND_INIT_FCALL_BY_NAME) { fcall->opcode = ZEND_INIT_FCALL; + fcall->op1.num = zend_vm_calc_used_stack(fcall->extended_value, call_stack[call].func); Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]); literal_dtor(&ZEND_OP2_LITERAL(fcall)); fcall->op2.constant = fcall->op2.constant + 1; } else if (fcall->opcode == ZEND_INIT_NS_FCALL_BY_NAME) { fcall->opcode = ZEND_INIT_FCALL; + fcall->op1.num = zend_vm_calc_used_stack(fcall->extended_value, call_stack[call].func); Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]); literal_dtor(&op_array->literals[fcall->op2.constant]); literal_dtor(&op_array->literals[fcall->op2.constant + 2]); @@ -92,17 +94,6 @@ void optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx TSRMLS } else { ZEND_ASSERT(0); } - } else if (call_stack[call].opline && - call_stack[call].opline->opcode == ZEND_INIT_FCALL_BY_NAME && - call_stack[call].opline->extended_value == 0 && - ZEND_OP2_IS_CONST_STRING(call_stack[call].opline)) { - - zend_op *fcall = call_stack[call].opline; - - fcall->opcode = ZEND_INIT_FCALL; - Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]); - literal_dtor(&ZEND_OP2_LITERAL(fcall)); - fcall->op2.constant = fcall->op2.constant + 1; } call_stack[call].func = NULL; call_stack[call].opline = NULL; -- cgit v1.2.1 From 14e29f51460ecd1ec9ae7a26dfb9dcb2c81768d5 Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Fri, 12 Dec 2014 10:19:41 +0300 Subject: Reduced size of zend_op on 64-bit systems. the main idea - the smaller the zend_op structure, the lees memory traffic is required to load VM instructions during execution. The patch reduces the size of each opcode from 48 to 32 bytes (saves 16 bytes for each opcode, and applications use thousands of opoceds). This reduced the number of CPU cache misses by 12% and improved performance of real-life apps by 1-2%. The patch affects how constants and jump targets are represented in VM during execution. Previously they were implemented as absolute 64-bit pointers. Now they are relative 32-bit offsets. In run-time constant now should be accessed as: RT_CONSTANT(op_array, opine->op1) instead of opline->op1.zv EX_CONSTANT(opline->op1) instead of opline->op1.zv Jump targets: OP_JMP_ADDR(opline, opline->op2) instead of opline->op2.jmp_addr The patch doesn't change zend_op representation for 32-bit systems. They still use absolute addresses. The compile-time representation is also kept the same. --- Zend/zend_compile.c | 54 +- Zend/zend_compile.h | 164 ++- Zend/zend_execute.c | 16 +- Zend/zend_execute.h | 12 +- Zend/zend_inheritance.c | 2 +- Zend/zend_opcode.c | 19 +- Zend/zend_vm_def.h | 284 ++--- Zend/zend_vm_execute.h | 1848 ++++++++++++++++---------------- Zend/zend_vm_gen.php | 16 +- ext/opcache/Optimizer/pass1_5.c | 2 +- ext/opcache/Optimizer/zend_optimizer.c | 20 +- ext/opcache/zend_persist.c | 7 +- ext/reflection/php_reflection.c | 10 +- sapi/phpdbg/phpdbg_opcode.c | 6 +- 14 files changed, 1309 insertions(+), 1151 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 44ee16a574..ec449fd1da 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -32,12 +32,6 @@ #include "zend_language_scanner.h" #include "zend_inheritance.h" -#define CONSTANT_EX(op_array, op) \ - (op_array)->literals[op] - -#define CONSTANT(op) \ - CONSTANT_EX(CG(active_op_array), op) - #define SET_NODE(target, src) do { \ target ## _type = (src)->op_type; \ if ((src)->op_type == IS_CONST) { \ @@ -50,7 +44,7 @@ #define GET_NODE(target, src) do { \ (target)->op_type = src ## _type; \ if ((target)->op_type == IS_CONST) { \ - (target)->u.constant = CONSTANT(src.constant); \ + ZVAL_COPY_VALUE(&(target)->u.constant, CT_CONSTANT(src)); \ } else { \ (target)->u.op = src; \ } \ @@ -291,11 +285,11 @@ static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{ void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */ { - zval_dtor(&CONSTANT_EX(op_array, n)); + zval_dtor(CT_CONSTANT_EX(op_array, n)); if (n + 1 == op_array->last_literal) { op_array->last_literal--; } else { - ZVAL_UNDEF(&CONSTANT_EX(op_array, n)); + ZVAL_UNDEF(CT_CONSTANT_EX(op_array, n)); } } /* }}} */ @@ -310,7 +304,7 @@ static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int li Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE); } } - ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv); + ZVAL_COPY_VALUE(CT_CONSTANT_EX(op_array, literal_position), zv); Z_CACHE_SLOT(op_array->literals[literal_position]) = -1; } /* }}} */ @@ -752,13 +746,13 @@ static void str_dtor(zval *zv) /* {{{ */ { void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC) /* {{{ */ { zend_label *dest; - zend_long current, distance; + int current, distance; zval *label; if (pass2) { - label = opline->op2.zv; + label = RT_CONSTANT(op_array, opline->op2); } else { - label = &CONSTANT_EX(op_array, opline->op2.constant); + label = CT_CONSTANT_EX(op_array, opline->op2.constant); } if (CG(context).labels == NULL || (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) { @@ -888,11 +882,11 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, const zend_op *opli zval *op1, *op2; if (compile_time) { - op1 = &CONSTANT_EX(op_array, opline->op1.constant); - op2 = &CONSTANT_EX(op_array, opline->op2.constant); + op1 = CT_CONSTANT_EX(op_array, opline->op1.constant); + op2 = CT_CONSTANT_EX(op_array, opline->op2.constant); } else { - op1 = opline->op1.zv; - op2 = opline->op2.zv; + op1 = RT_CONSTANT(op_array, opline->op1); + op2 = RT_CONSTANT(op_array, opline->op2); } function = zend_hash_find_ptr(function_table, Z_STR_P(op1)); @@ -928,11 +922,11 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze zval *op1, *op2; if (compile_time) { - op1 = &CONSTANT_EX(op_array, opline->op1.constant); - op2 = &CONSTANT_EX(op_array, opline->op2.constant); + op1 = CT_CONSTANT_EX(op_array, opline->op1.constant); + op2 = CT_CONSTANT_EX(op_array, opline->op2.constant); } else { - op1 = opline->op1.zv; - op2 = opline->op2.zv; + op1 = RT_CONSTANT(op_array, opline->op1); + op2 = RT_CONSTANT(op_array, opline->op2); } if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) { zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1)); @@ -965,11 +959,11 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array zval *op1, *op2; if (compile_time) { - op1 = &CONSTANT_EX(op_array, opline->op1.constant); - op2 = &CONSTANT_EX(op_array, opline->op2.constant); + op1 = CT_CONSTANT_EX(op_array, opline->op1.constant); + op2 = CT_CONSTANT_EX(op_array, opline->op2.constant); } else { - op1 = opline->op1.zv; - op2 = opline->op2.zv; + op1 = RT_CONSTANT(op_array, opline->op1); + op2 = RT_CONSTANT(op_array, opline->op2); } ce = zend_hash_find_ptr(class_table, Z_STR_P(op1)); @@ -1032,7 +1026,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */ zval *parent_name; zend_class_entry *ce; - parent_name = &CONSTANT(fetch_class_opline->op2.constant); + parent_name = CT_CONSTANT(fetch_class_opline->op2); if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) || ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) && (ce->type == ZEND_INTERNAL_CLASS))) { @@ -1071,7 +1065,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */ return; } - zend_hash_del(table, Z_STR(CONSTANT(opline->op1.constant))); + zend_hash_del(table, Z_STR_P(CT_CONSTANT(opline->op1))); zend_del_literal(CG(active_op_array), opline->op1.constant); zend_del_literal(CG(active_op_array), opline->op2.constant); MAKE_NOP(opline); @@ -1087,7 +1081,7 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS CG(in_compilation) = 1; while (opline_num != -1) { - if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) { + if ((ce = zend_lookup_class(Z_STR_P(RT_CONSTANT(op_array, op_array->opcodes[opline_num-1].op2)) TSRMLS_CC)) != NULL) { do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC); } opline_num = op_array->opcodes[opline_num].result.opline_num; @@ -2112,7 +2106,7 @@ static zend_op *zend_delayed_compile_prop(znode *result, zend_ast *ast, uint32_t opline = zend_delayed_emit_op(result, ZEND_FETCH_OBJ_R, &obj_node, &prop_node TSRMLS_CC); if (opline->op2_type == IS_CONST) { - convert_to_string(&CONSTANT(opline->op2.constant)); + convert_to_string(CT_CONSTANT(opline->op2)); zend_alloc_polymorphic_cache_slot(opline->op2.constant TSRMLS_CC); } @@ -3519,7 +3513,7 @@ void zend_compile_switch(zend_ast *ast TSRMLS_DC) /* {{{ */ opline = zend_emit_op(NULL, ZEND_CASE, &expr_node, &cond_node TSRMLS_CC); SET_NODE(opline->result, &case_node); if (opline->op1_type == IS_CONST) { - zval_copy_ctor(&CONSTANT(opline->op1.constant)); + zval_copy_ctor(CT_CONSTANT(opline->op1)); } jmpnz_opnums[i] = zend_emit_cond_jump(ZEND_JMPNZ, &case_node, 0 TSRMLS_CC); diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 63d67660c6..c44b37b995 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -56,13 +56,34 @@ typedef struct _zend_compiler_context { HashTable *labels; } zend_compiler_context; +/* On 64-bi systems less optimal, but more compact VM code leads to better + * performance. So on 32-bit systems we use absolute addresses for jump + * targets and constants, but on 64-bit systems realtive 32-bit offsets */ +#if SIZEOF_SIZE_T == 4 +# define ZEND_USE_ABS_JMP_ADDR 1 +# define ZEND_USE_ABS_CONST_ADDR 1 +# define ZEND_EX_USE_LITERALS 0 +# define ZEND_EX_USE_RUN_TIME_CACHE 1 +#else +# define ZEND_USE_ABS_JMP_ADDR 0 +# define ZEND_USE_ABS_CONST_ADDR 0 +# define ZEND_EX_USE_LITERALS 1 +# define ZEND_EX_USE_RUN_TIME_CACHE 1 +#endif + typedef union _znode_op { uint32_t constant; uint32_t var; uint32_t num; uint32_t opline_num; /* Needs to be signed */ +#if ZEND_USE_ABS_JMP_ADDR zend_op *jmp_addr; +#else + uint32_t jmp_offset; +#endif +#if ZEND_USE_ABS_CONST_ADDR zval *zv; +#endif } znode_op; typedef struct _znode { /* used only during compilation */ @@ -112,8 +133,8 @@ struct _zend_op { znode_op op1; znode_op op2; znode_op result; - zend_ulong extended_value; - uint lineno; + uint32_t extended_value; + uint32_t lineno; zend_uchar opcode; zend_uchar op1_type; zend_uchar op2_type; @@ -374,12 +395,17 @@ typedef enum _zend_call_kind { struct _zend_execute_data { const zend_op *opline; /* executed opline */ zend_execute_data *call; /* current call */ - void **run_time_cache; + zval *return_value; zend_function *func; /* executed op_array */ zval This; +#if ZEND_EX_USE_RUN_TIME_CACHE + void **run_time_cache; +#endif +#if ZEND_EX_USE_LITERALS + zval *literals; +#endif zend_class_entry *called_scope; zend_execute_data *prev_execute_data; - zval *return_value; zend_array *symbol_table; }; @@ -430,6 +456,136 @@ struct _zend_execute_data { #define EX_VAR_TO_NUM(n) (ZEND_CALL_VAR(NULL, n) - ZEND_CALL_VAR_NUM(NULL, 0)) +#define ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline_num) \ + ((char*)&(op_array)->opcodes[opline_num] - (char*)(opline)) + +#define ZEND_OFFSET_TO_OPLINE(base, offset) \ + ((zend_op*)(((char*)(base)) + (int)offset)) + +#define ZEND_OFFSET_TO_OPLINE_NUM(op_array, base, offset) \ + (ZEND_OFFSET_TO_OPLINE(base, offset) - op_array->opcodes) + +#if ZEND_USE_ABS_JMP_ADDR + +/* run-time jump target */ +# define OP_JMP_ADDR(opline, node) \ + (node).jmp_addr + +/* convert jump target from compile-time to run-time */ +# define ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \ + (node).jmp_addr = (op_array)->opcodes + (node).opline_num; \ + } while (0) + +/* convert jump target back from run-time to compile-time */ +# define ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \ + (node).opline_num = (node).jmp_addr - (op_array)->opcodes; \ + } while (0) + +#else + +/* run-time jump target */ +# define OP_JMP_ADDR(opline, node) \ + ZEND_OFFSET_TO_OPLINE(opline, (node).jmp_offset) + +/* convert jump target from compile-time to run-time */ +# define ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, node) do { \ + (node).jmp_offset = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, (node).opline_num); \ + } while (0) + +/* convert jump target back from run-time to compile-time */ +# define ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, node) do { \ + (node).opline_num = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, (node).jmp_offset); \ + } while (0) + +#endif + +/* constant-time constant */ +# define CT_CONSTANT_EX(op_array, num) \ + ((op_array)->literals + (num)) + +# define CT_CONSTANT(node) \ + CT_CONSTANT_EX(CG(active_op_array), (node).constant) + +#if ZEND_USE_ABS_CONST_ADDR + +/* run-time constant */ +# define RT_CONSTANT_EX(base, node) \ + (node).zv + +/* convert constant from compile-time to run-time */ +# define ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, node) do { \ + (node).zv = CT_CONSTANT_EX(op_array, (node).constant); \ + } while (0) + +/* convert constant back from run-time to compile-time */ +# define ZEND_PASS_TWO_UNDO_CONSTANT(op_array, node) do { \ + (node).constant = (node).zv - (op_array)->literals; \ + } while (0) + +#else + +/* run-time constant */ +# define RT_CONSTANT_EX(base, node) \ + ((zval*)(((char*)(base)) + (node).constant)) + +/* convert constant from compile-time to run-time */ +# define ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, node) do { \ + (node).constant *= sizeof(zval); \ + } while (0) + +/* convert constant back from run-time to compile-time (do nothing) */ +# define ZEND_PASS_TWO_UNDO_CONSTANT(op_array, node) do { \ + (node).constant /= sizeof(zval); \ + } while (0) + +#endif + +#if ZEND_EX_USE_LITERALS + +# define EX_LITERALS() \ + EX(literals) + +# define EX_LOAD_LITERALS(op_array) do { \ + EX(literals) = (op_array)->literals; \ + } while (0) + +#else + +# define EX_LITERALS() \ + EX(func)->op_array.literals + +# define EX_LOAD_LITERALS(op_array) do { \ + } while (0) + +#endif + +/* run-time constant */ +#define RT_CONSTANT(op_array, node) \ + RT_CONSTANT_EX((op_array)->literals, node) + +/* constant in currently executed function */ +#define EX_CONSTANT(node) \ + RT_CONSTANT_EX(EX_LITERALS(), node) + +#if ZEND_EX_USE_RUN_TIME_CACHE + +# define EX_RUN_TIME_CACHE() \ + EX(run_time_cache) + +# define EX_LOAD_RUN_TIME_CACHE(op_array) do { \ + EX(run_time_cache) = (op_array)->run_time_cache; \ + } while (0) + +#else + +# define EX_RUN_TIME_CACHE() \ + EX(func)->op_array.run_time_cache + +# define EX_LOAD_RUN_TIME_CACHE(op_array) do { \ + } while (0) + +#endif + #define IS_CONST (1<<0) #define IS_TMP_VAR (1<<1) #define IS_VAR (1<<2) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index fbe52fe95a..aff92a3952 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -402,7 +402,7 @@ static zend_always_inline zval *_get_zval_ptr(int op_type, znode_op node, const } else { *should_free = NULL; if (op_type == IS_CONST) { - return node.zv; + return EX_CONSTANT(node); } else { ZEND_ASSERT(op_type == IS_CV); return _get_zval_ptr_cv(execute_data, node.var, type TSRMLS_CC); @@ -422,7 +422,7 @@ static zend_always_inline zval *_get_zval_ptr_deref(int op_type, znode_op node, } else { *should_free = NULL; if (op_type == IS_CONST) { - return node.zv; + return EX_CONSTANT(node); } else { ZEND_ASSERT(op_type == IS_CV); return _get_zval_ptr_cv_deref(execute_data, node.var, type TSRMLS_CC); @@ -1674,7 +1674,8 @@ static zend_always_inline void i_init_func_execute_data(zend_execute_data *execu if (!op_array->run_time_cache && op_array->last_cache_slot) { op_array->run_time_cache = zend_arena_calloc(&CG(arena), op_array->last_cache_slot, sizeof(void*)); } - EX(run_time_cache) = op_array->run_time_cache; + EX_LOAD_RUN_TIME_CACHE(op_array); + EX_LOAD_LITERALS(op_array); EG(current_execute_data) = execute_data; } @@ -1698,7 +1699,8 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu if (!op_array->run_time_cache && op_array->last_cache_slot) { op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*)); } - EX(run_time_cache) = op_array->run_time_cache; + EX_LOAD_RUN_TIME_CACHE(op_array); + EX_LOAD_LITERALS(op_array); EG(current_execute_data) = execute_data; } @@ -1772,7 +1774,8 @@ static zend_always_inline void i_init_execute_data(zend_execute_data *execute_da op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*)); } } - EX(run_time_cache) = op_array->run_time_cache; + EX_LOAD_RUN_TIME_CACHE(op_array); + EX_LOAD_LITERALS(op_array); EG(current_execute_data) = execute_data; } @@ -1897,8 +1900,7 @@ static zend_always_inline void zend_vm_stack_extend_call_frame(zend_execute_data OPLINE = new_op #define ZEND_VM_SET_RELATIVE_OPCODE(opline, offset) \ - CHECK_SYMBOL_TABLES() \ - OPLINE = ((zend_op*)(((char*)opline)+(offset))) + ZEND_VM_SET_OPCODE(ZEND_OFFSET_TO_OPLINE(opline, offset)) #define ZEND_VM_JMP(new_op) \ if (EXPECTED(!EG(exception))) { \ diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index 5ab083e9f2..3eab9662db 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -265,20 +265,20 @@ ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table TSRMLS_ void zend_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC); #define CACHED_PTR(num) \ - EX(run_time_cache)[(num)] + EX_RUN_TIME_CACHE()[(num)] #define CACHE_PTR(num, ptr) do { \ - EX(run_time_cache)[(num)] = (ptr); \ + EX_RUN_TIME_CACHE()[(num)] = (ptr); \ } while (0) #define CACHED_POLYMORPHIC_PTR(num, ce) \ - ((EX(run_time_cache)[(num)] == (ce)) ? \ - EX(run_time_cache)[(num) + 1] : \ + ((EX_RUN_TIME_CACHE()[(num)] == (ce)) ? \ + EX_RUN_TIME_CACHE()[(num) + 1] : \ NULL) #define CACHE_POLYMORPHIC_PTR(num, ce, ptr) do { \ - EX(run_time_cache)[(num)] = (ce); \ - EX(run_time_cache)[(num) + 1] = (ptr); \ + EX_RUN_TIME_CACHE()[(num)] = (ce); \ + EX_RUN_TIME_CACHE()[(num) + 1] = (ptr); \ } while (0) #define CACHED_PTR_EX(slot) \ diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 407acade0e..8f0d9fecb7 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -454,7 +454,7 @@ static zend_string *zend_get_function_declaration(zend_function *fptr TSRMLS_DC) } } if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) { - zval *zv = precv->op2.zv; + zval *zv = RT_CONSTANT(&fptr->op_array, precv->op2); if (Z_TYPE_P(zv) == IS_CONSTANT) { smart_str_append(&str, Z_STR_P(zv)); diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 0ab110b52c..1bc788a644 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -662,9 +662,10 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC) } } case ZEND_GOTO: - if (Z_TYPE(op_array->literals[opline->op2.constant]) != IS_LONG) { + if (Z_TYPE_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) != IS_LONG) { uint32_t num = opline->op2.constant; - opline->op2.zv = &op_array->literals[opline->op2.constant]; + + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline->op2); zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC); opline->op2.constant = num; } @@ -717,12 +718,12 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC) end = opline + op_array->last; while (opline < end) { if (opline->op1_type == IS_CONST) { - opline->op1.zv = &op_array->literals[opline->op1.constant]; + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline->op1); } else if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) { opline->op1.var = (uint32_t)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, op_array->last_var + opline->op1.var); } if (opline->op2_type == IS_CONST) { - opline->op2.zv = &op_array->literals[opline->op2.constant]; + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline->op2); } else if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) { opline->op2.var = (uint32_t)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, op_array->last_var + opline->op2.var); } @@ -735,17 +736,17 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC) opline->extended_value = (uint32_t)(zend_intptr_t)ZEND_CALL_VAR_NUM(NULL, op_array->last_var + opline->extended_value); break; case ZEND_GOTO: - if (Z_TYPE_P(opline->op2.zv) != IS_LONG) { + if (Z_TYPE_P(RT_CONSTANT(op_array, opline->op2)) != IS_LONG) { zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC); } /* break omitted intentionally */ case ZEND_JMP: case ZEND_FAST_CALL: - opline->op1.jmp_addr = &op_array->opcodes[opline->op1.opline_num]; + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op1); break; case ZEND_JMPZNZ: /* absolute index to relative offset */ - opline->extended_value = (char*)(op_array->opcodes + opline->extended_value) - (char*)opline; + opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value); /* break omitted intentionally */ case ZEND_JMPZ: case ZEND_JMPNZ: @@ -756,12 +757,12 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC) case ZEND_NEW: case ZEND_FE_RESET: case ZEND_FE_FETCH: - opline->op2.jmp_addr = &op_array->opcodes[opline->op2.opline_num]; + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, opline->op2); break; case ZEND_RETURN: case ZEND_RETURN_BY_REF: if (op_array->fn_flags & ZEND_ACC_GENERATOR) { - if (opline->op1_type != IS_CONST || Z_TYPE_P(opline->op1.zv) != IS_NULL) { + if (opline->op1_type != IS_CONST || Z_TYPE_P(RT_CONSTANT(op_array, opline->op1)) != IS_NULL) { CG(zend_lineno) = opline->lineno; zend_error_noreturn(E_COMPILE_ERROR, "Generators cannot return values using \"return\""); } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index c40574c902..223ecf9a0d 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -361,7 +361,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR| /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -375,7 +375,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR| zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -388,7 +388,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMPVAR| ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -759,7 +759,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|C /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -772,7 +772,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|C zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -789,7 +789,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR|C if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -846,7 +846,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR| /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -856,7 +856,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR| } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -872,7 +872,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMPVAR| ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -1118,10 +1118,10 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED|CONST|V zend_class_entry *ce; if (OP2_TYPE == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (OP1_TYPE != IS_CONST) { zend_string_release(name); @@ -1130,12 +1130,12 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED|CONST|V CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((OP1_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((OP1_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); FREE_OP1(); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -1423,7 +1423,7 @@ ZEND_VM_C_LABEL(fetch_obj_r_no_object): } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -1452,7 +1452,7 @@ ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMPVAR|CV) zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -1476,7 +1476,7 @@ ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMPVAR|CV) if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -1536,7 +1536,7 @@ ZEND_VM_C_LABEL(fetch_obj_is_no_object): } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -1570,7 +1570,7 @@ ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, CONST|TMP|VAR|UNUSED|CV, CONST|TMPV if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -1596,7 +1596,7 @@ ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMPVAR|CV) if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, OP1_TYPE, property, OP2_TYPE, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); FREE_OP2(); if (OP1_TYPE == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -1657,7 +1657,7 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV) if (OP1_TYPE == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, OP1_TYPE, property_name, OP2_TYPE, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, OP1_TYPE, property_name, OP2_TYPE, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); FREE_OP2(); FREE_OP1_VAR_PTR(); /* assign_obj has two opcodes! */ @@ -1935,7 +1935,7 @@ ZEND_VM_HANDLER(42, ZEND_JMP, ANY, ANY) { USE_OPLINE - ZEND_VM_SET_OPCODE(opline->op1.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1)); ZEND_VM_CONTINUE(); } @@ -1953,9 +1953,9 @@ ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMPVAR|CV, ANY) ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (OP1_TYPE == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -1963,7 +1963,7 @@ ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMPVAR|CV, ANY) if (i_zend_is_true(val TSRMLS_CC)) { opline++; } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } FREE_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -1982,7 +1982,7 @@ ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMPVAR|CV, ANY) val = GET_OP1_ZVAL_PTR(BP_VAR_R); if (Z_TYPE_P(val) == IS_TRUE) { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (OP1_TYPE == IS_CV) { @@ -1994,7 +1994,7 @@ ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMPVAR|CV, ANY) } if (i_zend_is_true(val TSRMLS_CC)) { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { opline++; } @@ -2019,17 +2019,17 @@ ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMPVAR|CV, ANY) ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (OP1_TYPE == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } if (i_zend_is_true(val TSRMLS_CC)) { - opline = (zend_op*)(((char*)opline) + opline->extended_value); + opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } FREE_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -2054,9 +2054,9 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMPVAR|CV, ANY) } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); if (OP1_TYPE == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -2068,7 +2068,7 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMPVAR|CV, ANY) } else { FREE_OP1(); ZVAL_FALSE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -2087,7 +2087,7 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMPVAR|CV, ANY) if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); @@ -2100,7 +2100,7 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMPVAR|CV, ANY) } if (i_zend_is_true(val TSRMLS_CC)) { ZVAL_TRUE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { ZVAL_FALSE(EX_VAR(opline->result.var)); opline++; @@ -2134,7 +2134,7 @@ ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP|UNUSED, CONST) ZVAL_EMPTY_STRING(str); } - add_char_to_string(str, str, opline->op2.zv); + add_char_to_string(str, str, EX_CONSTANT(opline->op2)); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ /*CHECK_EXCEPTION();*/ @@ -2153,7 +2153,7 @@ ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TMP|UNUSED, CONST) ZVAL_EMPTY_STRING(str); } - add_string_to_string(str, str, opline->op2.zv); + add_string_to_string(str, str, EX_CONSTANT(opline->op2)); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ /*CHECK_EXCEPTION();*/ @@ -2222,7 +2222,7 @@ ZEND_VM_C_LABEL(try_class_name): if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC); CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { @@ -2335,7 +2335,7 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMPVAR|UNUSED|CV, CONST|TMPVAR|CV) } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -2375,17 +2375,17 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMPVAR|UNUSE if (OP1_TYPE == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -2393,11 +2393,11 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMPVAR|UNUSE if (OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (OP1_TYPE != IS_CONST && OP2_TYPE == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (OP2_TYPE != IS_UNUSED) { zend_free_op free_op2; @@ -2415,7 +2415,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMPVAR|UNUSE if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -2493,16 +2493,16 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMPVAR|CV) zend_function *fbc; zval *function_name, *func; - if (OP2_TYPE == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { - function_name = (zval*)(opline->op2.zv+1); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (OP2_TYPE == IS_CONST && Z_TYPE_P(EX_CONSTANT(opline->op2)) == IS_STRING) { + function_name = (zval*)(EX_CONSTANT(opline->op2)+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, @@ -2673,7 +2673,7 @@ ZEND_VM_HANDLER(118, ZEND_INIT_USER_CALL, CONST, CONST|TMPVAR|CV) } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error); + zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -2695,21 +2695,21 @@ ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST) zval *func; zend_function *fbc; - func_name = opline->op2.zv + 1; - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + func_name = EX_CONSTANT(opline->op2) + 1; + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) { func_name++; if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, @@ -3080,12 +3080,12 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV) ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->extended_value]); ZEND_VM_CONTINUE(); /* CHECK_ME */ } - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + catch_ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), catch_ce); } ce = EG(exception)->ce; @@ -3677,7 +3677,7 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST) SAVE_OPLINE(); param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); if (arg_num > EX_NUM_ARGS()) { - ZVAL_COPY_VALUE(param, opline->op2.zv); + ZVAL_COPY_VALUE(param, EX_CONSTANT(opline->op2)); if (Z_OPT_CONSTANT_P(param)) { zval_update_constant(param, 0 TSRMLS_CC); } else { @@ -3689,7 +3689,7 @@ ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST) } if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { - zend_verify_arg_type(EX(func), arg_num, param, opline->op2.zv TSRMLS_CC); + zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2) TSRMLS_CC); } CHECK_EXCEPTION(); @@ -3760,7 +3760,7 @@ ZEND_VM_HANDLER(50, ZEND_BRK, ANY, CONST) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->brk); } @@ -3771,7 +3771,7 @@ ZEND_VM_HANDLER(51, ZEND_CONT, ANY, CONST) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->cont); } @@ -3783,7 +3783,7 @@ ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value, + el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->extended_value, &EX(func)->op_array, execute_data TSRMLS_CC); brk_opline = EX(func)->op_array.opcodes + el->brk; @@ -3793,7 +3793,7 @@ ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST) zval_ptr_dtor_nogc(EX_VAR(brk_opline->op1.var)); } } - ZEND_VM_JMP(opline->op1.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1)); } ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMPVAR|CV, CONST|TMPVAR|CV) @@ -3821,15 +3821,15 @@ ZEND_VM_HANDLER(68, ZEND_NEW, CONST|VAR, ANY) SAVE_OPLINE(); if (OP1_TYPE == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -3852,7 +3852,7 @@ ZEND_VM_HANDLER(68, ZEND_NEW, CONST|VAR, ANY) } else { OBJ_RELEASE(Z_OBJ(object_zval)); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { /* We are not handling overloaded classes right now */ EX(call) = zend_vm_stack_push_call_frame( @@ -3951,17 +3951,17 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) zend_constant *c; zval *retval; - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); - } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); + } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(EX_CONSTANT(opline->op2)), '\\', Z_STRLEN_P(EX_CONSTANT(opline->op2))); if (!actual) { - ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(opline->op2.zv))); + ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(EX_CONSTANT(opline->op2)))); } else { actual++; ZVAL_STRINGL(EX_VAR(opline->result.var), - actual, Z_STRLEN_P(opline->op2.zv) - (actual - Z_STRVAL_P(opline->op2.zv))); + actual, Z_STRLEN_P(EX_CONSTANT(opline->op2)) - (actual - Z_STRVAL_P(EX_CONSTANT(opline->op2)))); } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", @@ -3969,10 +3969,10 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { - zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } else { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), c); } retval = EX_VAR(opline->result.var); ZVAL_COPY_VALUE(retval, &c->value); @@ -3989,33 +3989,33 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) zval *value; if (OP1_TYPE == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); ZEND_VM_C_GOTO(constant_fetch_end); - } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); - if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce)) != NULL) { ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); ZEND_VM_C_GOTO(constant_fetch_end); } } - if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { ZVAL_DEREF(value); if (Z_CONSTANT_P(value)) { EG(scope) = ce; @@ -4023,16 +4023,16 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST) EG(scope) = EX(func)->op_array.scope; } if (OP1_TYPE == IS_CONST) { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), value); } else { - CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRLEN_P(EX_CONSTANT(opline->op2)) == sizeof("class")-1 && memcmp(Z_STRVAL_P(EX_CONSTANT(opline->op2)), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); } else { - zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } ZEND_VM_C_LABEL(constant_fetch_end): @@ -4432,10 +4432,10 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR) zend_class_entry *ce; if (OP2_TYPE == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (OP1_TYPE != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -4444,14 +4444,14 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR) HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((OP1_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((OP1_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -4579,7 +4579,7 @@ ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMPVAR|CV) } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -4744,7 +4744,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY) if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_FETCH_BYREF) { FREE_OP1_VAR_PTR(); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; if (Z_TYPE(p->val) == IS_UNDEF || @@ -4775,7 +4775,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY) FREE_OP1_VAR_PTR(); } if (is_empty) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -4810,7 +4810,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) pos = ptr->pos; if (UNEXPECTED(pos == INVALID_IDX)) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else if (UNEXPECTED(ptr->ht != fe_ht)) { ptr->ht = fe_ht; pos = 0; @@ -4833,7 +4833,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) while (1) { if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; value = &p->val; @@ -4891,7 +4891,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) pos = ptr->pos; if (pos == INVALID_IDX) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else if (UNEXPECTED(ptr->ht != fe_ht)) { ptr->ht = fe_ht; pos = 0; @@ -4914,7 +4914,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) while (1) { if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; @@ -4994,7 +4994,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) zval_ptr_dtor(array_ref); HANDLE_EXCEPTION(); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } value = iter->funcs->get_current_data(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { @@ -5003,7 +5003,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) } if (!value) { /* failure in get_current_data */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } if (opline->extended_value & ZEND_FE_FETCH_BYREF) { ZVAL_MAKE_REF(value); @@ -5028,7 +5028,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY) } } else { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } } @@ -5066,20 +5066,20 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMPVAR|CV, UNUSED|CONST|VAR) zend_class_entry *ce; if (OP2_TYPE == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((OP1_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((OP1_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -5249,7 +5249,7 @@ ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED|CV, CONST| ZEND_VM_C_LABEL(isset_no_object): result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -5365,7 +5365,7 @@ ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY) if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); FREE_OP1(); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } FREE_OP1(); @@ -5400,7 +5400,7 @@ ZEND_VM_HANDLER(169, ZEND_COALESCE, CONST|TMP|VAR|CV, ANY) if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); FREE_OP1(); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } FREE_OP1(); @@ -5489,8 +5489,8 @@ ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY) zval *zce, *orig_zce; SAVE_OPLINE(); - if ((zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op2.zv))) == NULL || - ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op1.zv))) != NULL && + if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)))) == NULL || + ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) != NULL && Z_CE_P(zce) != Z_CE_P(orig_zce))) { do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC); } @@ -5538,17 +5538,17 @@ ZEND_VM_C_LABEL(try_instanceof): zend_class_entry *ce; if (OP2_TYPE == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { ZVAL_FALSE(EX_VAR(opline->result.var)); FREE_OP1(); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); @@ -5583,15 +5583,15 @@ ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST) zend_class_entry *iface; SAVE_OPLINE(); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + iface = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_INTERFACE TSRMLS_CC); + iface = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_INTERFACE TSRMLS_CC); if (UNEXPECTED(iface == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), iface); } if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) { @@ -5610,11 +5610,11 @@ ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY) zend_class_entry *trait; SAVE_OPLINE(); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + trait = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), - opline->op2.zv + 1, + trait = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), + EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_TRAIT TSRMLS_CC); if (UNEXPECTED(trait == NULL)) { CHECK_EXCEPTION(); @@ -5623,7 +5623,7 @@ ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY) if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) { zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), trait); } zend_do_implement_trait(ce, trait TSRMLS_CC); @@ -5832,7 +5832,7 @@ ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED) SAVE_OPLINE(); - if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(opline->op1.zv))) == NULL) || + if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(EX_CONSTANT(opline->op1)))) == NULL) || UNEXPECTED(Z_FUNC_P(zfunc)->type != ZEND_USER_FUNCTION)) { zend_error_noreturn(E_ERROR, "Base lambda function for closure not found"); } @@ -6029,7 +6029,7 @@ ZEND_VM_HANDLER(162, ZEND_FAST_CALL, ANY, ANY) Z_OBJ_P(fast_call) = NULL; /* set return address */ fast_call->u2.lineno = opline - EX(func)->op_array.opcodes; - ZEND_VM_SET_OPCODE(opline->op1.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1)); ZEND_VM_CONTINUE(); } @@ -6240,12 +6240,12 @@ ZEND_VM_HANDLER(122, ZEND_DEFINED, CONST, ANY) zend_constant *c; SAVE_OPLINE(); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { ZVAL_TRUE(EX_VAR(opline->result.var)); - } else if ((c = zend_quick_get_constant(opline->op1.zv, 0 TSRMLS_CC)) == NULL) { + } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op1), 0 TSRMLS_CC)) == NULL) { ZVAL_FALSE(EX_VAR(opline->result.var)); } else { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), c); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), c); ZVAL_TRUE(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 64d7789185..408b59d692 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -482,7 +482,7 @@ static int ZEND_FASTCALL ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - ZEND_VM_SET_OPCODE(opline->op1.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1)); ZEND_VM_CONTINUE(); } @@ -1120,8 +1120,8 @@ static int ZEND_FASTCALL ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND zval *zce, *orig_zce; SAVE_OPLINE(); - if ((zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op2.zv))) == NULL || - ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op1.zv))) != NULL && + if ((zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op2)))) == NULL || + ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(EX_CONSTANT(opline->op1)))) != NULL && Z_CE_P(zce) != Z_CE_P(orig_zce))) { do_bind_inherited_class(&EX(func)->op_array, opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC); } @@ -1171,11 +1171,11 @@ static int ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_class_entry *trait; SAVE_OPLINE(); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + trait = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), - opline->op2.zv + 1, + trait = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), + EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_TRAIT TSRMLS_CC); if (UNEXPECTED(trait == NULL)) { CHECK_EXCEPTION(); @@ -1184,7 +1184,7 @@ static int ZEND_FASTCALL ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) { zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), trait); } zend_do_implement_trait(ce, trait TSRMLS_CC); @@ -1381,7 +1381,7 @@ static int ZEND_FASTCALL ZEND_FAST_CALL_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) Z_OBJ_P(fast_call) = NULL; /* set return address */ fast_call->u2.lineno = opline - EX(func)->op_array.opcodes; - ZEND_VM_SET_OPCODE(opline->op1.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op1)); ZEND_VM_CONTINUE(); } @@ -1433,14 +1433,14 @@ static int ZEND_FASTCALL ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE ZEND_VM_NEXT_OPCODE(); } else { - zval *class_name = opline->op2.zv; + zval *class_name = EX_CONSTANT(opline->op2); try_class_name: if (IS_CONST == IS_CONST) { if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC); CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { @@ -1468,16 +1468,16 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE zend_function *fbc; zval *function_name, *func; - if (IS_CONST == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { - function_name = (zval*)(opline->op2.zv+1); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (IS_CONST == IS_CONST && Z_TYPE_P(EX_CONSTANT(opline->op2)) == IS_STRING) { + function_name = (zval*)(EX_CONSTANT(opline->op2)+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, @@ -1492,7 +1492,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE zend_object *object; SAVE_OPLINE(); - function_name = opline->op2.zv; + function_name = EX_CONSTANT(opline->op2); try_function_name: if (IS_CONST != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { @@ -1615,21 +1615,21 @@ static int ZEND_FASTCALL ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPC zval *func; zend_function *fbc; - func_name = opline->op2.zv + 1; - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + func_name = EX_CONSTANT(opline->op2) + 1; + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) { func_name++; if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, @@ -1642,7 +1642,7 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER { USE_OPLINE - zval *fname = opline->op2.zv; + zval *fname = EX_CONSTANT(opline->op2); zval *func; zend_function *fbc; @@ -1671,7 +1671,7 @@ static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); param = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC); if (arg_num > EX_NUM_ARGS()) { - ZVAL_COPY_VALUE(param, opline->op2.zv); + ZVAL_COPY_VALUE(param, EX_CONSTANT(opline->op2)); if (Z_OPT_CONSTANT_P(param)) { zval_update_constant(param, 0 TSRMLS_CC); } else { @@ -1683,7 +1683,7 @@ static int ZEND_FASTCALL ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ } if (UNEXPECTED((EX(func)->op_array.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) { - zend_verify_arg_type(EX(func), arg_num, param, opline->op2.zv TSRMLS_CC); + zend_verify_arg_type(EX(func), arg_num, param, EX_CONSTANT(opline->op2) TSRMLS_CC); } CHECK_EXCEPTION(); @@ -1696,7 +1696,7 @@ static int ZEND_FASTCALL ZEND_BRK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->brk); } @@ -1707,7 +1707,7 @@ static int ZEND_FASTCALL ZEND_CONT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->op1.opline_num, + el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->op1.opline_num, &EX(func)->op_array, execute_data TSRMLS_CC); ZEND_VM_JMP(EX(func)->op_array.opcodes + el->cont); } @@ -1719,7 +1719,7 @@ static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zend_brk_cont_element *el; SAVE_OPLINE(); - el = zend_brk_cont(Z_LVAL_P(opline->op2.zv), opline->extended_value, + el = zend_brk_cont(Z_LVAL_P(EX_CONSTANT(opline->op2)), opline->extended_value, &EX(func)->op_array, execute_data TSRMLS_CC); brk_opline = EX(func)->op_array.opcodes + el->brk; @@ -1729,7 +1729,7 @@ static int ZEND_FASTCALL ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval_ptr_dtor_nogc(EX_VAR(brk_opline->op1.var)); } } - ZEND_VM_JMP(opline->op1.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op1)); } static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -1739,15 +1739,15 @@ static int ZEND_FASTCALL ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND zend_class_entry *iface; SAVE_OPLINE(); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + iface = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_INTERFACE TSRMLS_CC); + iface = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_INTERFACE TSRMLS_CC); if (UNEXPECTED(iface == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), iface); } if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) { @@ -1780,7 +1780,7 @@ try_class_name: if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC); CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { @@ -1823,7 +1823,7 @@ try_class_name: if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC); CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { @@ -1851,16 +1851,16 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA zend_function *fbc; zval *function_name, *func; - if (IS_CV == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { - function_name = (zval*)(opline->op2.zv+1); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (IS_CV == IS_CONST && Z_TYPE_P(EX_CONSTANT(opline->op2)) == IS_STRING) { + function_name = (zval*)(EX_CONSTANT(opline->op2)+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, @@ -2012,7 +2012,7 @@ try_class_name: if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) { Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name)); } else { - Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC); + Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC); CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var))); } } else if (Z_TYPE_P(class_name) == IS_OBJECT) { @@ -2041,16 +2041,16 @@ static int ZEND_FASTCALL ZEND_INIT_FCALL_BY_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCOD zend_function *fbc; zval *function_name, *func; - if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_TYPE_P(opline->op2.zv) == IS_STRING) { - function_name = (zval*)(opline->op2.zv+1); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_TYPE_P(EX_CONSTANT(opline->op2)) == IS_STRING) { + function_name = (zval*)(EX_CONSTANT(opline->op2)+1); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) { SAVE_OPLINE(); - zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } else { fbc = Z_FUNC_P(func); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), fbc); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), fbc); } EX(call) = zend_vm_stack_push_call_frame(ZEND_CALL_NESTED_FUNCTION, @@ -2189,7 +2189,7 @@ static int ZEND_FASTCALL ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); bitwise_not_function(EX_VAR(opline->result.var), - opline->op1.zv TSRMLS_CC); + EX_CONSTANT(opline->op1) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -2202,7 +2202,7 @@ static int ZEND_FASTCALL ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_FALSE(EX_VAR(opline->result.var)); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { @@ -2222,7 +2222,7 @@ static int ZEND_FASTCALL ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *z; SAVE_OPLINE(); - z = opline->op1.zv; + z = EX_CONSTANT(opline->op1); if (Z_TYPE_P(z) == IS_STRING) { zend_string *str = Z_STR_P(z); @@ -2258,16 +2258,16 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *val; SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (Z_TYPE_P(val) == IS_TRUE) { ZEND_VM_SET_OPCODE(opline + 1); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (IS_CONST == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -2275,7 +2275,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (i_zend_is_true(val TSRMLS_CC)) { opline++; } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { @@ -2291,10 +2291,10 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS zval *val; SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (Z_TYPE_P(val) == IS_TRUE) { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (IS_CONST == IS_CV) { @@ -2306,7 +2306,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS } if (i_zend_is_true(val TSRMLS_CC)) { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { opline++; } @@ -2324,24 +2324,24 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG zval *val; SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (EXPECTED(Z_TYPE_P(val) == IS_TRUE)) { ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (IS_CONST == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } if (i_zend_is_true(val TSRMLS_CC)) { - opline = (zend_op*)(((char*)opline) + opline->extended_value); + opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { @@ -2357,7 +2357,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zval *val; SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_TRUE(EX_VAR(opline->result.var)); @@ -2366,9 +2366,9 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); if (IS_CONST == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -2380,7 +2380,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR } else { ZVAL_FALSE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -2395,11 +2395,11 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A zval *val; SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); @@ -2412,7 +2412,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A } if (i_zend_is_true(val TSRMLS_CC)) { ZVAL_TRUE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { ZVAL_FALSE(EX_VAR(opline->result.var)); opline++; @@ -2431,7 +2431,7 @@ static int ZEND_FASTCALL ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - retval_ptr = opline->op1.zv; + retval_ptr = EX_CONSTANT(opline->op1); if (!EX(return_value)) { @@ -2470,7 +2470,7 @@ static int ZEND_FASTCALL ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND /* Not supposed to happen, but we'll allow it */ zend_error(E_NOTICE, "Only variable references should be returned by reference"); - retval_ptr = opline->op1.zv; + retval_ptr = EX_CONSTANT(opline->op1); if (!EX(return_value)) { if (IS_CONST == IS_TMP_VAR) { @@ -2523,7 +2523,7 @@ static int ZEND_FASTCALL ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); do { if (IS_CONST == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { @@ -2558,7 +2558,7 @@ static int ZEND_FASTCALL ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); arg = ZEND_CALL_ARG(EX(call), opline->op2.num); ZEND_CALL_NUM_ARGS(EX(call)) = opline->op2.num; ZVAL_COPY_VALUE(arg, value); @@ -2580,7 +2580,7 @@ static int ZEND_FASTCALL ZEND_SEND_VAL_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num)) { zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.num); } - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); arg = ZEND_CALL_ARG(EX(call), opline->op2.num); ZEND_CALL_NUM_ARGS(EX(call)) = opline->op2.num; ZVAL_COPY_VALUE(arg, value); @@ -2599,7 +2599,7 @@ static int ZEND_FASTCALL ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); - val = opline->op1.zv; + val = EX_CONSTANT(opline->op1); if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_TRUE(EX_VAR(opline->result.var)); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { @@ -2621,15 +2621,15 @@ static int ZEND_FASTCALL ZEND_NEW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -2652,7 +2652,7 @@ static int ZEND_FASTCALL ZEND_NEW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } else { OBJ_RELEASE(Z_OBJ(object_zval)); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { /* We are not handling overloaded classes right now */ EX(call) = zend_vm_stack_push_call_frame( @@ -2686,7 +2686,7 @@ static int ZEND_FASTCALL ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS zend_object_clone_obj_t clone_call; SAVE_OPLINE(); - obj = opline->op1.zv; + obj = EX_CONSTANT(opline->op1); do { if (IS_CONST == IS_CONST || @@ -2750,7 +2750,7 @@ static int ZEND_FASTCALL ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - expr = opline->op1.zv; + expr = EX_CONSTANT(opline->op1); switch (opline->extended_value) { case IS_NULL: @@ -2855,7 +2855,7 @@ static int ZEND_FASTCALL ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA zend_bool failure_retval=0; SAVE_OPLINE(); - inc_filename = opline->op1.zv; + inc_filename = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp_inc_filename); if (Z_TYPE_P(inc_filename) != IS_STRING) { @@ -3004,7 +3004,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref); } } else { - array_ptr = array_ref = opline->op1.zv; + array_ptr = array_ref = EX_CONSTANT(opline->op1); if (IS_CONST & (IS_VAR|IS_CV)) { ZVAL_DEREF(array_ptr); } @@ -3124,7 +3124,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_FETCH_BYREF) { } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; if (Z_TYPE(p->val) == IS_UNDEF || @@ -3155,7 +3155,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A } if (is_empty) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -3170,7 +3170,7 @@ static int ZEND_FASTCALL ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); if (IS_CONST != IS_UNUSED) { - zval *ptr = opline->op1.zv; + zval *ptr = EX_CONSTANT(opline->op1); do { if (Z_TYPE_P(ptr) == IS_LONG) { @@ -3201,7 +3201,7 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR int is_ref = 0; SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) { is_ref = 1; @@ -3219,7 +3219,7 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } CHECK_EXCEPTION(); @@ -3234,7 +3234,7 @@ static int ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A int is_ref = 0; SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) { is_ref = 1; @@ -3253,7 +3253,7 @@ static int ZEND_FASTCALL ZEND_COALESCE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } CHECK_EXCEPTION(); @@ -3267,7 +3267,7 @@ static int ZEND_FASTCALL ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ zval *value; SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && Z_ISREF_P(value)) { ZVAL_COPY(EX_VAR(opline->result.var), Z_REFVAL_P(value)); @@ -3292,7 +3292,7 @@ static int ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); try_strlen: if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); @@ -3336,7 +3336,7 @@ static int ZEND_FASTCALL ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); switch (opline->extended_value) { case IS_NULL: case IS_LONG: @@ -3382,12 +3382,12 @@ static int ZEND_FASTCALL ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR zend_constant *c; SAVE_OPLINE(); - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { ZVAL_TRUE(EX_VAR(opline->result.var)); - } else if ((c = zend_quick_get_constant(opline->op1.zv, 0 TSRMLS_CC)) == NULL) { + } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op1), 0 TSRMLS_CC)) == NULL) { ZVAL_FALSE(EX_VAR(opline->result.var)); } else { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), c); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), c); ZVAL_TRUE(EX_VAR(opline->result.var)); } CHECK_EXCEPTION(); @@ -3401,8 +3401,8 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); fast_add_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3416,8 +3416,8 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); fast_sub_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3431,8 +3431,8 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); fast_mul_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3446,8 +3446,8 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); fast_div_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3461,8 +3461,8 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); fast_mod_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3476,8 +3476,8 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); shift_left_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3491,8 +3491,8 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); shift_right_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3506,8 +3506,8 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); concat_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3521,8 +3521,8 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3537,8 +3537,8 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP SAVE_OPLINE(); fast_is_not_identical_function(result, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3553,8 +3553,8 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); fast_equal_function(result, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3569,8 +3569,8 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE SAVE_OPLINE(); fast_not_equal_function(result, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3585,8 +3585,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); fast_is_smaller_function(result, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3601,8 +3601,8 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND SAVE_OPLINE(); fast_is_smaller_or_equal_function(result, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3616,8 +3616,8 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); bitwise_or_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3631,8 +3631,8 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); bitwise_and_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3646,8 +3646,8 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); bitwise_xor_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3661,8 +3661,8 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); boolean_xor_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -3679,7 +3679,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type HashTable *target_symbol_table; SAVE_OPLINE(); - varname = opline->op1.zv; + varname = EX_CONSTANT(opline->op1); if (IS_CONST == IS_CONST) { name = Z_STR_P(varname); @@ -3694,10 +3694,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (IS_CONST != IS_CONST) { zend_string_release(name); @@ -3706,12 +3706,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -3824,8 +3824,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_ zval *container; SAVE_OPLINE(); - container = opline->op1.zv; - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + container = EX_CONSTANT(opline->op1); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); CHECK_EXCEPTION(); @@ -3839,8 +3839,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE zval *container; SAVE_OPLINE(); - container = opline->op1.zv; - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + container = EX_CONSTANT(opline->op1); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); CHECK_EXCEPTION(); @@ -3863,7 +3863,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_ if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -3873,8 +3873,8 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_ if (IS_CONST == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } - container = opline->op1.zv; - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + container = EX_CONSTANT(opline->op1); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); } @@ -3891,8 +3891,8 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_ zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; - offset = opline->op2.zv; + container = EX_CONSTANT(opline->op1); + offset = EX_CONSTANT(opline->op2); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -3933,7 +3933,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -3955,8 +3955,8 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; - offset = opline->op2.zv; + container = EX_CONSTANT(opline->op1); + offset = EX_CONSTANT(opline->op2); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -3996,7 +3996,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -4020,7 +4020,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_ zval *property; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = NULL; if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) { @@ -4029,7 +4029,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_ if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -4049,18 +4049,18 @@ static int ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H zval *container; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); try_fetch_list: if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), EX_CONSTANT(opline->op2), IS_CONST, BP_VAR_R TSRMLS_CC); ZVAL_COPY(EX_VAR(opline->result.var), value); } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, opline->op2.zv, BP_VAR_R, result TSRMLS_CC); + zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, EX_CONSTANT(opline->op2), BP_VAR_R, result TSRMLS_CC); if (retval) { if (result != retval) { @@ -4091,17 +4091,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -4109,16 +4109,16 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (IS_CONST == IS_CONST && IS_CONST == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_CONST != IS_CONST && IS_CONST == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (IS_CONST != IS_UNUSED) { - function_name = opline->op2.zv; + function_name = EX_CONSTANT(opline->op2); if (IS_CONST != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { @@ -4131,7 +4131,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER( if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -4207,7 +4207,7 @@ static int ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCO { USE_OPLINE - zval *function_name = opline->op2.zv; + zval *function_name = EX_CONSTANT(opline->op2); zend_fcall_info_cache fcc; char *error = NULL; zend_function *func; @@ -4242,7 +4242,7 @@ static int ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER(ZEND_OPCO } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error); + zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -4264,8 +4264,8 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_equal_function(result, - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -4280,17 +4280,17 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO zend_constant *c; zval *retval; - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); - } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); + } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(EX_CONSTANT(opline->op2)), '\\', Z_STRLEN_P(EX_CONSTANT(opline->op2))); if (!actual) { - ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(opline->op2.zv))); + ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(EX_CONSTANT(opline->op2)))); } else { actual++; ZVAL_STRINGL(EX_VAR(opline->result.var), - actual, Z_STRLEN_P(opline->op2.zv) - (actual - Z_STRVAL_P(opline->op2.zv))); + actual, Z_STRLEN_P(EX_CONSTANT(opline->op2)) - (actual - Z_STRVAL_P(EX_CONSTANT(opline->op2)))); } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", @@ -4298,10 +4298,10 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { - zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } else { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), c); } retval = EX_VAR(opline->result.var); ZVAL_COPY_VALUE(retval, &c->value); @@ -4318,33 +4318,33 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO zval *value; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; - } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); - if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce)) != NULL) { ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; } } - if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { ZVAL_DEREF(value); if (Z_CONSTANT_P(value)) { EG(scope) = ce; @@ -4352,16 +4352,16 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO EG(scope) = EX(func)->op_array.scope; } if (IS_CONST == IS_CONST) { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), value); } else { - CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRLEN_P(EX_CONSTANT(opline->op2)) == sizeof("class")-1 && memcmp(Z_STRVAL_P(EX_CONSTANT(opline->op2)), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); } else { - zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } constant_fetch_end: @@ -4386,7 +4386,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O Z_ADDREF_P(expr_ptr); } else { - expr_ptr = opline->op1.zv; + expr_ptr = EX_CONSTANT(opline->op1); if (IS_CONST == IS_TMP_VAR) { ZVAL_COPY_VALUE(&new_expr, expr_ptr); expr_ptr = &new_expr; @@ -4406,7 +4406,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O if (IS_CONST != IS_UNUSED) { - zval *offset = opline->op2.zv; + zval *offset = EX_CONSTANT(opline->op2); zend_string *str; zend_ulong hval; @@ -4518,7 +4518,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA ZEND_VM_NEXT_OPCODE(); } - varname = opline->op1.zv; + varname = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp); if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { @@ -4530,10 +4530,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -4542,14 +4542,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -4585,7 +4585,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O ZEND_VM_NEXT_OPCODE(); } else { - zval tmp, *varname = opline->op1.zv; + zval tmp, *varname = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp); if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { @@ -4597,20 +4597,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -4644,8 +4644,8 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER(ZE zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; - offset = opline->op2.zv; + container = EX_CONSTANT(opline->op1); + offset = EX_CONSTANT(opline->op2); isset_dim_obj_again: if (IS_CONST != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -4760,8 +4760,8 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(Z zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; - offset = opline->op2.zv; + container = EX_CONSTANT(opline->op1); + offset = EX_CONSTANT(opline->op2); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -4778,7 +4778,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER(Z isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -4799,8 +4799,8 @@ static int ZEND_FASTCALL ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCOD zend_constant c; SAVE_OPLINE(); - name = opline->op1.zv; - val = opline->op2.zv; + name = EX_CONSTANT(opline->op1); + val = EX_CONSTANT(opline->op2); ZVAL_COPY_VALUE(&c.value, val); if (Z_OPT_CONSTANT(c.value)) { @@ -4852,7 +4852,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); ZVAL_COPY_VALUE(&generator->value, value); if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); @@ -4881,7 +4881,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE } } else { - zval *value = opline->op1.zv; + zval *value = EX_CONSTANT(opline->op1); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -4906,7 +4906,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE /* Set the new yielded key */ if (IS_CONST != IS_UNUSED) { - zval *key = opline->op2.zv; + zval *key = EX_CONSTANT(opline->op2); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -4961,8 +4961,8 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); pow_function(EX_VAR(opline->result.var), - opline->op1.zv, - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op1), + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -4976,7 +4976,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -4992,7 +4992,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCO SAVE_OPLINE(); fast_is_not_identical_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -5029,7 +5029,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); ZVAL_COPY_VALUE(&generator->value, value); if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); @@ -5058,7 +5058,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ } } else { - zval *value = opline->op1.zv; + zval *value = EX_CONSTANT(opline->op1); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -5138,7 +5138,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -5154,7 +5154,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCO SAVE_OPLINE(); fast_is_not_identical_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -5172,7 +5172,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, HashTable *target_symbol_table; SAVE_OPLINE(); - varname = opline->op1.zv; + varname = EX_CONSTANT(opline->op1); if (IS_CONST == IS_CONST) { name = Z_STR_P(varname); @@ -5187,10 +5187,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (IS_CONST != IS_CONST) { zend_string_release(name); @@ -5199,12 +5199,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -5340,7 +5340,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND ZEND_VM_NEXT_OPCODE(); } - varname = opline->op1.zv; + varname = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp); if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { @@ -5352,10 +5352,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -5364,14 +5364,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -5407,7 +5407,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC ZEND_VM_NEXT_OPCODE(); } else { - zval tmp, *varname = opline->op1.zv; + zval tmp, *varname = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp); if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { @@ -5419,20 +5419,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -5485,7 +5485,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); ZVAL_COPY_VALUE(&generator->value, value); if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); @@ -5514,7 +5514,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ } } else { - zval *value = opline->op1.zv; + zval *value = EX_CONSTANT(opline->op1); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -5597,7 +5597,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ HashTable *target_symbol_table; SAVE_OPLINE(); - varname = opline->op1.zv; + varname = EX_CONSTANT(opline->op1); if (IS_CONST == IS_CONST) { name = Z_STR_P(varname); @@ -5612,10 +5612,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (IS_CONST != IS_CONST) { zend_string_release(name); @@ -5624,12 +5624,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -5761,7 +5761,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND if (IS_UNUSED == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC); @@ -5782,17 +5782,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -5800,11 +5800,11 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (IS_CONST == IS_CONST && IS_UNUSED == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_CONST != IS_CONST && IS_UNUSED == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (IS_UNUSED != IS_UNUSED) { @@ -5822,7 +5822,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -5911,7 +5911,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_ Z_ADDREF_P(expr_ptr); } else { - expr_ptr = opline->op1.zv; + expr_ptr = EX_CONSTANT(opline->op1); if (IS_CONST == IS_TMP_VAR) { ZVAL_COPY_VALUE(&new_expr, expr_ptr); expr_ptr = &new_expr; @@ -6043,7 +6043,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H ZEND_VM_NEXT_OPCODE(); } - varname = opline->op1.zv; + varname = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp); if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { @@ -6055,10 +6055,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (IS_CONST != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -6067,14 +6067,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -6110,7 +6110,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_ ZEND_VM_NEXT_OPCODE(); } else { - zval tmp, *varname = opline->op1.zv; + zval tmp, *varname = EX_CONSTANT(opline->op1); ZVAL_UNDEF(&tmp); if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) { @@ -6122,20 +6122,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_ zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -6167,7 +6167,7 @@ static int ZEND_FASTCALL ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER SAVE_OPLINE(); - if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(opline->op1.zv))) == NULL) || + if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(EX_CONSTANT(opline->op1)))) == NULL) || UNEXPECTED(Z_FUNC_P(zfunc)->type != ZEND_USER_FUNCTION)) { zend_error_noreturn(E_ERROR, "Base lambda function for closure not found"); } @@ -6213,7 +6213,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); ZVAL_COPY_VALUE(&generator->value, value); if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); @@ -6242,7 +6242,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL } } else { - zval *value = opline->op1.zv; + zval *value = EX_CONSTANT(opline->op1); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -6322,7 +6322,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_add_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6337,7 +6337,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_sub_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6352,7 +6352,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_mul_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6367,7 +6367,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_div_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6382,7 +6382,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_mod_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6397,7 +6397,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); shift_left_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6412,7 +6412,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); shift_right_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6427,7 +6427,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); concat_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6442,7 +6442,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6458,7 +6458,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD SAVE_OPLINE(); fast_is_not_identical_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6474,7 +6474,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); fast_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6490,7 +6490,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); fast_not_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6506,7 +6506,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); fast_is_smaller_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6522,7 +6522,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP SAVE_OPLINE(); fast_is_smaller_or_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6537,7 +6537,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); bitwise_or_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6552,7 +6552,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); bitwise_and_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6567,7 +6567,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); bitwise_xor_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6582,7 +6582,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); boolean_xor_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -6597,7 +6597,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN zval *container; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); @@ -6612,7 +6612,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA zval *container; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); @@ -6646,7 +6646,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPC if (IS_CV == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC); @@ -6664,7 +6664,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -6706,7 +6706,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -6728,7 +6728,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -6769,7 +6769,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -6802,7 +6802,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER(ZEND_OPC if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -6827,17 +6827,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -6845,11 +6845,11 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (IS_CONST == IS_CONST && IS_CV == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_CONST != IS_CONST && IS_CV == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (IS_CV != IS_UNUSED) { @@ -6867,7 +6867,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -6978,7 +6978,7 @@ static int ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_ } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error); + zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -7005,12 +7005,12 @@ static int ZEND_FASTCALL ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A ZEND_VM_SET_OPCODE(&EX(func)->op_array.opcodes[opline->extended_value]); ZEND_VM_CONTINUE(); /* CHECK_ME */ } - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + catch_ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), catch_ce); } ce = EG(exception)->ce; @@ -7051,7 +7051,7 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR SAVE_OPLINE(); fast_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); CHECK_EXCEPTION(); @@ -7075,7 +7075,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO Z_ADDREF_P(expr_ptr); } else { - expr_ptr = opline->op1.zv; + expr_ptr = EX_CONSTANT(opline->op1); if (IS_CONST == IS_TMP_VAR) { ZVAL_COPY_VALUE(&new_expr, expr_ptr); expr_ptr = &new_expr; @@ -7187,7 +7187,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER(ZEND_ zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); isset_dim_obj_again: @@ -7303,7 +7303,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -7321,7 +7321,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER(ZEND isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -7362,7 +7362,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - value = opline->op1.zv; + value = EX_CONSTANT(opline->op1); ZVAL_COPY_VALUE(&generator->value, value); if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1); @@ -7391,7 +7391,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A } } else { - zval *value = opline->op1.zv; + zval *value = EX_CONSTANT(opline->op1); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -7471,7 +7471,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); pow_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC); @@ -7486,7 +7486,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_add_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7501,7 +7501,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_sub_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7516,7 +7516,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_mul_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7531,7 +7531,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_div_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7546,7 +7546,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_mod_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7561,7 +7561,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); shift_left_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7576,7 +7576,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); shift_right_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7591,7 +7591,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); concat_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7607,7 +7607,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); fast_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7623,7 +7623,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCOD SAVE_OPLINE(); fast_not_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7639,7 +7639,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_ SAVE_OPLINE(); fast_is_smaller_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7655,7 +7655,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMPVAR_HANDLER(ZEN SAVE_OPLINE(); fast_is_smaller_or_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7670,7 +7670,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); bitwise_or_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7685,7 +7685,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); bitwise_and_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7700,7 +7700,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); bitwise_xor_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7715,7 +7715,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); boolean_xor_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7730,7 +7730,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE zval *container; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7745,7 +7745,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCOD zval *container; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7779,7 +7779,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2), (IS_TMP_VAR|IS_VAR) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -7797,7 +7797,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -7839,7 +7839,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -7862,7 +7862,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCOD zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -7903,7 +7903,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -7937,7 +7937,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND if (IS_CONST == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CONST, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_CONST == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -7962,17 +7962,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER if (IS_CONST == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -7980,11 +7980,11 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER if (IS_CONST == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_CONST != IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zend_free_op free_op2; @@ -8002,7 +8002,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -8113,7 +8113,7 @@ static int ZEND_FASTCALL ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPC } } } else { - zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(opline->op1.zv), error); + zend_error(E_WARNING, "%s() expects parameter 1 to be a valid callback, %s", Z_STRVAL_P(EX_CONSTANT(opline->op1)), error); efree(error); func = (zend_function*)&zend_pass_function; called_scope = NULL; @@ -8136,7 +8136,7 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); fast_equal_function(result, - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -8161,7 +8161,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_ Z_ADDREF_P(expr_ptr); } else { - expr_ptr = opline->op1.zv; + expr_ptr = EX_CONSTANT(opline->op1); if (IS_CONST == IS_TMP_VAR) { ZVAL_COPY_VALUE(&new_expr, expr_ptr); expr_ptr = &new_expr; @@ -8273,7 +8273,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(Z zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); isset_dim_obj_again: @@ -8390,7 +8390,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER( zval *offset; SAVE_OPLINE(); - container = opline->op1.zv; + container = EX_CONSTANT(opline->op1); offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2); if (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -8408,7 +8408,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER( isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -8428,7 +8428,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); pow_function(EX_VAR(opline->result.var), - opline->op1.zv, + EX_CONSTANT(opline->op1), _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); @@ -8861,7 +8861,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_FETCH_BYREF) { } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; if (Z_TYPE(p->val) == IS_UNDEF || @@ -8892,7 +8892,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG } if (is_empty) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -8936,7 +8936,7 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); zval_ptr_dtor_nogc(free_op1); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } zval_ptr_dtor_nogc(free_op1); @@ -8971,7 +8971,7 @@ static int ZEND_FASTCALL ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); zval_ptr_dtor_nogc(free_op1); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } zval_ptr_dtor_nogc(free_op1); @@ -9059,7 +9059,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -9075,7 +9075,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO SAVE_OPLINE(); fast_is_not_identical_function(result, _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -9098,7 +9098,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OP if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -9109,7 +9109,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OP zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); } @@ -9127,7 +9127,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -9168,7 +9168,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -9192,7 +9192,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OP zval *property; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = NULL; if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) { @@ -9201,7 +9201,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OP if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -9226,7 +9226,7 @@ static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL ZVAL_EMPTY_STRING(str); } - add_char_to_string(str, str, opline->op2.zv); + add_char_to_string(str, str, EX_CONSTANT(opline->op2)); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ /*CHECK_EXCEPTION();*/ @@ -9245,7 +9245,7 @@ static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAN ZVAL_EMPTY_STRING(str); } - add_string_to_string(str, str, opline->op2.zv); + add_string_to_string(str, str, EX_CONSTANT(opline->op2)); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ /*CHECK_EXCEPTION();*/ @@ -9289,7 +9289,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC if (IS_CONST != IS_UNUSED) { - zval *offset = opline->op2.zv; + zval *offset = EX_CONSTANT(opline->op2); zend_string *str; zend_ulong hval; @@ -9454,7 +9454,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ /* Set the new yielded key */ if (IS_CONST != IS_UNUSED) { - zval *key = opline->op2.zv; + zval *key = EX_CONSTANT(opline->op2); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -10228,7 +10228,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -10261,7 +10261,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCOD if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -10650,7 +10650,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -10684,7 +10684,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_O if (IS_TMP_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_TMP_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_TMP_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -11351,15 +11351,15 @@ static int ZEND_FASTCALL ZEND_NEW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) SAVE_OPLINE(); if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -11382,7 +11382,7 @@ static int ZEND_FASTCALL ZEND_NEW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } else { OBJ_RELEASE(Z_OBJ(object_zval)); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { /* We are not handling overloaded classes right now */ EX(call) = zend_vm_stack_push_call_frame( @@ -11664,7 +11664,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_FETCH_BYREF) { if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; if (Z_TYPE(p->val) == IS_UNDEF || @@ -11695,7 +11695,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; } if (is_empty) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -11730,7 +11730,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG pos = ptr->pos; if (UNEXPECTED(pos == INVALID_IDX)) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else if (UNEXPECTED(ptr->ht != fe_ht)) { ptr->ht = fe_ht; pos = 0; @@ -11753,7 +11753,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG while (1) { if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; value = &p->val; @@ -11811,7 +11811,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG pos = ptr->pos; if (pos == INVALID_IDX) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else if (UNEXPECTED(ptr->ht != fe_ht)) { ptr->ht = fe_ht; pos = 0; @@ -11834,7 +11834,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG while (1) { if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { /* reached end of iteration */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; @@ -11914,7 +11914,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG zval_ptr_dtor(array_ref); HANDLE_EXCEPTION(); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } value = iter->funcs->get_current_data(iter TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { @@ -11923,7 +11923,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG } if (!value) { /* failure in get_current_data */ - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } if (opline->extended_value & ZEND_FE_FETCH_BYREF) { ZVAL_MAKE_REF(value); @@ -11948,7 +11948,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG } } else { zend_error(E_WARNING, "Invalid argument supplied for foreach()"); - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } } @@ -11978,7 +11978,7 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); zval_ptr_dtor_nogc(free_op1); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } zval_ptr_dtor_nogc(free_op1); @@ -12013,7 +12013,7 @@ static int ZEND_FASTCALL ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); zval_ptr_dtor_nogc(free_op1); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } zval_ptr_dtor_nogc(free_op1); @@ -12101,7 +12101,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -12117,7 +12117,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO SAVE_OPLINE(); fast_is_not_identical_function(result, _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -12129,7 +12129,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b USE_OPLINE zend_free_op free_op1, free_op_data1; zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - zval *property = opline->op2.zv; + zval *property = EX_CONSTANT(opline->op2); zval *value; zval *zptr; @@ -12152,7 +12152,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -12166,7 +12166,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -12179,7 +12179,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -12213,7 +12213,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(int (*b zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); do { if (IS_VAR == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { @@ -12269,7 +12269,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binar zval *value; SAVE_OPLINE(); - value = opline->op2.zv; + value = EX_CONSTANT(opline->op2); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) { @@ -12527,7 +12527,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); retval = EX_VAR(opline->result.var); if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { @@ -12548,7 +12548,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -12561,7 +12561,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -12578,7 +12578,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -12615,7 +12615,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_ SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); retval = EX_VAR(opline->result.var); if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { @@ -12634,7 +12634,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_ /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -12644,7 +12644,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_ } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -12660,7 +12660,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_ ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -12697,7 +12697,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12719,7 +12719,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12745,7 +12745,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -12756,7 +12756,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); } @@ -12776,7 +12776,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCOD if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12796,7 +12796,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -12837,7 +12837,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -12858,14 +12858,14 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA zval *container; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12883,13 +12883,13 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H zval *container; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12910,7 +12910,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP zval *property; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) { @@ -12919,7 +12919,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12940,12 +12940,12 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -12964,12 +12964,12 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); - property_name = opline->op2.zv; + property_name = EX_CONSTANT(opline->op2); if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_VAR, property_name, IS_CONST, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_VAR, property_name, IS_CONST, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; /* assign_obj has two opcodes! */ @@ -12999,7 +12999,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN try_assign_dim: if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); zend_fetch_dimension_address_W(&rv, object_ptr, dim, IS_CONST TSRMLS_CC); value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); @@ -13021,7 +13021,7 @@ try_assign_dim_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zval *property_name = opline->op2.zv; + zval *property_name = EX_CONSTANT(opline->op2); zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, (opline+1)->op1_type, (opline+1)->op1, execute_data TSRMLS_CC); @@ -13029,7 +13029,7 @@ try_assign_dim_array: EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { zend_long offset; - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC); value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); @@ -13056,7 +13056,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER zval *variable_ptr; SAVE_OPLINE(); - value = opline->op2.zv; + value = EX_CONSTANT(opline->op2); variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1); if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { @@ -13092,17 +13092,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -13110,16 +13110,16 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (IS_VAR == IS_CONST && IS_CONST == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_VAR != IS_CONST && IS_CONST == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (IS_CONST != IS_UNUSED) { - function_name = opline->op2.zv; + function_name = EX_CONSTANT(opline->op2); if (IS_CONST != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { if (UNEXPECTED(EG(exception) != NULL)) { @@ -13132,7 +13132,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -13213,17 +13213,17 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE zend_constant *c; zval *retval; - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); - } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); + } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(EX_CONSTANT(opline->op2)), '\\', Z_STRLEN_P(EX_CONSTANT(opline->op2))); if (!actual) { - ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(opline->op2.zv))); + ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(EX_CONSTANT(opline->op2)))); } else { actual++; ZVAL_STRINGL(EX_VAR(opline->result.var), - actual, Z_STRLEN_P(opline->op2.zv) - (actual - Z_STRVAL_P(opline->op2.zv))); + actual, Z_STRLEN_P(EX_CONSTANT(opline->op2)) - (actual - Z_STRVAL_P(EX_CONSTANT(opline->op2)))); } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", @@ -13231,10 +13231,10 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { - zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } else { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), c); } retval = EX_VAR(opline->result.var); ZVAL_COPY_VALUE(retval, &c->value); @@ -13251,33 +13251,33 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE zval *value; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; - } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); - if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce)) != NULL) { ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; } } - if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { ZVAL_DEREF(value); if (Z_CONSTANT_P(value)) { EG(scope) = ce; @@ -13285,16 +13285,16 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE EG(scope) = EX(func)->op_array.scope; } if (IS_VAR == IS_CONST) { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), value); } else { - CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRLEN_P(EX_CONSTANT(opline->op2)) == sizeof("class")-1 && memcmp(Z_STRVAL_P(EX_CONSTANT(opline->op2)), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); } else { - zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } constant_fetch_end: @@ -13339,7 +13339,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC if (IS_CONST != IS_UNUSED) { - zval *offset = opline->op2.zv; + zval *offset = EX_CONSTANT(opline->op2); zend_string *str; zend_ulong hval; @@ -13434,7 +13434,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); } - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); unset_dim_again: if (IS_VAR != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -13521,7 +13521,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); } - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -13535,7 +13535,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -13630,7 +13630,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ /* Set the new yielded key */ if (IS_CONST != IS_UNUSED) { - zval *key = opline->op2.zv; + zval *key = EX_CONSTANT(opline->op2); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -14581,17 +14581,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -14599,11 +14599,11 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (IS_VAR == IS_CONST && IS_UNUSED == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_VAR != IS_CONST && IS_UNUSED == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (IS_UNUSED != IS_UNUSED) { @@ -14621,7 +14621,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -15021,7 +15021,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -15035,7 +15035,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -15048,7 +15048,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -15417,7 +15417,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t in /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -15430,7 +15430,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t in zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -15447,7 +15447,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t in if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -15503,7 +15503,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -15513,7 +15513,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -15529,7 +15529,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -15706,7 +15706,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -15734,7 +15734,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -15758,7 +15758,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -15788,7 +15788,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -15814,7 +15814,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_H if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -15838,7 +15838,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_VAR, property_name, IS_CV, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_VAR, property_name, IS_CV, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; /* assign_obj has two opcodes! */ @@ -16025,17 +16025,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -16043,11 +16043,11 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (IS_VAR == IS_CONST && IS_CV == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_VAR != IS_CONST && IS_CV == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if (IS_CV != IS_UNUSED) { @@ -16065,7 +16065,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_ if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -16370,7 +16370,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -16546,7 +16546,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(int (* /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -16560,7 +16560,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(int (* zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -16573,7 +16573,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMPVAR(int (* ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -16944,7 +16944,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_ /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -16957,7 +16957,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_ zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -16974,7 +16974,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMPVAR(incdec_ if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -17031,7 +17031,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMPVAR(incdec /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -17041,7 +17041,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMPVAR(incdec } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -17057,7 +17057,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMPVAR(incdec ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -17235,7 +17235,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -17264,7 +17264,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_H zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -17288,7 +17288,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_ if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -17318,7 +17318,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_O if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -17344,7 +17344,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCO if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_VAR == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -17368,7 +17368,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HA if (IS_VAR == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_VAR, property_name, (IS_TMP_VAR|IS_VAR), (opline+1)->op1_type, (opline+1)->op1, execute_data, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_VAR, property_name, (IS_TMP_VAR|IS_VAR), (opline+1)->op1_type, (opline+1)->op1, execute_data, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (free_op1) {zval_ptr_dtor_nogc(free_op1);}; /* assign_obj has two opcodes! */ @@ -17459,17 +17459,17 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(Z if (IS_VAR == IS_CONST) { /* no function found. try a static method in class */ - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, ZEND_FETCH_CLASS_DEFAULT TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); @@ -17477,11 +17477,11 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(Z if (IS_VAR == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST && - CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + fbc = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else if (IS_VAR != IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST && - (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) { + (fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce))) { /* do nothing */ } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zend_free_op free_op2; @@ -17499,7 +17499,7 @@ static int ZEND_FASTCALL ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(Z if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); } if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name)); @@ -17804,7 +17804,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HAN } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -17923,7 +17923,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int USE_OPLINE zend_free_op free_op_data1; zval *object = _get_obj_zval_ptr_unused(execute_data); - zval *property = opline->op2.zv; + zval *property = EX_CONSTANT(opline->op2); zval *value; zval *zptr; @@ -17946,7 +17946,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -17960,7 +17960,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -17973,7 +17973,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -18006,7 +18006,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(int zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); do { if (IS_UNUSED == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { @@ -18285,7 +18285,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde SAVE_OPLINE(); object = _get_obj_zval_ptr_unused(execute_data); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); retval = EX_VAR(opline->result.var); if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { @@ -18306,7 +18306,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -18319,7 +18319,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -18336,7 +18336,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -18373,7 +18373,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd SAVE_OPLINE(); object = _get_obj_zval_ptr_unused(execute_data); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); retval = EX_VAR(opline->result.var); if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { @@ -18392,7 +18392,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -18402,7 +18402,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -18418,7 +18418,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -18453,7 +18453,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(execute_data); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -18494,7 +18494,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -18515,14 +18515,14 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE zval *container; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_obj_zval_ptr_unused(execute_data); if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -18540,13 +18540,13 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD zval *container; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_obj_zval_ptr_unused(execute_data); if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -18566,7 +18566,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(execute_data); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -18606,7 +18606,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -18630,7 +18630,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND zval *property; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_obj_zval_ptr_unused(execute_data); if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) { @@ -18639,7 +18639,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -18660,12 +18660,12 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OP SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(execute_data); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -18684,12 +18684,12 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_ SAVE_OPLINE(); object = _get_obj_zval_ptr_unused(execute_data); - property_name = opline->op2.zv; + property_name = EX_CONSTANT(opline->op2); if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_UNUSED, property_name, IS_CONST, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_UNUSED, property_name, IS_CONST, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); /* assign_obj has two opcodes! */ @@ -18710,7 +18710,7 @@ static int ZEND_FASTCALL ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HA ZVAL_EMPTY_STRING(str); } - add_char_to_string(str, str, opline->op2.zv); + add_char_to_string(str, str, EX_CONSTANT(opline->op2)); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ /*CHECK_EXCEPTION();*/ @@ -18729,7 +18729,7 @@ static int ZEND_FASTCALL ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_ ZVAL_EMPTY_STRING(str); } - add_string_to_string(str, str, opline->op2.zv); + add_string_to_string(str, str, EX_CONSTANT(opline->op2)); /* FREE_OP is missing intentionally here - we're always working on the same temporary variable */ /*CHECK_EXCEPTION();*/ @@ -18748,7 +18748,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O SAVE_OPLINE(); - function_name = opline->op2.zv; + function_name = EX_CONSTANT(opline->op2); if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { @@ -18825,7 +18825,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -18860,17 +18860,17 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC zend_constant *c; zval *retval; - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); - } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) { + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + c = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); + } else if ((c = zend_quick_get_constant(EX_CONSTANT(opline->op2) + 1, opline->extended_value TSRMLS_CC)) == NULL) { if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) { - char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv)); + char *actual = (char *)zend_memrchr(Z_STRVAL_P(EX_CONSTANT(opline->op2)), '\\', Z_STRLEN_P(EX_CONSTANT(opline->op2))); if (!actual) { - ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(opline->op2.zv))); + ZVAL_STR(EX_VAR(opline->result.var), zend_string_copy(Z_STR_P(EX_CONSTANT(opline->op2)))); } else { actual++; ZVAL_STRINGL(EX_VAR(opline->result.var), - actual, Z_STRLEN_P(opline->op2.zv) - (actual - Z_STRVAL_P(opline->op2.zv))); + actual, Z_STRLEN_P(EX_CONSTANT(opline->op2)) - (actual - Z_STRVAL_P(EX_CONSTANT(opline->op2)))); } /* non-qualified constant - allow text substitution */ zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", @@ -18878,10 +18878,10 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } else { - zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } else { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), c); } retval = EX_VAR(opline->result.var); ZVAL_COPY_VALUE(retval, &c->value); @@ -18898,33 +18898,33 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC zval *value; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + value = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; - } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv)); + } else if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op1)), EX_CONSTANT(opline->op1) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op1))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op1)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op1.var)); - if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) { + if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce)) != NULL) { ZVAL_DEREF(value); ZVAL_DUP(EX_VAR(opline->result.var), value); goto constant_fetch_end; } } - if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) { + if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(EX_CONSTANT(opline->op2)))) != NULL)) { ZVAL_DEREF(value); if (Z_CONSTANT_P(value)) { EG(scope) = ce; @@ -18932,16 +18932,16 @@ static int ZEND_FASTCALL ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC EG(scope) = EX(func)->op_array.scope; } if (IS_UNUSED == IS_CONST) { - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), value); } else { - CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value); + CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce, value); } ZVAL_DUP(EX_VAR(opline->result.var), value); - } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) { + } else if (Z_STRLEN_P(EX_CONSTANT(opline->op2)) == sizeof("class")-1 && memcmp(Z_STRVAL_P(EX_CONSTANT(opline->op2)), "class", sizeof("class") - 1) == 0) { /* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */ ZVAL_STR_COPY(EX_VAR(opline->result.var), ce->name); } else { - zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } } constant_fetch_end: @@ -18993,7 +18993,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); } - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); unset_dim_again: if (IS_UNUSED != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -19080,7 +19080,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); } - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -19094,7 +19094,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -19116,7 +19116,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(Z SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(execute_data); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); isset_dim_obj_again: if (IS_UNUSED != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -19232,7 +19232,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER( SAVE_OPLINE(); container = _get_obj_zval_ptr_unused(execute_data); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -19249,7 +19249,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER( isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -19344,7 +19344,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL /* Set the new yielded key */ if (IS_CONST != IS_UNUSED) { - zval *key = opline->op2.zv; + zval *key = EX_CONSTANT(opline->op2); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -20125,7 +20125,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -20139,7 +20139,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -20152,7 +20152,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -20485,7 +20485,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -20498,7 +20498,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -20515,7 +20515,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -20571,7 +20571,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_ /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -20581,7 +20581,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_ } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -20597,7 +20597,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_ ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -20673,7 +20673,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -20701,7 +20701,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -20725,7 +20725,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -20785,7 +20785,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -20818,7 +20818,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OP if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -20844,7 +20844,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCOD if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -20868,7 +20868,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_UNUSED, property_name, IS_CV, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_UNUSED, property_name, IS_CV, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); /* assign_obj has two opcodes! */ @@ -21006,7 +21006,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -21177,7 +21177,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -21332,7 +21332,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEN isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -21503,7 +21503,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(int /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -21517,7 +21517,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(int zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -21530,7 +21530,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMPVAR(int ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -21864,7 +21864,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(incd /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -21877,7 +21877,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(incd zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -21894,7 +21894,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMPVAR(incd if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -21951,7 +21951,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMPVAR(inc /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -21961,7 +21961,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMPVAR(inc } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -21977,7 +21977,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMPVAR(inc ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -22054,7 +22054,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -22083,7 +22083,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCOD zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -22107,7 +22107,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCO if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -22167,7 +22167,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -22201,7 +22201,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEN if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -22227,7 +22227,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_O if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_UNUSED == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -22251,7 +22251,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE if (IS_UNUSED == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_UNUSED, property_name, (IS_TMP_VAR|IS_VAR), (opline+1)->op1_type, (opline+1)->op1, execute_data, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_UNUSED, property_name, (IS_TMP_VAR|IS_VAR), (opline+1)->op1_type, (opline+1)->op1, execute_data, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); /* assign_obj has two opcodes! */ @@ -22390,7 +22390,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_ } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -22562,7 +22562,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_ } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -22719,7 +22719,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -22969,9 +22969,9 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (IS_CV == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -22979,7 +22979,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (i_zend_is_true(val TSRMLS_CC)) { opline++; } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { @@ -22998,7 +22998,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); if (Z_TYPE_P(val) == IS_TRUE) { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (IS_CV == IS_CV) { @@ -23010,7 +23010,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } if (i_zend_is_true(val TSRMLS_CC)) { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { opline++; } @@ -23035,17 +23035,17 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if (IS_CV == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } if (i_zend_is_true(val TSRMLS_CC)) { - opline = (zend_op*)(((char*)opline) + opline->extended_value); + opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { @@ -23070,9 +23070,9 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); if (IS_CV == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -23084,7 +23084,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) } else { ZVAL_FALSE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -23103,7 +23103,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); @@ -23116,7 +23116,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS } if (i_zend_is_true(val TSRMLS_CC)) { ZVAL_TRUE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { ZVAL_FALSE(EX_VAR(opline->result.var)); opline++; @@ -23919,7 +23919,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_FETCH_BYREF) { } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } p = fe_ht->arData + pos; if (Z_TYPE(p->val) == IS_UNDEF || @@ -23950,7 +23950,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS } if (is_empty) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -24014,7 +24014,7 @@ static int ZEND_FASTCALL ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } CHECK_EXCEPTION(); @@ -24048,7 +24048,7 @@ static int ZEND_FASTCALL ZEND_COALESCE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); } - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } CHECK_EXCEPTION(); @@ -24179,7 +24179,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24194,7 +24194,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24209,7 +24209,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24224,7 +24224,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24239,7 +24239,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); fast_mod_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24254,7 +24254,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); shift_left_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24269,7 +24269,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS SAVE_OPLINE(); shift_right_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24284,7 +24284,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); concat_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24299,7 +24299,7 @@ static int ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); fast_is_identical_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24315,7 +24315,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); fast_is_not_identical_function(result, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24331,7 +24331,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); fast_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24347,7 +24347,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); fast_not_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24363,7 +24363,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); fast_is_smaller_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24379,7 +24379,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP SAVE_OPLINE(); fast_is_smaller_or_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24394,7 +24394,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A SAVE_OPLINE(); bitwise_or_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24409,7 +24409,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); bitwise_and_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24424,7 +24424,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); bitwise_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24439,7 +24439,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); boolean_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -24451,7 +24451,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi USE_OPLINE zend_free_op free_op_data1; zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - zval *property = opline->op2.zv; + zval *property = EX_CONSTANT(opline->op2); zval *value; zval *zptr; @@ -24474,7 +24474,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -24488,7 +24488,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -24501,7 +24501,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -24534,7 +24534,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CONST(int (*bi zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); do { if (IS_CV == IS_UNUSED || UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) { @@ -24590,7 +24590,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary zval *value; SAVE_OPLINE(); - value = opline->op2.zv; + value = EX_CONSTANT(opline->op2); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) { @@ -24848,7 +24848,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t SAVE_OPLINE(); object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); retval = EX_VAR(opline->result.var); if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { @@ -24869,7 +24869,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -24882,7 +24882,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -24899,7 +24899,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -24936,7 +24936,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t SAVE_OPLINE(); object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); retval = EX_VAR(opline->result.var); if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { @@ -24955,7 +24955,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -24965,7 +24965,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -24981,7 +24981,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -25031,10 +25031,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (IS_CV != IS_CONST) { zend_string_release(name); @@ -25043,12 +25043,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -25162,7 +25162,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); CHECK_EXCEPTION(); @@ -25181,7 +25181,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25203,7 +25203,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25221,7 +25221,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); CHECK_EXCEPTION(); @@ -25244,7 +25244,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); } @@ -25255,7 +25255,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC zend_error_noreturn(E_ERROR, "Cannot use [] for reading"); } container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); } @@ -25275,7 +25275,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25295,7 +25295,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -25336,7 +25336,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -25357,14 +25357,14 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN zval *container; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25382,13 +25382,13 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA zval *container; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25408,7 +25408,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -25448,7 +25448,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -25472,7 +25472,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC zval *property; SAVE_OPLINE(); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); container = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) { @@ -25481,7 +25481,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25502,12 +25502,12 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC); - property = opline->op2.zv; + property = EX_CONSTANT(opline->op2); if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CONST, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -25529,13 +25529,13 @@ static int ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND try_fetch_list: if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), EX_CONSTANT(opline->op2), IS_CONST, BP_VAR_R TSRMLS_CC); ZVAL_COPY(EX_VAR(opline->result.var), value); } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, opline->op2.zv, BP_VAR_R, result TSRMLS_CC); + zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, EX_CONSTANT(opline->op2), BP_VAR_R, result TSRMLS_CC); if (retval) { if (result != retval) { @@ -25563,12 +25563,12 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); object = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); - property_name = opline->op2.zv; + property_name = EX_CONSTANT(opline->op2); if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_CV, property_name, IS_CONST, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_CV, property_name, IS_CONST, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); /* assign_obj has two opcodes! */ @@ -25598,7 +25598,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND try_assign_dim: if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); zend_fetch_dimension_address_W(&rv, object_ptr, dim, IS_CONST TSRMLS_CC); value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); @@ -25620,7 +25620,7 @@ try_assign_dim_array: } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zval *property_name = opline->op2.zv; + zval *property_name = EX_CONSTANT(opline->op2); zend_assign_to_object_dim(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object_ptr, property_name, (opline+1)->op1_type, (opline+1)->op1, execute_data TSRMLS_CC); @@ -25628,7 +25628,7 @@ try_assign_dim_array: EXPECTED(Z_STRLEN_P(object_ptr) != 0)) { zend_long offset; - dim = opline->op2.zv; + dim = EX_CONSTANT(opline->op2); offset = zend_fetch_string_offset(object_ptr, dim, BP_VAR_W TSRMLS_CC); value = get_zval_ptr_deref((opline+1)->op1_type, (opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R); @@ -25655,7 +25655,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ zval *variable_ptr; SAVE_OPLINE(); - value = opline->op2.zv; + value = EX_CONSTANT(opline->op2); variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC); if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) { @@ -25691,7 +25691,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); - function_name = opline->op2.zv; + function_name = EX_CONSTANT(opline->op2); if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { @@ -25768,7 +25768,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -25803,7 +25803,7 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR SAVE_OPLINE(); fast_equal_function(result, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -25846,7 +25846,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO if (IS_CONST != IS_UNUSED) { - zval *offset = opline->op2.zv; + zval *offset = EX_CONSTANT(opline->op2); zend_string *str; zend_ulong hval; @@ -25970,10 +25970,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -25982,14 +25982,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -26016,7 +26016,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); } - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); unset_dim_again: if (IS_CV != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -26103,7 +26103,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot unset string offsets"); } - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -26117,7 +26117,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -26162,20 +26162,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -26210,7 +26210,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); isset_dim_obj_again: if (IS_CV != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -26326,7 +26326,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -26343,7 +26343,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -26370,17 +26370,17 @@ try_instanceof: zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { ZVAL_FALSE(EX_VAR(opline->result.var)); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); @@ -26481,7 +26481,7 @@ static int ZEND_FASTCALL ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A /* Set the new yielded key */ if (IS_CONST != IS_UNUSED) { - zval *key = opline->op2.zv; + zval *key = EX_CONSTANT(opline->op2); /* Consts, temporary variables and references need copying */ if (IS_CONST == IS_CONST) { @@ -26537,7 +26537,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG SAVE_OPLINE(); pow_function(EX_VAR(opline->result.var), _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); @@ -26559,7 +26559,7 @@ static int ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN uint32_t idx; SAVE_OPLINE(); - varname = opline->op2.zv; + varname = EX_CONSTANT(opline->op2); /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */ idx = (uint32_t)(uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1; @@ -26855,10 +26855,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (IS_CV != IS_CONST) { zend_string_release(name); @@ -26867,12 +26867,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -27117,10 +27117,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -27129,14 +27129,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -27184,20 +27184,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -27236,17 +27236,17 @@ try_instanceof: zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { ZVAL_FALSE(EX_VAR(opline->result.var)); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); @@ -27701,10 +27701,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if (IS_CV != IS_CONST) { zend_string_release(name); @@ -27713,12 +27713,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -28134,10 +28134,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if (IS_CV != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -28146,14 +28146,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -28201,20 +28201,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -28672,7 +28672,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -28686,7 +28686,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -28699,7 +28699,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -29067,7 +29067,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -29080,7 +29080,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -29097,7 +29097,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -29153,7 +29153,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -29163,7 +29163,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -29179,7 +29179,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -29386,7 +29386,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -29414,7 +29414,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -29438,7 +29438,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -29498,7 +29498,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -29531,7 +29531,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -29557,7 +29557,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, IS_CV, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -29581,7 +29581,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_CV, property_name, IS_CV, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_CV, property_name, IS_CV, (opline+1)->op1_type, (opline+1)->op1, execute_data, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); /* assign_obj has two opcodes! */ @@ -29844,7 +29844,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -30118,7 +30118,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -30273,7 +30273,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OP isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -30708,7 +30708,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(int (*b /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -30722,7 +30722,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(int (*b zval rv; if (Z_OBJ_HT_P(object)->read_property && - (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { + (z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC)) != NULL) { if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) { zval rv; zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC); @@ -30735,7 +30735,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMPVAR(int (*b ZVAL_DEREF(z); SEPARATE_ZVAL_NOREF(z); binary_op(z, z, value TSRMLS_CC); - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), z); } @@ -31105,7 +31105,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(incdec_t /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); SEPARATE_ZVAL_NOREF(zptr); @@ -31118,7 +31118,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(incdec_t zval rv; if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { zval rv; @@ -31135,7 +31135,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMPVAR(incdec_t if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(retval, z); } - Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, z, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(z); } else { zend_error(E_WARNING, "Attempt to increment/decrement property of non-object"); @@ -31192,7 +31192,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMPVAR(incdec_ /* here we are sure we are dealing with an object */ if (EXPECTED(Z_OBJ_HT_P(object)->get_property_ptr_ptr) - && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { + && EXPECTED((zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC)) != NULL)) { ZVAL_DEREF(zptr); ZVAL_COPY_VALUE(retval, zptr); @@ -31202,7 +31202,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMPVAR(incdec_ } else { if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) { zval rv; - zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); + zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), &rv TSRMLS_CC); zval z_copy; if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) { @@ -31218,7 +31218,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMPVAR(incdec_ ZVAL_DUP(&z_copy, z); incdec_op(&z_copy); if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z); - Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL) TSRMLS_CC); zval_ptr_dtor(&z_copy); zval_ptr_dtor(z); } else { @@ -31426,7 +31426,7 @@ fetch_obj_r_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -31455,7 +31455,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HA zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -31479,7 +31479,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_H if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_RW TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -31539,7 +31539,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -31573,7 +31573,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OP if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_W TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -31599,7 +31599,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCOD if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an object"); } - zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); + zend_fetch_property_address(EX_VAR(opline->result.var), container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property)) : NULL), BP_VAR_UNSET TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); if (IS_CV == IS_VAR && READY_TO_DESTROY(free_op1)) { EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var)); @@ -31623,7 +31623,7 @@ static int ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HAN if (IS_CV == IS_VAR && UNEXPECTED(object == NULL)) { zend_error_noreturn(E_ERROR, "Cannot use string offset as an array"); } - zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_CV, property_name, (IS_TMP_VAR|IS_VAR), (opline+1)->op1_type, (opline+1)->op1, execute_data, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); + zend_assign_to_object(UNEXPECTED(RETURN_VALUE_USED(opline)) ? EX_VAR(opline->result.var) : NULL, object, IS_CV, property_name, (IS_TMP_VAR|IS_VAR), (opline+1)->op1_type, (opline+1)->op1, execute_data, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(property_name)) : NULL) TSRMLS_CC); zval_ptr_dtor_nogc(free_op2); /* assign_obj has two opcodes! */ @@ -31791,7 +31791,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCO } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -32067,7 +32067,7 @@ static int ZEND_FASTCALL ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HAND } } if (Z_OBJ_HT_P(container)->unset_property) { - Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + Z_OBJ_HT_P(container)->unset_property(container, offset, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); } else { zend_error(E_NOTICE, "Trying to unset property of non-object"); } @@ -32224,7 +32224,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEN isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -32341,9 +32341,9 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if ((IS_TMP_VAR|IS_VAR) == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -32351,7 +32351,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS if (i_zend_is_true(val TSRMLS_CC)) { opline++; } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } zval_ptr_dtor_nogc(free_op1); if (UNEXPECTED(EG(exception) != NULL)) { @@ -32370,7 +32370,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARG val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); if (Z_TYPE_P(val) == IS_TRUE) { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if ((IS_TMP_VAR|IS_VAR) == IS_CV) { @@ -32382,7 +32382,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARG } if (i_zend_is_true(val TSRMLS_CC)) { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { opline++; } @@ -32407,17 +32407,17 @@ static int ZEND_FASTCALL ZEND_JMPZNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_AR ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { if ((IS_TMP_VAR|IS_VAR) == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } if (i_zend_is_true(val TSRMLS_CC)) { - opline = (zend_op*)(((char*)opline) + opline->extended_value); + opline = ZEND_OFFSET_TO_OPLINE(opline, opline->extended_value); } else { - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } zval_ptr_dtor_nogc(free_op1); if (UNEXPECTED(EG(exception) != NULL)) { @@ -32442,9 +32442,9 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_A } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); if ((IS_TMP_VAR|IS_VAR) == IS_CV) { - ZEND_VM_JMP(opline->op2.jmp_addr); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } else { - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } } @@ -32456,7 +32456,7 @@ static int ZEND_FASTCALL ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_A } else { zval_ptr_dtor_nogc(free_op1); ZVAL_FALSE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -32475,7 +32475,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ if (Z_TYPE_P(val) == IS_TRUE) { ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_SET_OPCODE(opline->op2.jmp_addr); + ZEND_VM_SET_OPCODE(OP_JMP_ADDR(opline, opline->op2)); ZEND_VM_CONTINUE(); } else if (EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) { ZVAL_FALSE(EX_VAR(opline->result.var)); @@ -32488,7 +32488,7 @@ static int ZEND_FASTCALL ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ } if (i_zend_is_true(val TSRMLS_CC)) { ZVAL_TRUE(EX_VAR(opline->result.var)); - opline = opline->op2.jmp_addr; + opline = OP_JMP_ADDR(opline, opline->op2); } else { ZVAL_FALSE(EX_VAR(opline->result.var)); opline++; @@ -32805,7 +32805,7 @@ static int ZEND_FASTCALL ZEND_ADD_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_add_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32820,7 +32820,7 @@ static int ZEND_FASTCALL ZEND_SUB_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_sub_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32835,7 +32835,7 @@ static int ZEND_FASTCALL ZEND_MUL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_mul_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32850,7 +32850,7 @@ static int ZEND_FASTCALL ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_div_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32865,7 +32865,7 @@ static int ZEND_FASTCALL ZEND_MOD_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); fast_mod_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32880,7 +32880,7 @@ static int ZEND_FASTCALL ZEND_SL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); shift_left_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32895,7 +32895,7 @@ static int ZEND_FASTCALL ZEND_SR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ SAVE_OPLINE(); shift_right_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32910,7 +32910,7 @@ static int ZEND_FASTCALL ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); concat_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32926,7 +32926,7 @@ static int ZEND_FASTCALL ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); fast_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32942,7 +32942,7 @@ static int ZEND_FASTCALL ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); fast_not_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32958,7 +32958,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_ SAVE_OPLINE(); fast_is_smaller_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32974,7 +32974,7 @@ static int ZEND_FASTCALL ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEN SAVE_OPLINE(); fast_is_smaller_or_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -32989,7 +32989,7 @@ static int ZEND_FASTCALL ZEND_BW_OR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDL SAVE_OPLINE(); bitwise_or_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33004,7 +33004,7 @@ static int ZEND_FASTCALL ZEND_BW_AND_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); bitwise_and_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33019,7 +33019,7 @@ static int ZEND_FASTCALL ZEND_BW_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HAND SAVE_OPLINE(); bitwise_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33034,7 +33034,7 @@ static int ZEND_FASTCALL ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HA SAVE_OPLINE(); boolean_xor_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33066,10 +33066,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_CONST(int typ zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release(name); @@ -33078,12 +33078,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_CONST(int typ CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -33197,7 +33197,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33212,7 +33212,7 @@ static int ZEND_FASTCALL ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC); + zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, EX_CONSTANT(opline->op2), IS_CONST TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33229,7 +33229,7 @@ static int ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCOD SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -33269,7 +33269,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -33294,13 +33294,13 @@ static int ZEND_FASTCALL ZEND_FETCH_LIST_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_ try_fetch_list: if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC); + zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), EX_CONSTANT(opline->op2), IS_CONST, BP_VAR_R TSRMLS_CC); ZVAL_COPY(EX_VAR(opline->result.var), value); } else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT) && EXPECTED(Z_OBJ_HT_P(container)->read_dimension)) { zval *result = EX_VAR(opline->result.var); - zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, opline->op2.zv, BP_VAR_R, result TSRMLS_CC); + zval *retval = Z_OBJ_HT_P(container)->read_dimension(container, EX_CONSTANT(opline->op2), BP_VAR_R, result TSRMLS_CC); if (retval) { if (result != retval) { @@ -33331,7 +33331,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_O SAVE_OPLINE(); - function_name = opline->op2.zv; + function_name = EX_CONSTANT(opline->op2); if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { @@ -33409,7 +33409,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_O } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -33445,7 +33445,7 @@ static int ZEND_FASTCALL ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLE SAVE_OPLINE(); fast_equal_function(result, _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); @@ -33493,10 +33493,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_H zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -33505,14 +33505,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_H HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -33560,20 +33560,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_CONST_HANDLER(ZEND_ zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -33609,7 +33609,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(Z SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); isset_dim_obj_again: if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -33725,7 +33725,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER( SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1); - offset = opline->op2.zv; + offset = EX_CONSTANT(opline->op2); if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { @@ -33742,7 +33742,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER( isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -33769,17 +33769,17 @@ try_instanceof: zend_class_entry *ce; if (IS_CONST == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { ZVAL_FALSE(EX_VAR(opline->result.var)); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); @@ -33805,7 +33805,7 @@ static int ZEND_FASTCALL ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER SAVE_OPLINE(); pow_function(EX_VAR(opline->result.var), _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1), - opline->op2.zv TSRMLS_CC); + EX_CONSTANT(opline->op2) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); @@ -33837,10 +33837,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_VAR(int type, zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release(name); @@ -33849,12 +33849,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_VAR(int type, CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -34002,10 +34002,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HAN zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -34014,14 +34014,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HAN HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -34069,20 +34069,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_VAR_HANDLER(ZEND_OP zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -34122,17 +34122,17 @@ try_instanceof: zend_class_entry *ce; if (IS_VAR == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { ZVAL_FALSE(EX_VAR(opline->result.var)); zval_ptr_dtor_nogc(free_op1); CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); @@ -34175,10 +34175,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int ty zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release(name); @@ -34187,12 +34187,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(int ty CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - retval = zend_std_get_static_property(ce, name, 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + retval = zend_std_get_static_property(ce, name, 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); zval_ptr_dtor_nogc(free_op1); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); @@ -34340,10 +34340,10 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_ zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(EG(exception) != NULL)) { if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE(tmp) != IS_UNDEF) { zend_string_release(Z_STR(tmp)); @@ -34352,14 +34352,14 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_ HANDLE_EXCEPTION(); } if (UNEXPECTED(ce == NULL)) { - zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv)); + zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(EX_CONSTANT(opline->op2))); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - zend_std_unset_static_property(ce, Z_STR_P(varname), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + zend_std_unset_static_property(ce, Z_STR_P(varname), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); zend_hash_del_ind(target_symbol_table, Z_STR_P(varname)); @@ -34407,20 +34407,20 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND zend_class_entry *ce; if (IS_UNUSED == IS_CONST) { - if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) { - ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv)); + if (CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)))) { + ce = CACHED_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2))); } else { - ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC); + ce = zend_fetch_class_by_name(Z_STR_P(EX_CONSTANT(opline->op2)), EX_CONSTANT(opline->op2) + 1, 0 TSRMLS_CC); if (UNEXPECTED(ce == NULL)) { CHECK_EXCEPTION(); ZEND_VM_NEXT_OPCODE(); } - CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce); + CACHE_PTR(Z_CACHE_SLOT_P(EX_CONSTANT(opline->op2)), ce); } } else { ce = Z_CE_P(EX_VAR(opline->op2.var)); } - value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); + value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(varname)) : NULL) TSRMLS_CC); } else { HashTable *target_symbol_table = zend_get_target_symbol_table(execute_data, opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC); value = zend_hash_find_ind(target_symbol_table, Z_STR_P(varname)); @@ -34769,7 +34769,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -34872,7 +34872,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCO } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -35058,7 +35058,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEN isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } @@ -35409,7 +35409,7 @@ fetch_obj_is_no_object: } } - retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); + retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL), EX_VAR(opline->result.var) TSRMLS_CC); if (retval != EX_VAR(opline->result.var)) { ZVAL_COPY(EX_VAR(opline->result.var), retval); @@ -35513,7 +35513,7 @@ static int ZEND_FASTCALL ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_ } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_CONSTANT(opline->op2) + 1) : NULL) TSRMLS_CC); if (UNEXPECTED(fbc == NULL)) { zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", obj->ce->name->val, Z_STRVAL_P(function_name)); } @@ -35702,7 +35702,7 @@ static int ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER isset_no_object: result = ((opline->extended_value & ZEND_ISSET) == 0); } else { - result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX(run_time_cache) + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); + result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (EX_RUN_TIME_CACHE() + Z_CACHE_SLOT_P(offset)) : NULL) TSRMLS_CC); if ((opline->extended_value & ZEND_ISSET) == 0) { result = !result; } diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php index f72531d44d..331286b3d8 100644 --- a/Zend/zend_vm_gen.php +++ b/Zend/zend_vm_gen.php @@ -137,7 +137,7 @@ $op1_get_zval_ptr = array( "ANY" => "get_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)", "VAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)", - "CONST" => "opline->op1.zv", + "CONST" => "EX_CONSTANT(opline->op1)", "UNUSED" => "NULL", "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)", "TMPVAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)", @@ -147,7 +147,7 @@ $op2_get_zval_ptr = array( "ANY" => "get_zval_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)", "VAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)", - "CONST" => "opline->op2.zv", + "CONST" => "EX_CONSTANT(opline->op2)", "UNUSED" => "NULL", "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)", "TMPVAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)", @@ -177,7 +177,7 @@ $op1_get_zval_ptr_deref = array( "ANY" => "get_zval_ptr_deref(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)", "VAR" => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1)", - "CONST" => "opline->op1.zv", + "CONST" => "EX_CONSTANT(opline->op1)", "UNUSED" => "NULL", "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var TSRMLS_CC)", "TMPVAR" => "???", @@ -187,7 +187,7 @@ $op2_get_zval_ptr_deref = array( "ANY" => "get_zval_ptr_deref(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)", "VAR" => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2)", - "CONST" => "opline->op2.zv", + "CONST" => "EX_CONSTANT(opline->op2)", "UNUSED" => "NULL", "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var TSRMLS_CC)", "TMPVAR" => "???", @@ -217,7 +217,7 @@ $op1_get_obj_zval_ptr = array( "ANY" => "get_obj_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)", "VAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)", - "CONST" => "opline->op1.zv", + "CONST" => "EX_CONSTANT(opline->op1)", "UNUSED" => "_get_obj_zval_ptr_unused(execute_data)", "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)", "TMPVAR" => "_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1)", @@ -227,7 +227,7 @@ $op2_get_obj_zval_ptr = array( "ANY" => "get_obj_zval_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)", "VAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)", - "CONST" => "opline->op2.zv", + "CONST" => "EX_CONSTANT(opline->op2)", "UNUSED" => "_get_obj_zval_ptr_unused(execute_data)", "CV" => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)", "TMPVAR" => "_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2)", @@ -237,7 +237,7 @@ $op1_get_obj_zval_ptr_deref = array( "ANY" => "get_obj_zval_ptr(opline->op1_type, opline->op1, execute_data, &free_op1, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1)", "VAR" => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1)", - "CONST" => "opline->op1.zv", + "CONST" => "EX_CONSTANT(opline->op1)", "UNUSED" => "_get_obj_zval_ptr_unused(execute_data)", "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var TSRMLS_CC)", "TMPVAR" => "???", @@ -247,7 +247,7 @@ $op2_get_obj_zval_ptr_deref = array( "ANY" => "get_obj_zval_ptr(opline->op2_type, opline->op2, execute_data, &free_op2, \\1)", "TMP" => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2)", "VAR" => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2)", - "CONST" => "opline->op2.zv", + "CONST" => "EX_CONSTANT(opline->op2)", "UNUSED" => "_get_obj_zval_ptr_unused(execute_data)", "CV" => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var TSRMLS_CC)", "TMPVAR" => "???", diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c index 15bca2adf8..6eb6a4ce02 100644 --- a/ext/opcache/Optimizer/pass1_5.c +++ b/ext/opcache/Optimizer/pass1_5.c @@ -401,7 +401,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx TSRML opline->result_type = IS_UNUSED; opline->op1.constant = send1_opline->op1.constant; opline->op2.constant = send2_opline->op1.constant; - opline->result.zv = NULL; + opline->result.num = 0; literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c index 32009791ed..a36b6584b3 100644 --- a/ext/opcache/Optimizer/zend_optimizer.c +++ b/ext/opcache/Optimizer/zend_optimizer.c @@ -428,20 +428,20 @@ static void zend_accel_optimize(zend_op_array *op_array, end = opline + op_array->last; while (opline < end) { if (opline->op1_type == IS_CONST) { - opline->op1.constant = opline->op1.zv - op_array->literals; + ZEND_PASS_TWO_UNDO_CONSTANT(op_array, opline->op1); } if (opline->op2_type == IS_CONST) { - opline->op2.constant = opline->op2.zv - op_array->literals; + ZEND_PASS_TWO_UNDO_CONSTANT(op_array, opline->op2); } switch (opline->opcode) { case ZEND_JMP: case ZEND_GOTO: case ZEND_FAST_CALL: - ZEND_OP1(opline).opline_num = ZEND_OP1(opline).jmp_addr - op_array->opcodes; + ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, ZEND_OP1(opline)); break; case ZEND_JMPZNZ: /* relative offset into absolute index */ - opline->extended_value = (zend_op*)(((char*)opline) + opline->extended_value) - op_array->opcodes; + opline->extended_value = ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value); /* break omitted intentionally */ case ZEND_JMPZ: case ZEND_JMPNZ: @@ -452,7 +452,7 @@ static void zend_accel_optimize(zend_op_array *op_array, case ZEND_NEW: case ZEND_FE_RESET: case ZEND_FE_FETCH: - ZEND_OP2(opline).opline_num = ZEND_OP2(opline).jmp_addr - op_array->opcodes; + ZEND_PASS_TWO_UNDO_JMP_TARGET(op_array, opline, ZEND_OP2(opline)); break; } opline++; @@ -466,20 +466,20 @@ static void zend_accel_optimize(zend_op_array *op_array, end = opline + op_array->last; while (opline < end) { if (opline->op1_type == IS_CONST) { - opline->op1.zv = &op_array->literals[opline->op1.constant]; + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline->op1); } if (opline->op2_type == IS_CONST) { - opline->op2.zv = &op_array->literals[opline->op2.constant]; + ZEND_PASS_TWO_UPDATE_CONSTANT(op_array, opline->op2); } switch (opline->opcode) { case ZEND_JMP: case ZEND_GOTO: case ZEND_FAST_CALL: - ZEND_OP1(opline).jmp_addr = &op_array->opcodes[ZEND_OP1(opline).opline_num]; + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, ZEND_OP1(opline)); break; case ZEND_JMPZNZ: /* absolute index to relative offset */ - opline->extended_value = (char*)(op_array->opcodes + opline->extended_value) - (char*)opline; + opline->extended_value = ZEND_OPLINE_NUM_TO_OFFSET(op_array, opline, opline->extended_value); /* break omitted intentionally */ case ZEND_JMPZ: case ZEND_JMPNZ: @@ -490,7 +490,7 @@ static void zend_accel_optimize(zend_op_array *op_array, case ZEND_NEW: case ZEND_FE_RESET: case ZEND_FE_FETCH: - ZEND_OP2(opline).jmp_addr = &op_array->opcodes[ZEND_OP2(opline).opline_num]; + ZEND_PASS_TWO_UPDATE_JMP_TARGET(op_array, opline, ZEND_OP2(opline)); break; } ZEND_VM_SET_OPCODE_HANDLER(opline); diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c index f6ade86acf..f790a5d778 100644 --- a/ext/opcache/zend_persist.c +++ b/ext/opcache/zend_persist.c @@ -345,18 +345,21 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc op_array->opcodes = persist_ptr; } else { zend_op *new_opcodes = zend_accel_memdup(op_array->opcodes, sizeof(zend_op) * op_array->last); +#if ZEND_USE_ABS_CONST_ADDR || ZEND_USE_ABS_JMP_ADDR zend_op *opline = new_opcodes; zend_op *end = new_opcodes + op_array->last; int offset = 0; for (; opline < end ; opline++, offset++) { +# if ZEND_USE_ABS_CONST_ADDR if (ZEND_OP1_TYPE(opline) == IS_CONST) { opline->op1.zv = (zval*)((char*)opline->op1.zv + ((char*)op_array->literals - (char*)orig_literals)); } if (ZEND_OP2_TYPE(opline) == IS_CONST) { opline->op2.zv = (zval*)((char*)opline->op2.zv + ((char*)op_array->literals - (char*)orig_literals)); } - +# endif +# if ZEND_USE_ABS_JMP_ADDR if (ZEND_DONE_PASS_TWO(op_array)) { /* fix jumps to point to new array */ switch (opline->opcode) { @@ -381,7 +384,9 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc break; } } +# endif } +#endif efree(op_array->opcodes); op_array->opcodes = new_opcodes; diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 7d8f2b43ea..18906d6004 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -722,7 +722,7 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg zend_class_entry *old_scope; string_write(str, " = ", sizeof(" = ")-1); - ZVAL_DUP(&zv, precv->op2.zv); + ZVAL_DUP(&zv, RT_CONSTANT(&fptr->op_array, precv->op2)); old_scope = EG(scope); EG(scope) = fptr->common.scope; zval_update_constant_ex(&zv, 1, NULL TSRMLS_CC); @@ -2618,7 +2618,7 @@ ZEND_METHOD(reflection_parameter, getDefaultValue) return; } - ZVAL_COPY_VALUE(return_value, precv->op2.zv); + ZVAL_COPY_VALUE(return_value, RT_CONSTANT(¶m->fptr->op_array, precv->op2)); if (Z_CONSTANT_P(return_value)) { zend_class_entry *old_scope = EG(scope); @@ -2648,7 +2648,7 @@ ZEND_METHOD(reflection_parameter, isDefaultValueConstant) } precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param); - if (precv && Z_TYPE_P(precv->op2.zv) == IS_CONSTANT) { + if (precv && Z_TYPE_P(RT_CONSTANT(¶m->fptr->op_array, precv->op2)) == IS_CONSTANT) { RETURN_TRUE; } @@ -2673,8 +2673,8 @@ ZEND_METHOD(reflection_parameter, getDefaultValueConstantName) } precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param); - if (precv && Z_TYPE_P(precv->op2.zv) == IS_CONSTANT) { - RETURN_STR(zend_string_copy(Z_STR_P(precv->op2.zv))); + if (precv && Z_TYPE_P(RT_CONSTANT(¶m->fptr->op_array, precv->op2)) == IS_CONSTANT) { + RETURN_STR(zend_string_copy(Z_STR_P(RT_CONSTANT(¶m->fptr->op_array, precv->op2)))); } } /* }}} */ diff --git a/sapi/phpdbg/phpdbg_opcode.c b/sapi/phpdbg/phpdbg_opcode.c index 99f43344a4..20841cbc42 100644 --- a/sapi/phpdbg/phpdbg_opcode.c +++ b/sapi/phpdbg/phpdbg_opcode.c @@ -64,7 +64,7 @@ static inline char *phpdbg_decode_op(zend_op_array *ops, znode_op *op, uint32_t } break; case IS_CONST: - asprintf(&decode, "C%u", phpdbg_decode_literal(ops, op->zv TSRMLS_CC)); + asprintf(&decode, "C%u", phpdbg_decode_literal(ops, RT_CONSTANT(ops, *op) TSRMLS_CC)); break; case IS_UNUSED: @@ -86,7 +86,7 @@ char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op, HashTable *vars TSRM #ifdef ZEND_FAST_CALL case ZEND_FAST_CALL: #endif - asprintf(&decode[1], "J%ld", op->op1.jmp_addr - ops->opcodes); + asprintf(&decode[1], "J%ld", OP_JMP_ADDR(op, op->op1) - ops->opcodes); goto format; case ZEND_JMPZNZ: @@ -103,7 +103,7 @@ char *phpdbg_decode_opline(zend_op_array *ops, zend_op *op, HashTable *vars TSRM case ZEND_JMP_SET: #endif decode[1] = phpdbg_decode_op(ops, &op->op1, op->op1_type, vars TSRMLS_CC); - asprintf(&decode[2], "J%ld", op->op2.jmp_addr - ops->opcodes); + asprintf(&decode[2], "J%ld", OP_JMP_ADDR(op, op->op2) - ops->opcodes); goto result; case ZEND_RECV_INIT: -- cgit v1.2.1 From 3affc0e8a2167fd5e31cf120f691f52d474e5f89 Mon Sep 17 00:00:00 2001 From: Anatol Belski Date: Fri, 12 Dec 2014 10:43:31 +0100 Subject: Fixed bug #68583 Crash in timeout thread This replaces the GUI element used for execution timeout handling on Windows. Instead a timer queue technique is used, which is indeed a thread pool. A timer queue timer is a lightweight object handled but that thread pool and the timer thread spends most of the time sleeping and waiting for an alert. Please note also that this introduces neither binary nor source breach. The custom timeout thread functions are deleted, however they was not exported throug DLL, so couldn't be used by any external code. As well they couldn't be used anywhere in the core except in executor api, because those custom timeout thread functions they used to operate on static variables which would be overwritten (and that would blow). So instead a relatively modern technique is used for the timeout handling. It's still not perfect because the executor still has to check EX(timed_out). This can be a topic for an improvement in master. But brobably can be tricky as currently it seems to be not possible to signal an individual thread. Also note another issue that static variables aren't thread safe, but the current timer implementation is. --- NEWS | 1 + Zend/zend.c | 3 - Zend/zend_execute.h | 7 --- Zend/zend_execute_API.c | 159 +++++++++++++----------------------------------- 4 files changed, 42 insertions(+), 128 deletions(-) diff --git a/NEWS b/NEWS index 3d56e3cc81..2d948194f8 100644 --- a/NEWS +++ b/NEWS @@ -12,6 +12,7 @@ PHP NEWS . Fixed bug #65769 (localeconv() broken in TS builds). (Anatol) . Fixed bug #65230 (setting locale randomly broken). (Anatol) . Fixed bug #68545 (NULL pointer dereference in unserialize.c). (Anatol) + . Fixed bug #68583 (Crash in timeout thread). (Anatol) - cURL: . Fixed bug #67643 (curl_multi_getcontent returns '' when diff --git a/Zend/zend.c b/Zend/zend.c index cb5c39ba8d..5deb7bba4b 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -809,9 +809,6 @@ void zend_shutdown(TSRMLS_D) /* {{{ */ { #ifdef ZEND_SIGNALS zend_signal_shutdown(TSRMLS_C); -#endif -#ifdef ZEND_WIN32 - zend_shutdown_timeout_thread(); #endif zend_destroy_rsrc_list(&EG(persistent_list) TSRMLS_CC); diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index ea06328d93..4a5313776f 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -352,13 +352,6 @@ ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_n ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC); void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC); -#ifdef ZEND_WIN32 -void zend_init_timeout_thread(void); -void zend_shutdown_timeout_thread(void); -#define WM_REGISTER_ZEND_TIMEOUT (WM_USER+1) -#define WM_UNREGISTER_ZEND_TIMEOUT (WM_USER+2) -#endif - #define zendi_zval_copy_ctor(p) zval_copy_ctor(&(p)) #define zendi_zval_dtor(p) zval_dtor(&(p)) diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index f5ee01463a..d6143807ca 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -46,13 +46,10 @@ ZEND_API const zend_fcall_info empty_fcall_info = { 0, NULL, NULL, NULL, NULL, 0 ZEND_API const zend_fcall_info_cache empty_fcall_info_cache = { 0, NULL, NULL, NULL, NULL }; #ifdef ZEND_WIN32 -#include -static WNDCLASS wc; -static HWND timeout_window; -static HANDLE timeout_thread_event; -static HANDLE timeout_thread_handle; -static DWORD timeout_thread_id; -static int timeout_thread_initialized=0; +#ifdef ZTS +__declspec(thread) +#endif +HANDLE tq_timer = NULL; #endif #if 0&&ZEND_DEBUG @@ -1339,115 +1336,19 @@ ZEND_API void zend_timeout(int dummy) /* {{{ */ /* }}} */ #ifdef ZEND_WIN32 -static LRESULT CALLBACK zend_timeout_WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) /* {{{ */ -{ -#ifdef ZTS - THREAD_T thread_id = (THREAD_T)wParam; -#endif - - switch (message) { - case WM_DESTROY: - PostQuitMessage(0); - break; - case WM_REGISTER_ZEND_TIMEOUT: - /* wParam is the thread id pointer, lParam is the timeout amount in seconds */ - if (lParam == 0) { - KillTimer(timeout_window, wParam); - } else { -#ifdef ZTS - void ***tsrm_ls; -#endif - SetTimer(timeout_window, wParam, lParam*1000, NULL); -#ifdef ZTS - tsrm_ls = ts_resource_ex(0, &thread_id); - if (!tsrm_ls) { - /* shouldn't normally happen */ - break; - } -#endif - EG(timed_out) = 0; - } - break; - case WM_UNREGISTER_ZEND_TIMEOUT: - /* wParam is the thread id pointer */ - KillTimer(timeout_window, wParam); - break; - case WM_TIMER: { -#ifdef ZTS - void ***tsrm_ls; - - tsrm_ls = ts_resource_ex(0, &thread_id); - if (!tsrm_ls) { - /* Thread died before receiving its timeout? */ - break; - } -#endif - KillTimer(timeout_window, wParam); - EG(timed_out) = 1; - } - break; - default: - return DefWindowProc(hWnd, message, wParam, lParam); - } - return 0; -} -/* }}} */ - -static unsigned __stdcall timeout_thread_proc(void *pArgs) /* {{{ */ -{ - MSG message; - - wc.style=0; - wc.lpfnWndProc = zend_timeout_WndProc; - wc.cbClsExtra=0; - wc.cbWndExtra=0; - wc.hInstance=NULL; - wc.hIcon=NULL; - wc.hCursor=NULL; - wc.hbrBackground=(HBRUSH)(COLOR_BACKGROUND + 5); - wc.lpszMenuName=NULL; - wc.lpszClassName = "Zend Timeout Window"; - if (!RegisterClass(&wc)) { - return -1; - } - timeout_window = CreateWindow(wc.lpszClassName, wc.lpszClassName, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, NULL); - SetEvent(timeout_thread_event); - while (GetMessage(&message, NULL, 0, 0)) { - SendMessage(timeout_window, message.message, message.wParam, message.lParam); - if (message.message == WM_QUIT) { - break; - } - } - DestroyWindow(timeout_window); - UnregisterClass(wc.lpszClassName, NULL); - SetEvent(timeout_thread_handle); - return 0; -} -/* }}} */ - -void zend_init_timeout_thread(void) /* {{{ */ +VOID CALLBACK tq_timer_cb(PVOID arg, BOOLEAN timed_out) { - timeout_thread_event = CreateEvent(NULL, FALSE, FALSE, NULL); - timeout_thread_handle = CreateEvent(NULL, FALSE, FALSE, NULL); - _beginthreadex(NULL, 0, timeout_thread_proc, NULL, 0, &timeout_thread_id); - WaitForSingleObject(timeout_thread_event, INFINITE); -} -/* }}} */ + zend_bool *php_timed_out; -void zend_shutdown_timeout_thread(void) /* {{{ */ -{ - if (!timeout_thread_initialized) { + /* The doc states it'll be always true, however it theoretically + could be FALSE when the thread was signaled. */ + if (!timed_out) { return; } - PostThreadMessage(timeout_thread_id, WM_QUIT, 0, 0); - /* Wait for thread termination */ - WaitForSingleObject(timeout_thread_handle, 5000); - CloseHandle(timeout_thread_handle); - timeout_thread_initialized = 0; + php_timed_out = (zend_bool *)arg; + *php_timed_out = 1; } -/* }}} */ - #endif /* This one doesn't exists on QNX */ @@ -1465,13 +1366,28 @@ void zend_set_timeout(long seconds, int reset_signals) /* {{{ */ if(!seconds) { return; } - if (timeout_thread_initialized == 0 && InterlockedIncrement(&timeout_thread_initialized) == 1) { - /* We start up this process-wide thread here and not in zend_startup(), because if Zend - * is initialized inside a DllMain(), you're not supposed to start threads from it. - */ - zend_init_timeout_thread(); + + /* Don't use ChangeTimerQueueTimer() as it will not restart an expired + timer, so we could end up with just an ignored timeout. Instead + delete and recreate. */ + if (NULL != tq_timer) { + if (!DeleteTimerQueueTimer(NULL, tq_timer, NULL)) { + EG(timed_out) = 0; + tq_timer = NULL; + zend_error(E_ERROR, "Could not delete queued timer"); + return; + } + tq_timer = NULL; } - PostThreadMessage(timeout_thread_id, WM_REGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) seconds); + + /* XXX passing NULL means the default timer queue provided by the system is used */ + if (!CreateTimerQueueTimer(&tq_timer, NULL, (WAITORTIMERCALLBACK)tq_timer_cb, (VOID*)&EG(timed_out), seconds*1000, 0, WT_EXECUTEONLYONCE)) { + EG(timed_out) = 0; + tq_timer = NULL; + zend_error(E_ERROR, "Could not queue new timer"); + return; + } + EG(timed_out) = 0; #else # ifdef HAVE_SETITIMER { @@ -1513,9 +1429,16 @@ void zend_set_timeout(long seconds, int reset_signals) /* {{{ */ void zend_unset_timeout(TSRMLS_D) /* {{{ */ { #ifdef ZEND_WIN32 - if(timeout_thread_initialized) { - PostThreadMessage(timeout_thread_id, WM_UNREGISTER_ZEND_TIMEOUT, (WPARAM) GetCurrentThreadId(), (LPARAM) 0); + if (NULL != tq_timer) { + if (!DeleteTimerQueueTimer(NULL, tq_timer, NULL)) { + EG(timed_out) = 0; + tq_timer = NULL; + zend_error(E_ERROR, "Could not delete queued timer"); + return; + } + tq_timer = NULL; } + EG(timed_out) = 0; #else # ifdef HAVE_SETITIMER if (EG(timeout_seconds)) { -- cgit v1.2.1 From fd045c7021cabe4462dd99611ab9d003adc203a5 Mon Sep 17 00:00:00 2001 From: Gustavo Frederico Temple Pedrosa Date: Thu, 11 Dec 2014 17:48:41 +0000 Subject: PowerPC64 support for operators with overflow check This adds fast architecture-specific implementations of the following functions for the ppc64: * fast_increment_function * fast_decrement_function --- Zend/zend_operators.h | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index d7967c458a..c6d40b8f85 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -443,6 +443,33 @@ static zend_always_inline int fast_increment_function(zval *op1) "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "cc"); +#elif defined(__GNUC__) && defined(__powerpc64__) + __asm__( + "ld 14, 0(%0)\n\t" + "li 15, 1\n\t" + "li 16, 0\n\t" + "mtxer 16\n\t" + "addo. 14, 14, 15\n\t" + "std 14, 0(%0)\n\t" + "bns+ 0f\n\t" + "xor 14, 14, 14\n\t" + "lis 15, 0x43e00000@h\n\t" + "ori 15, 15, 0x43e00000@l\n\t" +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + "stw 14, 0(%0)\n\t" + "stw 15, 0x4(%0)\n\t" +#else + "stw 14, 0x4(%0)\n\t" + "stw 15, 0(%0)\n\t" +#endif + "li 14, %1\n\t" + "stw 14, %c2(%0)\n" + "0:" + : + : "r"(&op1->value), + "n"(IS_DOUBLE), + "n"(ZVAL_OFFSETOF_TYPE) + : "r14", "r15", "r16", "cc"); #else if (UNEXPECTED(Z_LVAL_P(op1) == ZEND_LONG_MAX)) { /* switch to double */ @@ -485,6 +512,33 @@ static zend_always_inline int fast_decrement_function(zval *op1) "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "cc"); +#elif defined(__GNUC__) && defined(__powerpc64__) + __asm__( + "ld 14, 0(%0)\n\t" + "li 15, 1\n\t" + "li 16, 0\n\t" + "mtxer 16\n\t" + "subo. 14, 14, 15\n\t" + "std 14, 0(%0)\n\t" + "bns+ 0f\n\t" + "xor 14, 14, 14\n\t" + "lis 15, 0xc3e00000@h\n\t" + "ori 15, 15, 0xc3e00000@l\n\t" +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + "stw 14, 0(%0)\n\t" + "stw 15, 0x4(%0)\n\t" +#else + "stw 14, 0x4(%0)\n\t" + "stw 15, 0(%0)\n\t" +#endif + "li 14, %1\n\t" + "stw 14, %c2(%0)\n" + "0:" + : + : "r"(&op1->value), + "n"(IS_DOUBLE), + "n"(ZVAL_OFFSETOF_TYPE) + : "r14", "r15", "r16", "cc"); #else if (UNEXPECTED(Z_LVAL_P(op1) == ZEND_LONG_MIN)) { /* switch to double */ -- cgit v1.2.1 From 5dbeb9e65eb01fb974cd88025a4054f4e51bdbf2 Mon Sep 17 00:00:00 2001 From: Gustavo Frederico Temple Pedrosa Date: Thu, 11 Dec 2014 18:14:51 +0000 Subject: PowerPC64 support for add and sub with overflow check This adds fast architecture-specific implementations of the following functions for the ppc64: * fast_add_function * fast_sub_function --- Zend/zend_operators.h | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index c6d40b8f85..ccd00b4e52 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -602,6 +602,36 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "rax","cc"); +#elif defined(__GNUC__) && defined(__powerpc64__) + __asm__( + "ld 14, 0(%1)\n\t" + "ld 15, 0(%2)\n\t" + "li 16, 0 \n\t" + "mtxer 16\n\t" + "addo. 14, 14, 15\n\t" + "bso- 0f\n\t" + "std 14, 0(%0)\n\t" + "li 14, %3\n\t" + "stw 14, %c5(%0)\n\t" + "b 1f\n" + "0:\n\t" + "lfd 0, 0(%1)\n\t" + "lfd 1, 0(%2)\n\t" + "fcfid 0, 0\n\t" + "fcfid 1, 1\n\t" + "fadd 0, 0, 1\n\t" + "li 14, %4\n\t" + "stw 14, %c5(%0)\n\t" + "stfd 0, 0(%0)\n" + "1:" + : + : "r"(&result->value), + "r"(&op1->value), + "r"(&op2->value), + "n"(IS_LONG), + "n"(IS_DOUBLE), + "n"(ZVAL_OFFSETOF_TYPE) + : "r14","r15","r16","fr0","fr1","cc"); #else /* * 'result' may alias with op1 or op2, so we need to @@ -691,6 +721,36 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o "n"(IS_DOUBLE), "n"(ZVAL_OFFSETOF_TYPE) : "rax","cc"); +#elif defined(__GNUC__) && defined(__powerpc64__) + __asm__( + "ld 14, 0(%1)\n\t" + "ld 15, 0(%2)\n\t" + "li 16, 0\n\t" + "mtxer 16\n\t" + "subo. 14, 14, 15\n\t" + "bso- 0f\n\t" + "std 14, 0(%0)\n\t" + "li 14, %3\n\t" + "stw 14, %c5(%0)\n\t" + "b 1f\n" + "0:\n\t" + "lfd 0, 0(%1)\n\t" + "lfd 1, 0(%2)\n\t" + "fcfid 0, 0\n\t" + "fcfid 1, 1\n\t" + "fsub 0, 0, 1\n\t" + "li 14, %4\n\t" + "stw 14, %c5(%0)\n\t" + "stfd 0, 0(%0)\n" + "1:" + : + : "r"(&result->value), + "r"(&op1->value), + "r"(&op2->value), + "n"(IS_LONG), + "n"(IS_DOUBLE), + "n"(ZVAL_OFFSETOF_TYPE) + : "r14","r15","r16","fr0","fr1","cc"); #else ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2)); -- cgit v1.2.1 From b1709b8ff0ad3a4beb1b560301d886aa49946599 Mon Sep 17 00:00:00 2001 From: Anatol Belski Date: Fri, 12 Dec 2014 12:17:42 +0100 Subject: updated NEWS --- NEWS | 1 + 1 file changed, 1 insertion(+) diff --git a/NEWS b/NEWS index 6ddabffa8a..81a2f2b221 100644 --- a/NEWS +++ b/NEWS @@ -13,6 +13,7 @@ PHP NEWS . Fixed bug #65769 (localeconv() broken in TS builds). (Anatol) . Fixed bug #65230 (setting locale randomly broken). (Anatol) . Fixed bug #68545 (NULL pointer dereference in unserialize.c). (Anatol) + . Fixed bug #68583 (Crash in timeout thread). (Anatol) - cURL: . Fixed bug #67643 (curl_multi_getcontent returns '' when -- cgit v1.2.1