/Zend/zend_vm_def.h
C Header | 9217 lines | 7916 code | 1092 blank | 209 comment | 3120 complexity | 269e6b1c43e0bd1cf797e3fe4f21d39d MD5 | raw file
Possible License(s): BSD-2-Clause, BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-2.1
Large files files are truncated, but you can click here to view the full file
- /*
- +----------------------------------------------------------------------+
- | Zend Engine |
- +----------------------------------------------------------------------+
- | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
- +----------------------------------------------------------------------+
- | This source file is subject to version 2.00 of the Zend license, |
- | that is bundled with this package in the file LICENSE, and is |
- | available through the world-wide-web at the following url: |
- | http://www.zend.com/license/2_00.txt. |
- | If you did not receive a copy of the Zend license and are unable to |
- | obtain it through the world-wide-web, please send a note to |
- | license@zend.com so we can mail you a copy immediately. |
- +----------------------------------------------------------------------+
- | Authors: Andi Gutmans <andi@php.net> |
- | Zeev Suraski <zeev@php.net> |
- | Dmitry Stogov <dmitry@php.net> |
- +----------------------------------------------------------------------+
- */
- /* If you change this file, please regenerate the zend_vm_execute.h and
- * zend_vm_opcodes.h files by running:
- * php zend_vm_gen.php
- */
- ZEND_VM_HELPER(zend_add_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- add_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(1, ZEND_ADD, CONST|TMPVARCV, CONST|TMPVARCV)
- {
- USE_OPLINE
- zval *op1, *op2, *result;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- result = EX_VAR(opline->result.var);
- fast_long_add_function(result, op1, op2);
- ZEND_VM_NEXT_OPCODE();
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(add_double);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(add_double):
- result = EX_VAR(opline->result.var);
- ZVAL_DOUBLE(result, d1 + d2);
- ZEND_VM_NEXT_OPCODE();
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(add_double);
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_add_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_sub_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- sub_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(2, ZEND_SUB, CONST|TMPVARCV, CONST|TMPVARCV)
- {
- USE_OPLINE
- zval *op1, *op2, *result;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- result = EX_VAR(opline->result.var);
- fast_long_sub_function(result, op1, op2);
- ZEND_VM_NEXT_OPCODE();
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(sub_double);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(sub_double):
- result = EX_VAR(opline->result.var);
- ZVAL_DOUBLE(result, d1 - d2);
- ZEND_VM_NEXT_OPCODE();
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(sub_double);
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_sub_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_mul_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- mul_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(3, ZEND_MUL, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2, *result;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- zend_long overflow;
- result = EX_VAR(opline->result.var);
- ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
- Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
- ZEND_VM_NEXT_OPCODE();
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(mul_double);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(mul_double):
- result = EX_VAR(opline->result.var);
- ZVAL_DOUBLE(result, d1 * d2);
- ZEND_VM_NEXT_OPCODE();
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(mul_double);
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_mul_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(4, ZEND_DIV, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- {
- USE_OPLINE
- zval *op1, *op2;
- SAVE_OPLINE();
- op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
- fast_div_function(EX_VAR(opline->result.var), op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_COLD_HELPER(zend_mod_by_zero_helper, ANY, ANY)
- {
- USE_OPLINE
- SAVE_OPLINE();
- zend_throw_exception_ex(zend_ce_division_by_zero_error, 0, "Modulo by zero");
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- ZEND_VM_HELPER(zend_mod_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- mod_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(5, ZEND_MOD, CONST|TMPVARCV, CONST|TMPVARCV)
- {
- USE_OPLINE
- zval *op1, *op2, *result;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- result = EX_VAR(opline->result.var);
- if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
- ZEND_VM_DISPATCH_TO_HELPER(zend_mod_by_zero_helper);
- } else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
- /* Prevent overflow error/crash if op1==ZEND_LONG_MIN */
- ZVAL_LONG(result, 0);
- } else {
- ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
- }
- ZEND_VM_NEXT_OPCODE();
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_mod_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_shift_left_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- shift_left_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(6, ZEND_SL, CONST|TMPVARCV, CONST|TMPVARCV)
- {
- USE_OPLINE
- zval *op1, *op2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
- && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
- && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
- /* Perform shift on unsigned numbers to get well-defined wrap behavior. */
- ZVAL_LONG(EX_VAR(opline->result.var),
- (zend_long) ((zend_ulong) Z_LVAL_P(op1) << Z_LVAL_P(op2)));
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_shift_left_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_shift_right_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- shift_right_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(7, ZEND_SR, CONST|TMPVARCV, CONST|TMPVARCV)
- {
- USE_OPLINE
- zval *op1, *op2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
- && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)
- && EXPECTED((zend_ulong)Z_LVAL_P(op2) < SIZEOF_ZEND_LONG * 8)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) >> Z_LVAL_P(op2));
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_shift_right_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(12, ZEND_POW, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- {
- USE_OPLINE
- zval *op1, *op2;
- SAVE_OPLINE();
- op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
- pow_function(EX_VAR(opline->result.var), op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(NO_CONST_CONST))
- {
- USE_OPLINE
- zval *op1, *op2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if ((OP1_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) &&
- (OP2_TYPE == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) {
- zend_string *op1_str = Z_STR_P(op1);
- zend_string *op2_str = Z_STR_P(op2);
- zend_string *str;
- if (OP1_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) {
- if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_CV) {
- ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str);
- } else {
- ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- }
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zend_string_release_ex(op1_str, 0);
- }
- } else if (OP2_TYPE != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) {
- if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_CV) {
- ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str);
- } else {
- ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zend_string_release_ex(op2_str, 0);
- }
- } else if (OP1_TYPE != IS_CONST && OP1_TYPE != IS_CV &&
- !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) {
- size_t len = ZSTR_LEN(op1_str);
- str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0);
- memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
- ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zend_string_release_ex(op2_str, 0);
- }
- } else {
- str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0);
- memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str));
- memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
- ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zend_string_release_ex(op1_str, 0);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zend_string_release_ex(op2_str, 0);
- }
- }
- ZEND_VM_NEXT_OPCODE();
- } else {
- SAVE_OPLINE();
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) {
- op1 = ZVAL_UNDEFINED_OP1();
- }
- if (OP2_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) {
- op2 = ZVAL_UNDEFINED_OP2();
- }
- concat_function(EX_VAR(opline->result.var), op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(16, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- zend_bool result;
- SAVE_OPLINE();
- op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
- result = fast_is_identical_function(op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_SMART_BRANCH(result, 1);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- zend_bool result;
- SAVE_OPLINE();
- op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
- result = fast_is_not_identical_function(op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_SMART_BRANCH(result, 1);
- }
- ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- int ret;
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- ret = zend_compare(op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_SMART_BRANCH(ret == 0, 1);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(18, ZEND_IS_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) {
- ZEND_VM_C_LABEL(is_equal_true):
- ZEND_VM_SMART_BRANCH_TRUE();
- } else {
- ZEND_VM_C_LABEL(is_equal_false):
- ZEND_VM_SMART_BRANCH_FALSE();
- }
- } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(is_equal_double);
- }
- } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(is_equal_double):
- if (d1 == d2) {
- ZEND_VM_C_GOTO(is_equal_true);
- } else {
- ZEND_VM_C_GOTO(is_equal_false);
- }
- } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(is_equal_double);
- }
- } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
- if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
- int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_str(op1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_str(op2);
- }
- if (result) {
- ZEND_VM_C_GOTO(is_equal_true);
- } else {
- ZEND_VM_C_GOTO(is_equal_false);
- }
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_is_not_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- int ret;
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- ret = zend_compare(op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_SMART_BRANCH(ret != 0, 1);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(19, ZEND_IS_NOT_EQUAL, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(SMART_BRANCH,COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) {
- ZEND_VM_C_LABEL(is_not_equal_true):
- ZEND_VM_SMART_BRANCH_TRUE();
- } else {
- ZEND_VM_C_LABEL(is_not_equal_false):
- ZEND_VM_SMART_BRANCH_FALSE();
- }
- } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(is_not_equal_double);
- }
- } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(is_not_equal_double):
- if (d1 != d2) {
- ZEND_VM_C_GOTO(is_not_equal_true);
- } else {
- ZEND_VM_C_GOTO(is_not_equal_false);
- }
- } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(is_not_equal_double);
- }
- } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) {
- if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) {
- int result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2));
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_str(op1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_str(op2);
- }
- if (!result) {
- ZEND_VM_C_GOTO(is_not_equal_true);
- } else {
- ZEND_VM_C_GOTO(is_not_equal_false);
- }
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_is_smaller_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- int ret;
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- ret = zend_compare(op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_SMART_BRANCH(ret < 0, 1);
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(20, ZEND_IS_SMALLER, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
- {
- USE_OPLINE
- zval *op1, *op2;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- if (EXPECTED(Z_LVAL_P(op1) < Z_LVAL_P(op2))) {
- ZEND_VM_C_LABEL(is_smaller_true):
- ZEND_VM_SMART_BRANCH_TRUE();
- } else {
- ZEND_VM_C_LABEL(is_smaller_false):
- ZEND_VM_SMART_BRANCH_FALSE();
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(is_smaller_double);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(is_smaller_double):
- if (d1 < d2) {
- ZEND_VM_C_GOTO(is_smaller_true);
- } else {
- ZEND_VM_C_GOTO(is_smaller_false);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(is_smaller_double);
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_is_smaller_or_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- int ret;
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- ret = zend_compare(op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_SMART_BRANCH(ret <= 0, 1);
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(21, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(SMART_BRANCH))
- {
- USE_OPLINE
- zval *op1, *op2;
- double d1, d2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- if (EXPECTED(Z_LVAL_P(op1) <= Z_LVAL_P(op2))) {
- ZEND_VM_C_LABEL(is_smaller_or_equal_true):
- ZEND_VM_SMART_BRANCH_TRUE();
- ZVAL_TRUE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- } else {
- ZEND_VM_C_LABEL(is_smaller_or_equal_false):
- ZEND_VM_SMART_BRANCH_FALSE();
- ZVAL_FALSE(EX_VAR(opline->result.var));
- ZEND_VM_NEXT_OPCODE();
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = (double)Z_LVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_GOTO(is_smaller_or_equal_double);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_DOUBLE)) {
- if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_DOUBLE)) {
- d1 = Z_DVAL_P(op1);
- d2 = Z_DVAL_P(op2);
- ZEND_VM_C_LABEL(is_smaller_or_equal_double):
- if (d1 <= d2) {
- ZEND_VM_C_GOTO(is_smaller_or_equal_true);
- } else {
- ZEND_VM_C_GOTO(is_smaller_or_equal_false);
- }
- } else if (EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- d1 = Z_DVAL_P(op1);
- d2 = (double)Z_LVAL_P(op2);
- ZEND_VM_C_GOTO(is_smaller_or_equal_double);
- }
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_is_smaller_or_equal_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(170, ZEND_SPACESHIP, CONST|TMPVAR|CV, CONST|TMPVAR|CV)
- {
- USE_OPLINE
- zval *op1, *op2;
- SAVE_OPLINE();
- op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
- compare_function(EX_VAR(opline->result.var), op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HELPER(zend_bw_or_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- bitwise_or_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(9, ZEND_BW_OR, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
- && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) | Z_LVAL_P(op2));
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_bw_or_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_bw_and_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- bitwise_and_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(10, ZEND_BW_AND, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
- && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) & Z_LVAL_P(op2));
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_bw_and_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_HELPER(zend_bw_xor_helper, ANY, ANY, zval *op_1, zval *op_2)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_INFO_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- if (UNEXPECTED(Z_TYPE_INFO_P(op_2) == IS_UNDEF)) {
- op_2 = ZVAL_UNDEFINED_OP2();
- }
- bitwise_xor_function(EX_VAR(opline->result.var), op_1, op_2);
- if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_1);
- }
- if (OP2_TYPE & (IS_TMP_VAR|IS_VAR)) {
- zval_ptr_dtor_nogc(op_2);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_NOCONSTCONST_HANDLER(11, ZEND_BW_XOR, CONST|TMPVARCV, CONST|TMPVARCV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (ZEND_VM_SPEC && OP1_TYPE == IS_CONST && OP2_TYPE == IS_CONST) {
- /* pass */
- } else if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)
- && EXPECTED(Z_TYPE_INFO_P(op2) == IS_LONG)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(op1) ^ Z_LVAL_P(op2));
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_bw_xor_helper, op_1, op1, op_2, op2);
- }
- ZEND_VM_COLD_CONSTCONST_HANDLER(15, ZEND_BOOL_XOR, CONST|TMPVAR|CV, CONST|TMPVAR|CV, SPEC(COMMUTATIVE))
- {
- USE_OPLINE
- zval *op1, *op2;
- SAVE_OPLINE();
- op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
- op2 = GET_OP2_ZVAL_PTR(BP_VAR_R);
- boolean_xor_function(EX_VAR(opline->result.var), op1, op2);
- FREE_OP1();
- FREE_OP2();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HELPER(zend_bw_not_helper, ANY, ANY, zval *op_1)
- {
- USE_OPLINE
- SAVE_OPLINE();
- if (UNEXPECTED(Z_TYPE_P(op_1) == IS_UNDEF)) {
- op_1 = ZVAL_UNDEFINED_OP1();
- }
- bitwise_not_function(EX_VAR(opline->result.var), op_1);
- FREE_OP1();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_NOCONST_HANDLER(13, ZEND_BW_NOT, CONST|TMPVARCV, ANY)
- {
- USE_OPLINE
- zval *op1;
- op1 = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (EXPECTED(Z_TYPE_INFO_P(op1) == IS_LONG)) {
- ZVAL_LONG(EX_VAR(opline->result.var), ~Z_LVAL_P(op1));
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_bw_not_helper, op_1, op1);
- }
- ZEND_VM_COLD_CONST_HANDLER(14, ZEND_BOOL_NOT, CONST|TMPVAR|CV, ANY)
- {
- USE_OPLINE
- zval *val;
- val = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (Z_TYPE_INFO_P(val) == IS_TRUE) {
- ZVAL_FALSE(EX_VAR(opline->result.var));
- } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) {
- /* The result and op1 can be the same cv zval */
- const uint32_t orig_val_type = Z_TYPE_INFO_P(val);
- ZVAL_TRUE(EX_VAR(opline->result.var));
- if (OP1_TYPE == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) {
- SAVE_OPLINE();
- ZVAL_UNDEFINED_OP1();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- } else {
- SAVE_OPLINE();
- ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val));
- FREE_OP1();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_COLD_HELPER(zend_this_not_in_object_context_helper, ANY, ANY)
- {
- USE_OPLINE
- SAVE_OPLINE();
- zend_throw_error(NULL, "Using $this when not in object context");
- UNDEF_RESULT();
- HANDLE_EXCEPTION();
- }
- ZEND_VM_COLD_HELPER(zend_undefined_function_helper, ANY, ANY)
- {
- USE_OPLINE
- zval *function_name;
- SAVE_OPLINE();
- function_name = RT_CONSTANT(opline, opline->op2);
- zend_throw_error(NULL, "Call to undefined function %s()", Z_STRVAL_P(function_name));
- HANDLE_EXCEPTION();
- }
- ZEND_VM_HANDLER(28, ZEND_ASSIGN_OBJ_OP, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, OP)
- {
- USE_OPLINE
- zval *object;
- zval *property;
- zval *value;
- zval *zptr;
- void **cache_slot;
- zend_property_info *prop_info;
- zend_object *zobj;
- zend_string *name, *tmp_name;
- SAVE_OPLINE();
- object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- property = GET_OP2_ZVAL_PTR(BP_VAR_R);
- do {
- value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
- if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
- if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
- object = Z_REFVAL_P(object);
- ZEND_VM_C_GOTO(assign_op_object);
- }
- if (OP1_TYPE == IS_CV
- && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
- ZVAL_UNDEFINED_OP1();
- }
- zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- ZEND_VM_C_LABEL(assign_op_object):
- /* here we are sure we are dealing with an object */
- zobj = Z_OBJ_P(object);
- if (OP2_TYPE == IS_CONST) {
- name = Z_STR_P(property);
- } else {
- name = zval_try_get_tmp_string(property, &tmp_name);
- if (UNEXPECTED(!name)) {
- UNDEF_RESULT();
- break;
- }
- }
- cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : NULL;
- if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
- if (UNEXPECTED(Z_ISERROR_P(zptr))) {
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_NULL(EX_VAR(opline->result.var));
- }
- } else {
- zval *orig_zptr = zptr;
- zend_reference *ref;
- do {
- if (UNEXPECTED(Z_ISREF_P(zptr))) {
- ref = Z_REF_P(zptr);
- zptr = Z_REFVAL_P(zptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- if (OP2_TYPE == IS_CONST) {
- prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
- } else {
- prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), orig_zptr);
- }
- if (UNEXPECTED(prop_info)) {
- /* special case for typed properties */
- zend_binary_assign_op_typed_prop(prop_info, zptr, value OPLINE_CC EXECUTE_DATA_CC);
- } else {
- zend_binary_op(zptr, zptr, value OPLINE_CC);
- }
- } while (0);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY(EX_VAR(opline->result.var), zptr);
- }
- }
- } else {
- zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC);
- }
- if (OP2_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- } while (0);
- FREE_OP_DATA();
- FREE_OP2();
- FREE_OP1_VAR_PTR();
- /* assign_obj has two opcodes! */
- ZEND_VM_NEXT_OPCODE_EX(1, 2);
- }
- /* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */
- ZEND_VM_HANDLER(29, ZEND_ASSIGN_STATIC_PROP_OP, ANY, ANY, OP)
- {
- /* This helper actually never will receive IS_VAR as second op, and has the same handling for VAR and TMP in the first op, but for interoperability with the other binary_assign_op helpers, it is necessary to "include" it */
- USE_OPLINE
- zval *prop, *value;
- zend_property_info *prop_info;
- zend_reference *ref;
- SAVE_OPLINE();
- if (UNEXPECTED(zend_fetch_static_property_address(&prop, &prop_info, (opline+1)->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS)) {
- ZEND_ASSERT(EG(exception));
- UNDEF_RESULT();
- FREE_UNFETCHED_OP_DATA();
- HANDLE_EXCEPTION();
- }
- value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R);
- do {
- if (UNEXPECTED(Z_ISREF_P(prop))) {
- ref = Z_REF_P(prop);
- prop = Z_REFVAL_P(prop);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- if (UNEXPECTED(ZEND_TYPE_IS_SET(prop_info->type))) {
- /* special case for typed properties */
- zend_binary_assign_op_typed_prop(prop_info, prop, value OPLINE_CC EXECUTE_DATA_CC);
- } else {
- zend_binary_op(prop, prop, value OPLINE_CC);
- }
- } while (0);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY(EX_VAR(opline->result.var), prop);
- }
- FREE_OP_DATA();
- /* assign_static_prop has two opcodes! */
- ZEND_VM_NEXT_OPCODE_EX(1, 2);
- }
- ZEND_VM_HANDLER(27, ZEND_ASSIGN_DIM_OP, VAR|CV, CONST|TMPVAR|UNUSED|NEXT|CV, OP)
- {
- USE_OPLINE
- zval *var_ptr;
- zval *value, *container, *dim;
- SAVE_OPLINE();
- container = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
- ZEND_VM_C_LABEL(assign_dim_op_array):
- SEPARATE_ARRAY(container);
- ZEND_VM_C_LABEL(assign_dim_op_new_array):
- dim = GET_OP2_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (OP2_TYPE == IS_UNUSED) {
- var_ptr = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
- if (UNEXPECTED(!var_ptr)) {
- zend_cannot_add_element();
- ZEND_VM_C_GOTO(assign_dim_op_ret_null);
- }
- } else {
- if (OP2_TYPE == IS_CONST) {
- var_ptr = zend_fetch_dimension_address_inner_RW_CONST(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
- } else {
- var_ptr = zend_fetch_dimension_address_inner_RW(Z_ARRVAL_P(container), dim EXECUTE_DATA_CC);
- }
- if (UNEXPECTED(!var_ptr)) {
- ZEND_VM_C_GOTO(assign_dim_op_ret_null);
- }
- }
- value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1);
- do {
- if (OP2_TYPE != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) {
- zend_reference *ref = Z_REF_P(var_ptr);
- var_ptr = Z_REFVAL_P(var_ptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
- } while (0);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- }
- FREE_OP((opline+1)->op1_type, (opline+1)->op1.var);
- } else {
- if (EXPECTED(Z_ISREF_P(container))) {
- container = Z_REFVAL_P(container);
- if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
- ZEND_VM_C_GOTO(assign_dim_op_array);
- }
- }
- dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
- if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
- if (OP2_TYPE == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) {
- dim++;
- }
- zend_binary_assign_op_obj_dim(container, dim OPLINE_CC EXECUTE_DATA_CC);
- } else if (EXPECTED(Z_TYPE_P(container) <= IS_FALSE)) {
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(container) == IS_UNDEF)) {
- ZVAL_UNDEFINED_OP1();
- }
- ZVAL_ARR(container, zend_new_array(8));
- ZEND_VM_C_GOTO(assign_dim_op_new_array);
- } else {
- zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC);
- ZEND_VM_C_LABEL(assign_dim_op_ret_null):
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_NULL(EX_VAR(opline->result.var));
- }
- }
- }
- FREE_OP2();
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_EX(1, 2);
- }
- ZEND_VM_HANDLER(26, ZEND_ASSIGN_OP, VAR|CV, CONST|TMPVAR|CV, OP)
- {
- USE_OPLINE
- zval *var_ptr;
- zval *value;
- SAVE_OPLINE();
- value = GET_OP2_ZVAL_PTR(BP_VAR_R);
- var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
- do {
- if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
- zend_reference *ref = Z_REF_P(var_ptr);
- var_ptr = Z_REFVAL_P(var_ptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_binary_assign_op_typed_ref(ref, value OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- zend_binary_op(var_ptr, var_ptr, value OPLINE_CC);
- } while (0);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- }
- FREE_OP2();
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HANDLER(132, ZEND_PRE_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
- {
- USE_OPLINE
- zval *object;
- zval *property;
- zval *zptr;
- void **cache_slot;
- zend_property_info *prop_info;
- zend_object *zobj;
- zend_string *name, *tmp_name;
- SAVE_OPLINE();
- object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- property = GET_OP2_ZVAL_PTR(BP_VAR_R);
- do {
- if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
- if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
- object = Z_REFVAL_P(object);
- ZEND_VM_C_GOTO(pre_incdec_object);
- }
- if (OP1_TYPE == IS_CV
- && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
- ZVAL_UNDEFINED_OP1();
- }
- zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- ZEND_VM_C_LABEL(pre_incdec_object):
- /* here we are sure we are dealing with an object */
- zobj = Z_OBJ_P(object);
- if (OP2_TYPE == IS_CONST) {
- name = Z_STR_P(property);
- } else {
- name = zval_try_get_tmp_string(property, &tmp_name);
- if (UNEXPECTED(!name)) {
- UNDEF_RESULT();
- break;
- }
- }
- cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
- if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
- if (UNEXPECTED(Z_ISERROR_P(zptr))) {
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_NULL(EX_VAR(opline->result.var));
- }
- } else {
- if (OP2_TYPE == IS_CONST) {
- prop_info = (zend_property_info *) CACHED_PTR_EX(cache_slot + 2);
- } else {
- prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
- }
- zend_pre_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
- }
- } else {
- zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
- }
- if (OP2_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- } while (0);
- FREE_OP2();
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HANDLER(133, ZEND_PRE_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
- {
- ZEND_VM_DISPATCH_TO_HANDLER(ZEND_PRE_INC_OBJ);
- }
- ZEND_VM_HANDLER(134, ZEND_POST_INC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
- {
- USE_OPLINE
- zval *object;
- zval *property;
- zval *zptr;
- void **cache_slot;
- zend_property_info *prop_info;
- zend_object *zobj;
- zend_string *name, *tmp_name;
- SAVE_OPLINE();
- object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- property = GET_OP2_ZVAL_PTR(BP_VAR_R);
- do {
- if (OP1_TYPE != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
- if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) {
- object = Z_REFVAL_P(object);
- ZEND_VM_C_GOTO(post_incdec_object);
- }
- if (OP1_TYPE == IS_CV
- && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) {
- ZVAL_UNDEFINED_OP1();
- }
- zend_throw_non_object_error(object, property OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- ZEND_VM_C_LABEL(post_incdec_object):
- /* here we are sure we are dealing with an object */
- zobj = Z_OBJ_P(object);
- if (OP2_TYPE == IS_CONST) {
- name = Z_STR_P(property);
- } else {
- name = zval_try_get_tmp_string(property, &tmp_name);
- if (UNEXPECTED(!name)) {
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- break;
- }
- }
- cache_slot = (OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL;
- if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) {
- if (UNEXPECTED(Z_ISERROR_P(zptr))) {
- ZVAL_NULL(EX_VAR(opline->result.var));
- } else {
- if (OP2_TYPE == IS_CONST) {
- prop_info = (zend_property_info*)CACHED_PTR_EX(cache_slot + 2);
- } else {
- prop_info = zend_object_fetch_property_type_info(Z_OBJ_P(object), zptr);
- }
- zend_post_incdec_property_zval(zptr, prop_info OPLINE_CC EXECUTE_DATA_CC);
- }
- } else {
- zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC);
- }
- if (OP2_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- } while (0);
- FREE_OP2();
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HANDLER(135, ZEND_POST_DEC_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, CACHE_SLOT)
- {
- ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_OBJ);
- }
- /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
- ZEND_VM_HANDLER(38, ZEND_PRE_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
- {
- USE_OPLINE
- zval *prop;
- zend_property_info *prop_info;
- SAVE_OPLINE();
- if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
- UNDEF_RESULT();
- HANDLE_EXCEPTION();
- }
- zend_pre_incdec_property_zval(prop,
- ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
- ZEND_VM_HANDLER(39, ZEND_PRE_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
- {
- ZEND_VM_DISPATCH_TO_HANDLER(ZEND_PRE_INC_STATIC_PROP);
- }
- /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
- ZEND_VM_HANDLER(40, ZEND_POST_INC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
- {
- USE_OPLINE
- zval *prop;
- zend_property_info *prop_info;
- SAVE_OPLINE();
- if (zend_fetch_static_property_address(&prop, &prop_info, opline->extended_value, BP_VAR_RW, 0 OPLINE_CC EXECUTE_DATA_CC) != SUCCESS) {
- UNDEF_RESULT();
- HANDLE_EXCEPTION();
- }
- zend_post_incdec_property_zval(prop,
- ZEND_TYPE_IS_SET(prop_info->type) ? prop_info : NULL OPLINE_CC EXECUTE_DATA_CC);
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- /* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */
- ZEND_VM_HANDLER(41, ZEND_POST_DEC_STATIC_PROP, ANY, ANY, CACHE_SLOT)
- {
- ZEND_VM_DISPATCH_TO_HANDLER(ZEND_POST_INC_STATIC_PROP);
- }
- ZEND_VM_HELPER(zend_pre_inc_helper, VAR|CV, ANY)
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- SAVE_OPLINE();
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
- ZVAL_NULL(var_ptr);
- ZVAL_UNDEFINED_OP1();
- }
- do {
- if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
- zend_reference *ref = Z_REF_P(var_ptr);
- var_ptr = Z_REFVAL_P(var_ptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- increment_function(var_ptr);
- } while (0);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- }
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY, SPEC(RETVAL))
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
- fast_long_increment_function(var_ptr);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
- }
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_pre_inc_helper);
- }
- ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY)
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- SAVE_OPLINE();
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
- ZVAL_NULL(var_ptr);
- ZVAL_UNDEFINED_OP1();
- }
- do {
- if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
- zend_reference *ref = Z_REF_P(var_ptr);
- var_ptr = Z_REFVAL_P(var_ptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_incdec_typed_ref(ref, NULL OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- decrement_function(var_ptr);
- } while (0);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- }
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY, SPEC(RETVAL))
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
- fast_long_decrement_function(var_ptr);
- if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
- ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
- }
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_pre_dec_helper);
- }
- ZEND_VM_HELPER(zend_post_inc_helper, VAR|CV, ANY)
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- SAVE_OPLINE();
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
- ZVAL_NULL(var_ptr);
- ZVAL_UNDEFINED_OP1();
- }
- do {
- if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
- zend_reference *ref = Z_REF_P(var_ptr);
- var_ptr = Z_REFVAL_P(var_ptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- increment_function(var_ptr);
- } while (0);
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
- fast_long_increment_function(var_ptr);
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_post_inc_helper);
- }
- ZEND_VM_HELPER(zend_post_dec_helper, VAR|CV, ANY)
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- SAVE_OPLINE();
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
- ZVAL_NULL(var_ptr);
- ZVAL_UNDEFINED_OP1();
- }
- do {
- if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_REFERENCE)) {
- zend_reference *ref = Z_REF_P(var_ptr);
- var_ptr = Z_REFVAL_P(var_ptr);
- if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) {
- zend_incdec_typed_ref(ref, EX_VAR(opline->result.var) OPLINE_CC EXECUTE_DATA_CC);
- break;
- }
- }
- ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
- decrement_function(var_ptr);
- } while (0);
- FREE_OP1_VAR_PTR();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HOT_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
- {
- USE_OPLINE
- zval *var_ptr;
- var_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_RW);
- if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
- ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
- fast_long_decrement_function(var_ptr);
- ZEND_VM_NEXT_OPCODE();
- }
- ZEND_VM_DISPATCH_TO_HELPER(zend_post_dec_helper);
- }
- ZEND_VM_HANDLER(136, ZEND_ECHO, CONST|TMPVAR|CV, ANY)
- {
- USE_OPLINE
- zval *z;
- SAVE_OPLINE();
- z = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (Z_TYPE_P(z) == IS_STRING) {
- zend_string *str = Z_STR_P(z);
- if (ZSTR_LEN(str) != 0) {
- zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
- }
- } else {
- zend_string *str = zval_get_string_func(z);
- if (ZSTR_LEN(str) != 0) {
- zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
- } else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
- ZVAL_UNDEFINED_OP1();
- }
- zend_string_release_ex(str, 0);
- }
- FREE_OP1();
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HELPER(zend_fetch_var_address_helper, CONST|TMPVAR|CV, UNUSED, int type)
- {
- USE_OPLINE
- zval *varname;
- zval *retval;
- zend_string *name, *tmp_name;
- HashTable *target_symbol_table;
- SAVE_OPLINE();
- varname = GET_OP1_ZVAL_PTR_UNDEF(BP_VAR_R);
- if (OP1_TYPE == IS_CONST) {
- name = Z_STR_P(varname);
- } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) {
- name = Z_STR_P(varname);
- tmp_name = NULL;
- } else {
- if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) {
- ZVAL_UNDEFINED_OP1();
- }
- name = zval_try_get_tmp_string(varname, &tmp_name);
- if (UNEXPECTED(!name)) {
- FREE_OP1();
- ZVAL_UNDEF(EX_VAR(opline->result.var));
- HANDLE_EXCEPTION();
- }
- }
- target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC);
- retval = zend_hash_find_ex(target_symbol_table, name, OP1_TYPE == IS_CONST);
- if (retval == NULL) {
- if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
- ZEND_VM_C_LABEL(fetch_this):
- zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC);
- if (OP1_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- if (type == BP_VAR_W) {
- retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval));
- } else if (type == BP_VAR_IS) {
- retval = &EG(uninitialized_zval);
- } else {
- zend_error(E_WARNING, "Undefined variable $%s", ZSTR_VAL(name));
- if (type == BP_VAR_RW) {
- retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval));
- } else {
- retval = &EG(uninitialized_zval);
- }
- }
- /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
- } else if (Z_TYPE_P(retval) == IS_INDIRECT) {
- retval = Z_INDIRECT_P(retval);
- if (Z_TYPE_P(retval) == IS_UNDEF) {
- if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) {
- ZEND_VM_C_GOTO(fetch_this);
- }
- if (type == BP_VAR_W) {
- ZVAL_NULL(retval);
- } else if (type == BP_VAR_IS) {
- retval = &EG(uninitialized_zval);
- } else {
- zend_error(E_WARNING, "Undefined variable $%s", ZSTR_VAL(name));
- if (type == BP_VAR_RW) {
- ZVAL_NULL(retval);
- } else {
- retval = &EG(uninitialized_zval);
- }
- }
- }
- }
- if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) {
- FREE_OP1();
- }
- if (OP1_TYPE != IS_CONST) {
- zend_tmp_string_release(tmp_name);
- }
- ZEND_ASSERT(retval != NULL);
- if (type == BP_VAR_R || type == BP_VAR_IS) {
- ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval);
- } else {
- ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
- }
- ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
- }
- ZEND_VM_HANDLER(80, ZEND_FETCH_R, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
- {
- ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_R);
- }
- ZEND_VM_HANDLER(83, ZEND_FETCH_W, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
- {
- ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_W);
- }
- ZEND_VM_HANDLER(86, ZEND_FETCH_RW, CONST|TMPVAR|CV, UNUSED, VAR_FETCH)
- {
- ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper, type, BP_VAR_RW);
- }
- ZEND_VM_HANDLER(…
Large files files are truncated, but you can click here to view the full file