Small optimization of ZEND_INIT_ARRAY/ZEND_ADD_ARRAY_ELEMENT. (Nuno, Dmitry)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 884a0ece7b6763e1bbdb885f51b9e0318780594e..79bf6034087a50e3f3ecfbc1cbbafad9f94e170a 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -2610,7 +2610,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, CONST|UNUSED, CONST)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
+ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
        zend_op *opline = EX(opline);
        zend_free_op free_op1, free_op2;
@@ -2631,12 +2631,6 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
        expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (IS_OP1_TMP_FREE()) { /* temporary variable */
                zval *new_expr;
 
@@ -2697,7 +2691,16 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|V
 
 ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-       ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (OP1_TYPE == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if !defined(ZEND_VM_SPEC) || OP1_TYPE != IS_UNUSED
+       } else {
+               ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ADD_ARRAY_ELEMENT);
+#endif
+       }
 }
 
 ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 132f3683bb321ab781625af684e4d0183793a1a8..f3039acaabc9928aa2234f35fc89c5b3e92254ef 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2670,12 +2670,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        expr_ptr=&opline->op1.u.constant;
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -2736,7 +2730,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 static int ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CONST == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CONST != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -3026,12 +3029,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        expr_ptr=&opline->op1.u.constant;
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -3092,7 +3089,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 static int ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CONST == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CONST != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -3382,12 +3388,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        expr_ptr=&opline->op1.u.constant;
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -3448,7 +3448,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 static int ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CONST == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CONST != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -3472,12 +3481,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
        expr_ptr=&opline->op1.u.constant;
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -3538,7 +3541,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 
 static int ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CONST == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CONST != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -3827,12 +3839,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        expr_ptr=&opline->op1.u.constant;
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -3893,7 +3899,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 static int ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CONST == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CONST != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -5270,12 +5285,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (1) { /* temporary variable */
                zval *new_expr;
 
@@ -5336,7 +5345,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 static int ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_TMP_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_TMP_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -5709,12 +5727,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (1) { /* temporary variable */
                zval *new_expr;
 
@@ -5775,7 +5787,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_TMP_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_TMP_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6148,12 +6169,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (1) { /* temporary variable */
                zval *new_expr;
 
@@ -6214,7 +6229,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_TMP_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_TMP_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6238,12 +6262,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
        expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (1) { /* temporary variable */
                zval *new_expr;
 
@@ -6304,7 +6322,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
 
 static int ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_TMP_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_TMP_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6674,12 +6701,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (1) { /* temporary variable */
                zval *new_expr;
 
@@ -6740,7 +6761,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_TMP_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_TMP_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -9255,12 +9285,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -9321,7 +9345,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 static int ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -10738,12 +10771,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -10804,7 +10831,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12259,12 +12295,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -12325,7 +12355,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -12953,12 +12992,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
        expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -13019,7 +13052,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_AR
 
 static int ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -14206,12 +14248,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -14272,7 +14308,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_VAR == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_VAR != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15349,94 +15394,18 @@ static int ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
 
-       zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr;
-       zval *offset=&opline->op2.u.constant;
-
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-       zval **expr_ptr_ptr = NULL;
-
-       if (opline->extended_value) {
-               expr_ptr_ptr=NULL;
-               expr_ptr = *expr_ptr_ptr;
-       } else {
-               expr_ptr=NULL;
-       }
-#else
-       expr_ptr=NULL;
-#endif
-
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
-       if (0) { /* temporary variable */
-               zval *new_expr;
-
-               ALLOC_ZVAL(new_expr);
-               INIT_PZVAL_COPY(new_expr, expr_ptr);
-               expr_ptr = new_expr;
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_UNUSED == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_UNUSED != IS_UNUSED
        } else {
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-               if (opline->extended_value) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-                       expr_ptr = *expr_ptr_ptr;
-                       expr_ptr->refcount++;
-               } else
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 #endif
-               if (PZVAL_IS_REF(expr_ptr)) {
-                       zval *new_expr;
-
-                       ALLOC_ZVAL(new_expr);
-                       INIT_PZVAL_COPY(new_expr, expr_ptr);
-                       expr_ptr = new_expr;
-                       zendi_zval_copy_ctor(*expr_ptr);
-               } else {
-                       expr_ptr->refcount++;
-               }
-       }
-       if (offset) {
-               switch (Z_TYPE_P(offset)) {
-                       case IS_DOUBLE:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_LONG:
-                       case IS_BOOL:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_STRING:
-                               zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_NULL:
-                               zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       default:
-                               zend_error(E_WARNING, "Illegal offset type");
-                               zval_ptr_dtor(&expr_ptr);
-                               /* do nothing */
-                               break;
-               }
-
-       } else {
-               zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
        }
-       if (opline->extended_value) {
-
-       } else {
-
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
 static int ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -16389,95 +16358,19 @@ static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-       zend_free_op free_op2;
-       zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr;
-       zval *offset=_get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-       zval **expr_ptr_ptr = NULL;
 
-       if (opline->extended_value) {
-               expr_ptr_ptr=NULL;
-               expr_ptr = *expr_ptr_ptr;
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_UNUSED == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_UNUSED != IS_UNUSED
        } else {
-               expr_ptr=NULL;
-       }
-#else
-       expr_ptr=NULL;
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 #endif
-
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
        }
-       if (0) { /* temporary variable */
-               zval *new_expr;
-
-               ALLOC_ZVAL(new_expr);
-               INIT_PZVAL_COPY(new_expr, expr_ptr);
-               expr_ptr = new_expr;
-       } else {
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-               if (opline->extended_value) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-                       expr_ptr = *expr_ptr_ptr;
-                       expr_ptr->refcount++;
-               } else
-#endif
-               if (PZVAL_IS_REF(expr_ptr)) {
-                       zval *new_expr;
-
-                       ALLOC_ZVAL(new_expr);
-                       INIT_PZVAL_COPY(new_expr, expr_ptr);
-                       expr_ptr = new_expr;
-                       zendi_zval_copy_ctor(*expr_ptr);
-               } else {
-                       expr_ptr->refcount++;
-               }
-       }
-       if (offset) {
-               switch (Z_TYPE_P(offset)) {
-                       case IS_DOUBLE:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_LONG:
-                       case IS_BOOL:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_STRING:
-                               zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_NULL:
-                               zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       default:
-                               zend_error(E_WARNING, "Illegal offset type");
-                               zval_ptr_dtor(&expr_ptr);
-                               /* do nothing */
-                               break;
-               }
-               zval_dtor(free_op2.var);
-       } else {
-               zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
-       }
-       if (opline->extended_value) {
-
-       } else {
-
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
+}
 
 static int ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
@@ -17429,94 +17322,18 @@ static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
-       zend_free_op free_op2;
-       zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr;
-       zval *offset=_get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-       zval **expr_ptr_ptr = NULL;
-
-       if (opline->extended_value) {
-               expr_ptr_ptr=NULL;
-               expr_ptr = *expr_ptr_ptr;
-       } else {
-               expr_ptr=NULL;
-       }
-#else
-       expr_ptr=NULL;
-#endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
-       if (0) { /* temporary variable */
-               zval *new_expr;
-
-               ALLOC_ZVAL(new_expr);
-               INIT_PZVAL_COPY(new_expr, expr_ptr);
-               expr_ptr = new_expr;
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_UNUSED == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_UNUSED != IS_UNUSED
        } else {
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-               if (opline->extended_value) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-                       expr_ptr = *expr_ptr_ptr;
-                       expr_ptr->refcount++;
-               } else
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 #endif
-               if (PZVAL_IS_REF(expr_ptr)) {
-                       zval *new_expr;
-
-                       ALLOC_ZVAL(new_expr);
-                       INIT_PZVAL_COPY(new_expr, expr_ptr);
-                       expr_ptr = new_expr;
-                       zendi_zval_copy_ctor(*expr_ptr);
-               } else {
-                       expr_ptr->refcount++;
-               }
-       }
-       if (offset) {
-               switch (Z_TYPE_P(offset)) {
-                       case IS_DOUBLE:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_LONG:
-                       case IS_BOOL:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_STRING:
-                               zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_NULL:
-                               zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       default:
-                               zend_error(E_WARNING, "Illegal offset type");
-                               zval_ptr_dtor(&expr_ptr);
-                               /* do nothing */
-                               break;
-               }
-               if (free_op2.var) {zval_ptr_dtor(&free_op2.var);};
-       } else {
-               zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
        }
-       if (opline->extended_value) {
-
-       } else {
-
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
 static int ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -18029,94 +17846,18 @@ static int ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
        return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
-static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
 
-       zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr;
-       zval *offset=NULL;
-
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-       zval **expr_ptr_ptr = NULL;
-
-       if (opline->extended_value) {
-               expr_ptr_ptr=NULL;
-               expr_ptr = *expr_ptr_ptr;
-       } else {
-               expr_ptr=NULL;
-       }
-#else
-       expr_ptr=NULL;
-#endif
-
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
-       if (0) { /* temporary variable */
-               zval *new_expr;
-
-               ALLOC_ZVAL(new_expr);
-               INIT_PZVAL_COPY(new_expr, expr_ptr);
-               expr_ptr = new_expr;
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_UNUSED == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_UNUSED != IS_UNUSED
        } else {
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-               if (opline->extended_value) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-                       expr_ptr = *expr_ptr_ptr;
-                       expr_ptr->refcount++;
-               } else
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 #endif
-               if (PZVAL_IS_REF(expr_ptr)) {
-                       zval *new_expr;
-
-                       ALLOC_ZVAL(new_expr);
-                       INIT_PZVAL_COPY(new_expr, expr_ptr);
-                       expr_ptr = new_expr;
-                       zendi_zval_copy_ctor(*expr_ptr);
-               } else {
-                       expr_ptr->refcount++;
-               }
        }
-       if (offset) {
-               switch (Z_TYPE_P(offset)) {
-                       case IS_DOUBLE:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_LONG:
-                       case IS_BOOL:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_STRING:
-                               zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_NULL:
-                               zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       default:
-                               zend_error(E_WARNING, "Illegal offset type");
-                               zval_ptr_dtor(&expr_ptr);
-                               /* do nothing */
-                               break;
-               }
-
-       } else {
-               zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
-       }
-       if (opline->extended_value) {
-
-       } else {
-
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
 static int zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
@@ -18809,94 +18550,18 @@ static int ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
 
-       zval *array_ptr = &EX_T(opline->result.u.var).tmp_var;
-       zval *expr_ptr;
-       zval *offset=_get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
-
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-       zval **expr_ptr_ptr = NULL;
-
-       if (opline->extended_value) {
-               expr_ptr_ptr=NULL;
-               expr_ptr = *expr_ptr_ptr;
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_UNUSED == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_UNUSED != IS_UNUSED
        } else {
-               expr_ptr=NULL;
-       }
-#else
-       expr_ptr=NULL;
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 #endif
-
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
        }
-       if (0) { /* temporary variable */
-               zval *new_expr;
-
-               ALLOC_ZVAL(new_expr);
-               INIT_PZVAL_COPY(new_expr, expr_ptr);
-               expr_ptr = new_expr;
-       } else {
-#if 0 || IS_UNUSED == IS_VAR || IS_UNUSED == IS_CV
-               if (opline->extended_value) {
-                       SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-                       expr_ptr = *expr_ptr_ptr;
-                       expr_ptr->refcount++;
-               } else
-#endif
-               if (PZVAL_IS_REF(expr_ptr)) {
-                       zval *new_expr;
-
-                       ALLOC_ZVAL(new_expr);
-                       INIT_PZVAL_COPY(new_expr, expr_ptr);
-                       expr_ptr = new_expr;
-                       zendi_zval_copy_ctor(*expr_ptr);
-               } else {
-                       expr_ptr->refcount++;
-               }
-       }
-       if (offset) {
-               switch (Z_TYPE_P(offset)) {
-                       case IS_DOUBLE:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), (long) Z_DVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_LONG:
-                       case IS_BOOL:
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), Z_LVAL_P(offset), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_STRING:
-                               zend_symtable_update(Z_ARRVAL_P(array_ptr), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       case IS_NULL:
-                               zend_hash_update(Z_ARRVAL_P(array_ptr), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
-                               break;
-                       default:
-                               zend_error(E_WARNING, "Illegal offset type");
-                               zval_ptr_dtor(&expr_ptr);
-                               /* do nothing */
-                               break;
-               }
-
-       } else {
-               zend_hash_next_index_insert(Z_ARRVAL_P(array_ptr), &expr_ptr, sizeof(zval *), NULL);
-       }
-       if (opline->extended_value) {
-
-       } else {
-
-       }
-       ZEND_VM_NEXT_OPCODE();
-}
-
-static int ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
 static int ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -21505,12 +21170,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -21571,7 +21230,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 static int ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CV == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CV != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -22980,12 +22648,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -23046,7 +22708,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CV == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CV != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -24492,12 +24163,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -24558,7 +24223,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CV == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CV != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -25181,12 +24855,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
        expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -25247,7 +24915,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 static int ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CV == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CV != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -26429,12 +26106,6 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        expr_ptr=_get_zval_ptr_cv(&opline->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
 #endif
 
-       if (opline->opcode == ZEND_INIT_ARRAY) {
-               array_init(array_ptr);
-               if (!expr_ptr) {
-                       ZEND_VM_NEXT_OPCODE();
-               }
-       }
        if (0) { /* temporary variable */
                zval *new_expr;
 
@@ -26495,7 +26166,16 @@ static int ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 static int ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-       return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+       zend_op *opline = EX(opline);
+
+       array_init(&EX_T(opline->result.u.var).tmp_var);
+       if (IS_CV == IS_UNUSED) {
+               ZEND_VM_NEXT_OPCODE();
+#if 0 || IS_CV != IS_UNUSED
+       } else {
+               return ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+#endif
+       }
 }
 
 static int ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -28581,11 +28261,11 @@ void zend_init_opcodes_handlers()
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER,
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER,
        ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER,
-       ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CONST_HANDLER,
-       ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_TMP_HANDLER,
-       ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_VAR_HANDLER,
-       ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_UNUSED_HANDLER,
-       ZEND_ADD_ARRAY_ELEMENT_SPEC_UNUSED_CV_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER,
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER,
        ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER,