Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW...

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 67043fa4481034c019e11929979f7faa0fee91a0..8fe5362870b14036c2b59d717bda8843f4e29b0c 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -989,24 +989,14 @@ void zend_do_free(znode *op1 TSRMLS_DC)
                while (opline->opcode == ZEND_END_SILENCE || opline->opcode == ZEND_EXT_FCALL_END || opline->opcode == ZEND_OP_DATA) {
                        opline--;
                }
-               if (opline->result.op_type == op1->op_type
+               if (opline->result.op_type == IS_VAR
                        && opline->result.u.var == op1->u.var) {
                        opline->result.u.EA.type |= EXT_TYPE_UNUSED;
                } else {
                        while (opline>CG(active_op_array)->opcodes) {
-                               /* This should be an object instantiation
-                                * Find JMP_NO_CTOR, mark the preceding ASSIGN and the
-                                * proceeding INIT_FCALL_BY_NAME as unused
-                                */
-                               if (opline->opcode == ZEND_JMP_NO_CTOR &&
-                                   opline->op1.u.var == op1->u.var) {
-                                       opline->op1.u.EA.type |= EXT_TYPE_UNUSED;
-                                       (opline-1)->result.u.EA.type |= EXT_TYPE_UNUSED;
-                                       (opline+1)->op1.u.EA.type |= EXT_TYPE_UNUSED;
-                                       break;
-                               } else if (opline->opcode == ZEND_FETCH_DIM_R
-                                                       && opline->op1.op_type == IS_VAR
-                                                       && opline->op1.u.var == op1->u.var) {
+                               if (opline->opcode == ZEND_FETCH_DIM_R
+                                   && opline->op1.op_type == IS_VAR
+                                   && opline->op1.u.var == op1->u.var) {
                                        /* This should the end of a list() construct
                                         * Mark its result as unused
                                         */
@@ -1014,6 +1004,9 @@ void zend_do_free(znode *op1 TSRMLS_DC)
                                        break;
                                } else if (opline->result.op_type==IS_VAR
                                        && opline->result.u.var == op1->u.var) {
+                                       if (opline->opcode == ZEND_NEW) {
+                                               opline->result.u.EA.type |= EXT_TYPE_UNUSED;
+                                       }
                                        break;
                                }
                                opline--;
@@ -2935,25 +2928,16 @@ void zend_do_pop_object(znode *object TSRMLS_DC)
 
 void zend_do_begin_new_object(znode *new_token, znode *class_type TSRMLS_DC)
 {
-       zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+       zend_op *opline;
        unsigned char *ptr = NULL;
        
+       new_token->u.opline_num = get_next_op_number(CG(active_op_array));
+       opline = get_next_op(CG(active_op_array) TSRMLS_CC);
        opline->opcode = ZEND_NEW;
        opline->result.op_type = IS_VAR;
        opline->result.u.var = get_temporary_variable(CG(active_op_array));
        opline->op1 = *class_type;
        SET_UNUSED(opline->op2);
-
-       new_token->u.opline_num = get_next_op_number(CG(active_op_array));
-       opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-       opline->opcode = ZEND_JMP_NO_CTOR;
-       opline->op1 = (opline-1)->result;
-       SET_UNUSED(opline->op2);
-
-       opline = get_next_op(CG(active_op_array) TSRMLS_CC);
-       opline->opcode = ZEND_INIT_CTOR_CALL;
-       opline->op1 = (opline-2)->result;
-       SET_UNUSED(opline->op2);
        
        zend_stack_push(&CG(function_call_stack), (void *) &ptr, sizeof(unsigned char *));
 }
@@ -2967,7 +2951,7 @@ void zend_do_end_new_object(znode *result, znode *new_token, znode *argument_lis
        zend_do_free(&ctor_result TSRMLS_CC);
 
        CG(active_op_array)->opcodes[new_token->u.opline_num].op2.u.opline_num = get_next_op_number(CG(active_op_array));
-       *result = CG(active_op_array)->opcodes[new_token->u.opline_num].op1;
+       *result = CG(active_op_array)->opcodes[new_token->u.opline_num].result;
 }
 
 void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode TSRMLS_DC)

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 748a9cbab2596fade9cb0f5b9472d372f41996d8..e8d5e71c59226010f060efd3818e2ec0dbf60edf 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1605,35 +1605,6 @@ ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(111, ZEND_INIT_CTOR_CALL, TMP|VAR|CV, ANY)
-{
-       zend_op *opline = EX(opline);
-       zend_free_op free_op1;
-
-       zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
-
-       if (OP1_TYPE == IS_VAR) {
-               SELECTIVE_PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr, &opline->op1);
-       }
-
-       /* We are not handling overloaded classes right now */
-       EX(object) = GET_OP1_ZVAL_PTR(BP_VAR_R);
-
-       /* New always returns the object as is_ref=0, therefore, we can just increment the reference count */
-       EX(object)->refcount++; /* For $this pointer */
-
-       EX(fbc) = EX(fbc_constructor);
-
-       if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
-               EX(calling_scope) = EX(fbc)->common.scope;
-       } else {
-               EX(calling_scope) = NULL;
-       }
-
-       FREE_OP1_IF_VAR();
-       ZEND_VM_NEXT_OPCODE();
-}
-
 ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
        zend_op *opline = EX(opline);
@@ -2396,6 +2367,8 @@ ZEND_VM_HANDLER(49, ZEND_SWITCH_FREE, TMP|VAR, ANY)
 ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
 {
        zend_op *opline = EX(opline);
+       zval *object_zval;
+       zend_function *constructor;
 
        if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
                char *class_type;
@@ -2407,13 +2380,43 @@ ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
                }
                zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type,  EX_T(opline->op1.u.var).class_entry->name);
        }
