From: Dmitry Stogov <dmitry@php.net>
Date: Fri, 10 Jun 2005 07:56:40 +0000 (+0000)
Subject: Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW... 
X-Git-Tag: php-5.0.1b1~10
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=6efa17c2a1dd3448718845b9bbd93ca7769c7068;p=php

Merge three opcodes (ZEND_NEW, ZEND_JMP_NO_CTOR, ZEND_INIT_CTOR) into one (ZEND_NEW). There was no real reason for this anymore and API should be changed before 5.1
---

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 67043fa448..8fe5362870 100644
--- 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 748a9cbab2..e8d5e71c59 100644
--- 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 fe9013517e..cdc4adbd07 100644
--- 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 0bc3baef92..36dee54f3d 100644
--- 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