Fixed bug #65969 (Chain assignment with T_LIST failure)

diff --git a/NEWS b/NEWS
index 2514027710928b62b271fef1e0f6dba6107f11bf..ac573154699ca75392e3879078e4ee0fcad364da 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -7,6 +7,7 @@ PHP                                                                        NEWS
 - Core:
   . Fixed bug #66094 (unregister_tick_function tries to cast a Closure to a 
     string). (Laruence)
+  . Fixed bug #65969 (Chain assignment with T_LIST failure). (Dmitry)
   . Fixed bug #65947 (basename is no more working after fgetcsv in certain 
     situation). (Laruence)
 

diff --git a/Zend/tests/bug65969.phpt b/Zend/tests/bug65969.phpt
new file mode 100644 (file)
index 0000000..d512832
--- /dev/null
+++ b/Zend/tests/bug65969.phpt
@@ -0,0 +1,10 @@
+--TEST--
+Bug #65969 (Chain assignment with T_LIST failure)
+--FILE--
+<?php
+$obj = new stdClass;
+list($a,$b) = $obj->prop = [1,2];
+var_dump($a,$b);
+--EXPECT--
+int(1)
+int(2)

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index ff9c2d0de2ae36da66ea048f7b5ef7be9bf2d91e..0b6aff224f5da2a360a726d7b1e564c52be2d727 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1248,9 +1248,8 @@ convert_to_array:
        }
 }
 
-static void zend_fetch_dimension_address_read(temp_variable *result, zval **container_ptr, zval *dim, int dim_type, int type TSRMLS_DC)
+static void zend_fetch_dimension_address_read(temp_variable *result, zval *container, zval *dim, int dim_type, int type TSRMLS_DC)
 {
-       zval *container = *container_ptr;
        zval **retval;
 
        switch (Z_TYPE_P(container)) {

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index f6c6e6ac585c095bb71f7dc5a2ead2f0d6fde3bc..b28cd51291a753f68e0fde6222e5a4a3a081759f 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1166,19 +1166,17 @@ ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, VAR|CV, CONST|TMP|VAR|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           OP1_TYPE != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (OP1_TYPE == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
+       container = GET_OP1_ZVAL_PTR(BP_VAR_R);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
        FREE_OP2();
-       FREE_OP1_VAR_PTR();
+       FREE_OP1();
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -1243,13 +1241,13 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_IS);
+       container = GET_OP1_ZVAL_PTR(BP_VAR_IS);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_IS TSRMLS_CC);
        FREE_OP2();
-       FREE_OP1_VAR_PTR();
+       FREE_OP1();
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -1258,12 +1256,12 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+               zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+
                if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -1271,15 +1269,19 @@ ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+               FREE_OP2();
+               FREE_OP1_VAR_PTR();
        } else {
+               zval *container;
+
                if (OP2_TYPE == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
+               container = GET_OP1_ZVAL_PTR(BP_VAR_R);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+               FREE_OP2();
+               FREE_OP1();
        }
-       FREE_OP2();
-       FREE_OP1_VAR_PTR();
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 64d4320f9afef801232ea2a640824949bdc82353..c606b8819d867ca6c6f72348a7bbfd773d4a7535 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -12874,16 +12874,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_VAR != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -12951,10 +12949,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -12966,12 +12964,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
                if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -12979,15 +12977,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        } else {
+               zval *container;
+
                if (IS_CONST == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
-       }
 
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -15048,16 +15050,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_VAR != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -15125,10 +15125,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -15140,12 +15140,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
                if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -15153,15 +15153,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+               zval_dtor(free_op2.var);
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        } else {
+               zval *container;
+
                if (IS_TMP_VAR == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+               zval_dtor(free_op2.var);
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        }
-       zval_dtor(free_op2.var);
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -17132,16 +17136,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_VAR != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -17209,10 +17211,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -17224,12 +17226,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
                if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -17237,15 +17239,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+               if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        } else {
+               zval *container;
+
                if (IS_VAR == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
+               if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        }
-       if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -19007,12 +19013,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_O
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
                if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -19020,15 +19026,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_O
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        } else {
+               zval *container;
+
                if (IS_UNUSED == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
-       }
 
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -20257,16 +20267,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_VAR != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_VAR == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -20334,10 +20342,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+       container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
@@ -20349,12 +20357,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+
                if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -20362,15 +20370,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
        } else {
+               zval *container;
+
                if (IS_CV == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
+               container = _get_zval_ptr_var(opline->op1.var, EX_Ts(), &free_op1 TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
-       }
 
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+               if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -28692,16 +28704,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 {
        USE_OPLINE
 
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_CV != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
 
@@ -28768,10 +28778,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 {
        USE_OPLINE
 
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
 
 
@@ -28783,12 +28793,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+
                if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -28796,15 +28806,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+
+
        } else {
+               zval *container;
+
                if (IS_CONST == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
-       }
 
 
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -30641,16 +30655,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
        zend_free_op free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_CV != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
        zval_dtor(free_op2.var);
 
@@ -30717,10 +30729,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 {
        USE_OPLINE
        zend_free_op free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
        zval_dtor(free_op2.var);
 
@@ -30732,12 +30744,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+
                if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -30745,15 +30757,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+               zval_dtor(free_op2.var);
+
        } else {
+               zval *container;
+
                if (IS_TMP_VAR == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-       }
-       zval_dtor(free_op2.var);
+               zval_dtor(free_op2.var);
 
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -32594,16 +32610,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
        zend_free_op free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_CV != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
@@ -32670,10 +32684,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 {
        USE_OPLINE
        zend_free_op free_op2;
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
        if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
@@ -32685,12 +32699,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD
 {
        USE_OPLINE
        zend_free_op free_op1, free_op2;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+
                if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -32698,15 +32712,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+               if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+
        } else {
+               zval *container;
+
                if (IS_VAR == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, EX_Ts(), &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-       }
-       if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
+               if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
 
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -34336,12 +34354,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OP
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+
                if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -34349,15 +34367,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OP
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+
+
        } else {
+               zval *container;
+
                if (IS_UNUSED == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
-       }
 
 
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }
@@ -35446,16 +35468,14 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
        USE_OPLINE
 
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
 
-       if ((opline->extended_value & ZEND_FETCH_ADD_LOCK) &&
-           IS_CV != IS_CV &&
-           EX_T(opline->op1.var).var.ptr_ptr) {
-               PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+       if (IS_CV == IS_VAR && (opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
+               PZVAL_LOCK(EX_T(opline->op1.var).var.ptr);
        }
-       container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
 
 
@@ -35522,10 +35542,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 {
        USE_OPLINE
 
-       zval **container;
+       zval *container;
 
        SAVE_OPLINE();
-       container = _get_zval_ptr_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
+       container = _get_zval_ptr_cv_BP_VAR_IS(EX_CVs(), opline->op1.var TSRMLS_CC);
        zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
 
 
@@ -35537,12 +35557,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
 {
        USE_OPLINE
        zend_free_op free_op1;
-       zval **container;
 
        SAVE_OPLINE();
 
        if (ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), (opline->extended_value & ZEND_FETCH_ARG_MASK))) {
-               container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+               zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(EX_CVs(), opline->op1.var TSRMLS_CC);
+
                if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
                }
@@ -35550,15 +35570,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
                }
+
+
        } else {
+               zval *container;
+
                if (IS_CV == IS_UNUSED) {
                        zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
                }
-               container = _get_zval_ptr_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
+               container = _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op1.var TSRMLS_CC);
                zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(EX_CVs(), opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
-       }
 
 
+       }
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
 }