-       EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-       ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-       object_init_ex(EX_T(opline->result.u.var).var.ptr, EX_T(opline->op1.u.var).class_entry);
-       EX_T(opline->result.u.var).var.ptr->refcount=1;
-       EX_T(opline->result.u.var).var.ptr->is_ref=0;
+       ALLOC_ZVAL(object_zval);
+       object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
+       INIT_PZVAL(object_zval);
 
-       ZEND_VM_NEXT_OPCODE();
+       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
+
+       if (constructor == NULL) {
+               EX(fbc_constructor) = NULL;
+               if (RETURN_VALUE_USED(opline)) {
+                       EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+                       EX_T(opline->result.u.var).var.ptr = object_zval;
+               } else {
+                       zval_ptr_dtor(&object_zval);
+               }
+               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
+               ZEND_VM_CONTINUE_JMP();
+       } else {
+               EX(fbc_constructor) = constructor;
+
+               SELECTIVE_PZVAL_LOCK(object_zval, &opline->result);
+               EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+               EX_T(opline->result.u.var).var.ptr = object_zval;
+               
+               zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
+
+               /* We are not handling overloaded classes right now */
+               EX(object) = object_zval;
+
+               EX(fbc) = EX(fbc_constructor);
+
+               if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
+                       EX(calling_scope) = EX(fbc)->common.scope;
+               } else {
+                       EX(calling_scope) = NULL;
+               }
+               ZEND_VM_NEXT_OPCODE();
+       }
 }
 
 ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
@@ -3174,34 +3177,6 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
        ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(69, ZEND_JMP_NO_CTOR, TMP|VAR|CV, ANY)
-{
-       zend_op *opline = EX(opline);
-       zval *object_zval;
-       zend_function *constructor;
-       zend_free_op free_op1;
-
-       if (OP1_TYPE == IS_VAR) {
-               PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
-       }
-
-       object_zval = GET_OP1_ZVAL_PTR(BP_VAR_R);
-       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
-
-       EX(fbc_constructor) = NULL;
-       if (constructor == NULL) {
-               if(opline->op1.u.EA.type & EXT_TYPE_UNUSED) {
-                       zval_ptr_dtor(EX_T(opline->op1.u.var).var.ptr_ptr);
-               }
-               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
-               ZEND_VM_CONTINUE_JMP();
-       } else {
-               EX(fbc_constructor) = constructor;
-       }
-
-       ZEND_VM_NEXT_OPCODE();
-}
-
 ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, ANY)
 {
        zend_op *opline = EX(opline);

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index fe9013517ed4a61ef4c3ac0660c8334dd8bb8b49..cdc4adbd07294667682d3435960e3b07635a56d9 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -357,6 +357,8 @@ static int ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
+       zval *object_zval;
+       zend_function *constructor;
 
        if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
                char *class_type;
@@ -368,13 +370,43 @@ static int ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                }
                zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type,  EX_T(opline->op1.u.var).class_entry->name);
        }
-       EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-       ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-       object_init_ex(EX_T(opline->result.u.var).var.ptr, EX_T(opline->op1.u.var).class_entry);
-       EX_T(opline->result.u.var).var.ptr->refcount=1;
-       EX_T(opline->result.u.var).var.ptr->is_ref=0;
+       ALLOC_ZVAL(object_zval);
+       object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
+       INIT_PZVAL(object_zval);
 
-       ZEND_VM_NEXT_OPCODE();
+       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
+
+       if (constructor == NULL) {
+               EX(fbc_constructor) = NULL;
+               if (RETURN_VALUE_USED(opline)) {
+                       EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+                       EX_T(opline->result.u.var).var.ptr = object_zval;
+               } else {
+                       zval_ptr_dtor(&object_zval);
+               }
+               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
+               ZEND_VM_CONTINUE_JMP();
+       } else {
+               EX(fbc_constructor) = constructor;
+
+               SELECTIVE_PZVAL_LOCK(object_zval, &opline->result);
+               EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+               EX_T(opline->result.u.var).var.ptr = object_zval;
+               
+               zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
+
+               /* We are not handling overloaded classes right now */
+               EX(object) = object_zval;
+
+               EX(fbc) = EX(fbc_constructor);
+
+               if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
+                       EX(calling_scope) = EX(fbc)->common.scope;
+               } else {
+                       EX(calling_scope) = NULL;
+               }
+               ZEND_VM_NEXT_OPCODE();
+       }
 }
 
 static int ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -3950,35 +3982,6 @@ static int ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_INIT_CTOR_CALL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zend_free_op free_op1;
-
-       zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
-
-       if (IS_TMP_VAR == IS_VAR) {
-               SELECTIVE_PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr, &opline->op1);
-       }
-
-       /* We are not handling overloaded classes right now */
-       EX(object) = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
-
-       /* New always returns the object as is_ref=0, therefore, we can just increment the reference count */
-       EX(object)->refcount++; /* For $this pointer */
-
-       EX(fbc) = EX(fbc_constructor);
-
-       if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
-               EX(calling_scope) = EX(fbc)->common.scope;
-       } else {
-               EX(calling_scope) = NULL;
-       }
-
-       ;
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -4482,34 +4485,6 @@ static int ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        }
 }
 
-static int ZEND_JMP_NO_CTOR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zval *object_zval;
-       zend_function *constructor;
-       zend_free_op free_op1;
-
-       if (IS_TMP_VAR == IS_VAR) {
-               PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
-       }
-
-       object_zval = _get_zval_ptr_tmp(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
-       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
-
-       EX(fbc_constructor) = NULL;
-       if (constructor == NULL) {
-               if(opline->op1.u.EA.type & EXT_TYPE_UNUSED) {
-                       zval_ptr_dtor(EX_T(opline->op1.u.var).var.ptr_ptr);
-               }
-               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
-               ZEND_VM_CONTINUE_JMP();
-       } else {
-               EX(fbc_constructor) = constructor;
-       }
-
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -6939,35 +6914,6 @@ static int ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_INIT_CTOR_CALL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zend_free_op free_op1;
-
-       zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
-
-       if (IS_VAR == IS_VAR) {
-               SELECTIVE_PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr, &opline->op1);
-       }
-
-       /* We are not handling overloaded classes right now */
-       EX(object) = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
-
-       /* New always returns the object as is_ref=0, therefore, we can just increment the reference count */
-       EX(object)->refcount++; /* For $this pointer */
-
-       EX(fbc) = EX(fbc_constructor);
-
-       if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
-               EX(calling_scope) = EX(fbc)->common.scope;
-       } else {
-               EX(calling_scope) = NULL;
-       }
-
-       if (free_op1.var) {zval_ptr_dtor(&free_op1.var);};
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -7724,34 +7670,6 @@ static int ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_JMP_NO_CTOR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zval *object_zval;
-       zend_function *constructor;
-       zend_free_op free_op1;
-
-       if (IS_VAR == IS_VAR) {
-               PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
-       }
-
-       object_zval = _get_zval_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
-       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
-
-       EX(fbc_constructor) = NULL;
-       if (constructor == NULL) {
-               if(opline->op1.u.EA.type & EXT_TYPE_UNUSED) {
-                       zval_ptr_dtor(EX_T(opline->op1.u.var).var.ptr_ptr);
-               }
-               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
-               ZEND_VM_CONTINUE_JMP();
-       } else {
-               EX(fbc_constructor) = constructor;
-       }
-
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -19003,35 +18921,6 @@ static int ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_INIT_CTOR_CALL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zend_free_op free_op1;
-
-       zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
-
-       if (IS_CV == IS_VAR) {
-               SELECTIVE_PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr, &opline->op1);
-       }
-
-       /* We are not handling overloaded classes right now */
-       EX(object) = _get_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC);
-
-       /* New always returns the object as is_ref=0, therefore, we can just increment the reference count */
-       EX(object)->refcount++; /* For $this pointer */
-
-       EX(fbc) = EX(fbc_constructor);
-
-       if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
-               EX(calling_scope) = EX(fbc)->common.scope;
-       } else {
-               EX(calling_scope) = NULL;
-       }
-
-       ;
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -19639,34 +19528,6 @@ static int ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        }
 }
 
-static int ZEND_JMP_NO_CTOR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zval *object_zval;
-       zend_function *constructor;
-       zend_free_op free_op1;
-
-       if (IS_CV == IS_VAR) {
-               PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
-       }
-
-       object_zval = _get_zval_ptr_cv(&opline->op1, EX(Ts), &free_op1, BP_VAR_R TSRMLS_CC);
-       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
-
-       EX(fbc_constructor) = NULL;
-       if (constructor == NULL) {
-               if(opline->op1.u.EA.type & EXT_TYPE_UNUSED) {
-                       zval_ptr_dtor(EX_T(opline->op1.u.var).var.ptr_ptr);
-               }
-               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
-               ZEND_VM_CONTINUE_JMP();
-       } else {
-               EX(fbc_constructor) = constructor;
-       }
-
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -27596,26 +27457,26 @@ void zend_init_opcodes_handlers()
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_TMP_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_TMP_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_TMP_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_TMP_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_TMP_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_VAR_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_VAR_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_VAR_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_VAR_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_CV_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_CV_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_CV_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_CV_HANDLER,
-       ZEND_JMP_NO_CTOR_SPEC_CV_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -28646,26 +28507,26 @@ void zend_init_opcodes_handlers()
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_TMP_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_TMP_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_TMP_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_TMP_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_TMP_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_VAR_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_VAR_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_VAR_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_VAR_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_VAR_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_CV_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_CV_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_CV_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_CV_HANDLER,
-       ZEND_INIT_CTOR_CALL_SPEC_CV_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
        ZEND_NULL_HANDLER,
@@ -31279,35 +31140,6 @@ static int ZEND_FETCH_CLASS_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_INIT_CTOR_CALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zend_free_op free_op1;
-
-       zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
-
-       if (opline->op1.op_type == IS_VAR) {
-               SELECTIVE_PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr, &opline->op1);
-       }
-
-       /* We are not handling overloaded classes right now */
-       EX(object) = get_zval_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R);
-
-       /* New always returns the object as is_ref=0, therefore, we can just increment the reference count */
-       EX(object)->refcount++; /* For $this pointer */
-
-       EX(fbc) = EX(fbc_constructor);
-
-       if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
-               EX(calling_scope) = EX(fbc)->common.scope;
-       } else {
-               EX(calling_scope) = NULL;
-       }
-
-       FREE_OP_IF_VAR(free_op1);
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_INIT_METHOD_CALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -32070,6 +31902,8 @@ static int ZEND_SWITCH_FREE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_NEW_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
+       zval *object_zval;
+       zend_function *constructor;
 
        if (EX_T(opline->op1.u.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
                char *class_type;
@@ -32081,13 +31915,43 @@ static int ZEND_NEW_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                }
                zend_error_noreturn(E_ERROR, "Cannot instantiate %s %s", class_type,  EX_T(opline->op1.u.var).class_entry->name);
        }
-       EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
-       ALLOC_ZVAL(EX_T(opline->result.u.var).var.ptr);
-       object_init_ex(EX_T(opline->result.u.var).var.ptr, EX_T(opline->op1.u.var).class_entry);
-       EX_T(opline->result.u.var).var.ptr->refcount=1;
-       EX_T(opline->result.u.var).var.ptr->is_ref=0;
+       ALLOC_ZVAL(object_zval);
+       object_init_ex(object_zval, EX_T(opline->op1.u.var).class_entry);
+       INIT_PZVAL(object_zval);
 
-       ZEND_VM_NEXT_OPCODE();
+       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
+
+       if (constructor == NULL) {
+               EX(fbc_constructor) = NULL;
+               if (RETURN_VALUE_USED(opline)) {
+                       EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+                       EX_T(opline->result.u.var).var.ptr = object_zval;
+               } else {
+                       zval_ptr_dtor(&object_zval);
+               }
+               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
+               ZEND_VM_CONTINUE_JMP();
+       } else {
+               EX(fbc_constructor) = constructor;
+
+               SELECTIVE_PZVAL_LOCK(object_zval, &opline->result);
+               EX_T(opline->result.u.var).var.ptr_ptr = &EX_T(opline->result.u.var).var.ptr;
+               EX_T(opline->result.u.var).var.ptr = object_zval;
+               
+               zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), EX(calling_scope));
+
+               /* We are not handling overloaded classes right now */
+               EX(object) = object_zval;
+
+               EX(fbc) = EX(fbc_constructor);
+
+               if (EX(fbc)->type == ZEND_USER_FUNCTION) { /* HACK!! */
+                       EX(calling_scope) = EX(fbc)->common.scope;
+               } else {
+                       EX(calling_scope) = NULL;
+               }
+               ZEND_VM_NEXT_OPCODE();
+       }
 }
 
 static int ZEND_CLONE_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -32848,34 +32712,6 @@ static int ZEND_FE_FETCH_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_JMP_NO_CTOR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-       zend_op *opline = EX(opline);
-       zval *object_zval;
-       zend_function *constructor;
-       zend_free_op free_op1;
-
-       if (opline->op1.op_type == IS_VAR) {
-               PZVAL_LOCK(*EX_T(opline->op1.u.var).var.ptr_ptr);
-       }
-
-       object_zval = get_zval_ptr(&opline->op1, EX(Ts), &free_op1, BP_VAR_R);
-       constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
-
-       EX(fbc_constructor) = NULL;
-       if (constructor == NULL) {
-               if(opline->op1.u.EA.type & EXT_TYPE_UNUSED) {
-                       zval_ptr_dtor(EX_T(opline->op1.u.var).var.ptr_ptr);
-               }
-               ZEND_VM_SET_OPCODE(EX(op_array)->opcodes + opline->op2.u.opline_num);
-               ZEND_VM_CONTINUE_JMP();
-       } else {
-               EX(fbc_constructor) = constructor;
-       }
-
-       ZEND_VM_NEXT_OPCODE();
-}
-
 static int ZEND_ISSET_ISEMPTY_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        zend_op *opline = EX(opline);
@@ -33353,7 +33189,7 @@ void zend_vm_use_old_executor()
        ZEND_SEND_VAR_HANDLER,
        ZEND_SEND_REF_HANDLER,
        ZEND_NEW_HANDLER,
-       ZEND_JMP_NO_CTOR_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_FREE_HANDLER,
        ZEND_INIT_ARRAY_HANDLER,
        ZEND_ADD_ARRAY_ELEMENT_HANDLER,
@@ -33395,7 +33231,7 @@ void zend_vm_use_old_executor()
        ZEND_THROW_HANDLER,
        ZEND_FETCH_CLASS_HANDLER,
        ZEND_CLONE_HANDLER,
-       ZEND_INIT_CTOR_CALL_HANDLER,
+       ZEND_NULL_HANDLER,
        ZEND_INIT_METHOD_CALL_HANDLER,
        ZEND_INIT_STATIC_METHOD_CALL_HANDLER,
        ZEND_ISSET_ISEMPTY_VAR_HANDLER,

diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h
index 0bc3baef929b04eab75dd72e92027451f7ac22a7..36dee54f3d66100cd8fdf83a2db6b24485c2f48d 100644 (file)
--- a/Zend/zend_vm_opcodes.h
+++ b/Zend/zend_vm_opcodes.h
@@ -87,7 +87,6 @@
 #define ZEND_SEND_VAR                 66
 #define ZEND_SEND_REF                 67
 #define ZEND_NEW                      68
-#define ZEND_JMP_NO_CTOR              69
 #define ZEND_FREE                     70
 #define ZEND_INIT_ARRAY               71
 #define ZEND_ADD_ARRAY_ELEMENT        72
@@ -127,7 +126,6 @@
 #define ZEND_THROW                   108
 #define ZEND_FETCH_CLASS             109
 #define ZEND_CLONE                   110
-#define ZEND_INIT_CTOR_CALL          111
 #define ZEND_INIT_METHOD_CALL        112
 #define ZEND_INIT_STATIC_METHOD_CALL 113
 #define ZEND_ISSET_ISEMPTY_VAR       114