Index: zend.h
===================================================================
RCS file: /repository/ZendEngine2/zend.h,v
retrieving revision 1.293.2.11.2.4
diff -u -r1.293.2.11.2.4 zend.h
--- zend.h	11 Jun 2006 16:28:24 -0000	1.293.2.11.2.4
+++ zend.h	17 Jun 2006 22:15:34 -0000
@@ -177,6 +177,16 @@
 # define ZEND_ATTRIBUTE_PTR_FORMAT(type, idx, first)
 #endif
 
+#ifndef likely
+# if defined(__GNUC__) && __GNUC__ >= 3
+#  define likely(exp)	__builtin_expect(!!(exp), 1)
+#  define unlikely(exp)	__builtin_expect(!!(exp), 0)
+# else
+#  define likely(exp)	(exp)
+#  define unlikely(exp)	(exp)
+# endif
+#endif
+
 
 #if (HAVE_ALLOCA || (defined (__GNUC__) && __GNUC__ >= 2)) && !(defined(ZTS) && defined(ZEND_WIN32)) && !(defined(ZTS) && defined(NETWARE)) && !(defined(ZTS) && defined(HPUX)) && !defined(DARWIN)
 # define do_alloca(p) alloca(p)
Index: zend_vm_def.h
===================================================================
RCS file: /repository/ZendEngine2/zend_vm_def.h,v
retrieving revision 1.59.2.29.2.10
diff -u -r1.59.2.29.2.10 zend_vm_def.h
--- zend_vm_def.h	13 Jun 2006 12:57:48 -0000	1.59.2.29.2.10
+++ zend_vm_def.h	17 Jun 2006 22:15:35 -0000
@@ -298,7 +298,7 @@
 	make_real_object(object_ptr TSRMLS_CC);
 	object = *object_ptr;
 
-	if (Z_TYPE_P(object) != IS_OBJECT) {
+	if (unlikely(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
 		FREE_OP2();
 		FREE_OP(free_op_data1);
@@ -344,7 +344,7 @@
 					}
 					break;
 			}
-			if (z) {
+			if (likely(z)) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
 					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
 
@@ -432,7 +432,7 @@
 			break;
 	}
 
-	if (!var_ptr) {
+	if (unlikely(!var_ptr)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
@@ -548,7 +548,7 @@
 	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
 	object = *object_ptr;
 
-	if (Z_TYPE_P(object) != IS_OBJECT) {
+	if (unlikely(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		FREE_OP2();
 		if (!RETURN_VALUE_UNUSED(&opline->result)) {
@@ -580,7 +580,7 @@
 	}
 
 	if (!have_get_ptr) {
-		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
+		if (likely(Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property)) {
 			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
 
 			if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
@@ -640,7 +640,7 @@
 	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
 	object = *object_ptr;
 
-	if (Z_TYPE_P(object) != IS_OBJECT) {
+	if (unlikely(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		FREE_OP2();
 		*retval = *EG(uninitialized_zval_ptr);
@@ -669,7 +669,7 @@
 	}
 
 	if (!have_get_ptr) {
-		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
+		if (likely(Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property)) {
 			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_RW TSRMLS_CC);
 			zval *z_copy;
 
@@ -724,7 +724,7 @@
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (!var_ptr) {
+	if (unlikely(!var_ptr)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
@@ -767,7 +767,7 @@
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (!var_ptr) {
+	if (unlikely(!var_ptr)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
@@ -810,7 +810,7 @@
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (!var_ptr) {
+	if (unlikely(!var_ptr)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
@@ -848,7 +848,7 @@
 	zend_free_op free_op1;
 	zval **var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (!var_ptr) {
+	if (unlikely(!var_ptr)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 	if (*var_ptr == EG(error_zval_ptr)) {
@@ -1093,7 +1093,7 @@
 	int type = ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->extended_value)?BP_VAR_W:BP_VAR_R;
 	zval *dim;
 
-	if (OP2_TYPE == IS_UNUSED && type == BP_VAR_R) {
+	if (unlikely(OP2_TYPE == IS_UNUSED && type == BP_VAR_R)) {
 		zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 	}
 	dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
@@ -1123,7 +1123,7 @@
 	zend_fetch_dimension_address(RETURN_VALUE_UNUSED(&opline->result)?NULL:&EX_T(opline->result.u.var), container, dim, IS_OP2_TMP_FREE(), BP_VAR_UNSET TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1_VAR_PTR();
-	if (EX_T(opline->result.u.var).var.ptr_ptr == NULL) {
+	if (unlikely(EX_T(opline->result.u.var).var.ptr_ptr == NULL)) {
 		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
 	} else {
 		zend_free_op free_res;
@@ -1161,7 +1161,7 @@
 	}
 
 
-	if (Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property) {
+	if (unlikely(Z_TYPE_P(container) != IS_OBJECT || !Z_OBJ_HT_P(container)->read_property)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
 		*retval = EG(uninitialized_zval_ptr);
 		SELECTIVE_PZVAL_LOCK(*retval, &opline->result);
@@ -1397,18 +1397,18 @@
 	zval **variable_ptr_ptr;
 	zval **value_ptr_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
 
-	if (OP2_TYPE == IS_VAR &&
+	if (unlikely(OP2_TYPE == IS_VAR &&
 	    value_ptr_ptr &&
 	    !(*value_ptr_ptr)->is_ref &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION &&
-	    !EX_T(opline->op2.u.var).var.fcall_returned_reference) {
+	    !EX_T(opline->op2.u.var).var.fcall_returned_reference)) {
 		if (free_op2.var == NULL) {
 			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
 	}
-	if (OP1_TYPE == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
+	if (unlikely(OP1_TYPE == IS_VAR && EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr)) {
 		zend_error(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
 
@@ -1640,7 +1640,7 @@
 
 	function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (Z_TYPE_P(function_name)!=IS_STRING) {
+	if (unlikely(Z_TYPE_P(function_name)!=IS_STRING)) {
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
@@ -1649,14 +1649,14 @@
 
 	EX(object) = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
 
-	if (EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT) {
-		if (Z_OBJ_HT_P(EX(object))->get_method == NULL) {
+	if (likely(EX(object) && Z_TYPE_P(EX(object)) == IS_OBJECT)) {
+		if (unlikely(Z_OBJ_HT_P(EX(object))->get_method == NULL)) {
 			zend_error_noreturn(E_ERROR, "Object does not support method calls");
 		}
 
 		/* First, locate the function. */
 		EX(fbc) = Z_OBJ_HT_P(EX(object))->get_method(&EX(object), function_name_strval, function_name_strlen TSRMLS_CC);
-		if (!EX(fbc)) {
+		if (unlikely(!EX(fbc))) {
 			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(EX(object)), function_name_strval);
 		}
 	} else {
@@ -1704,7 +1704,7 @@
 		} else {
 			function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-			if (Z_TYPE_P(function_name) != IS_STRING) {
+			if (unlikely(Z_TYPE_P(function_name) != IS_STRING)) {
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
 			}
 			function_name_strval = zend_str_tolower_dup(function_name->value.str.val, function_name->value.str.len);
@@ -1727,10 +1727,10 @@
 	if (EX(fbc)->common.fn_flags & ZEND_ACC_STATIC) {
 		EX(object) = NULL;
 	} else {
-		if (OP2_TYPE != IS_UNUSED &&
+		if (unlikely(OP2_TYPE != IS_UNUSED &&
 		    EG(This) &&
 		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC))) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", EX(fbc)->common.scope->name, EX(fbc)->common.function_name);
@@ -1761,7 +1761,7 @@
 	} else {
 		function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-		if (Z_TYPE_P(function_name) != IS_STRING) {
+		if (unlikely(Z_TYPE_P(function_name) != IS_STRING)) {
 			zend_error_noreturn(E_ERROR, "Function name must be a string");
 		}
 		function_name_strval = function_name->value.str.val;
@@ -1769,7 +1769,7 @@
 	}
 
 	lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
-	if (zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE) {
+	if (unlikely(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &function)==FAILURE)) {
 		efree(lcname);
 		zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
 	}
@@ -1798,11 +1798,11 @@
 	zend_op *ctor_opline;
 
 	if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
-		if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
+		if (unlikely(EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT)) {
 			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
 			ZEND_VM_NEXT_OPCODE(); /* Never reached */
 		}
-		if (EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED) {
+		if (unlikely(EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED)) {
 			zend_error(E_STRICT, "Function %s%s%s() is deprecated", 
 				EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
 				EX(function_state).function->common.scope ? "::" : "",
@@ -1828,7 +1828,7 @@
 	EX_T(opline->result.u.var).var.fcall_returned_reference = 0;
 
 	if (EX(function_state).function->common.scope) {
-		if (!EG(This) && !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
+		if (unlikely(!EG(This) && !(EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC))) {
 			int severity;
 			char *severity_word;
 			if (EX(function_state).function->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
@@ -1926,7 +1926,7 @@
 		INIT_ZVAL(*(EX_T(opline->result.u.var).var.ptr));
 
 			/* Not sure what should be done here if it's a static method */
-		if (EX(object)) {
+		if (likely(EX(object))) {
 			Z_OBJ_HT_P(EX(object))->call_method(EX(fbc)->common.function_name, opline->extended_value, EX_T(opline->result.u.var).var.ptr, &EX_T(opline->result.u.var).var.ptr, EX(object), return_value_used TSRMLS_CC);
 		} else {
 			zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
@@ -1995,7 +1995,7 @@
 
 	zend_ptr_stack_3_push(&EG(arg_types_stack), EX(fbc), EX(object), NULL);
 
-	if (zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE) {
+	if (unlikely(zend_hash_find(EG(function_table), fname->value.str.val, fname->value.str.len+1, (void **) &EX(function_state).function)==FAILURE)) {
 		zend_error_noreturn(E_ERROR, "Unknown function:  %s()", fname->value.str.val);
 	}
 	EX(object) = NULL;
@@ -2014,7 +2014,7 @@
 
 	if (EG(active_op_array)->return_reference == ZEND_RETURN_REF) {
 
-		if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
+		if (unlikely(OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR)) {
 			/* Not supposed to happen, but we'll allow it */
 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
 			ZEND_VM_C_GOTO(return_by_value);
@@ -2022,14 +2022,14 @@
 
 		retval_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-		if (!retval_ptr_ptr) {
+		if (unlikely(!retval_ptr_ptr)) {
 			zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
 		}
 
 		if (OP1_TYPE == IS_VAR && !(*retval_ptr_ptr)->is_ref) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
 			    EX_T(opline->op1.u.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr) {
+			} else if (unlikely(EX_T(opline->op1.u.var).var.ptr_ptr == &EX_T(opline->op1.u.var).var.ptr)) {
 				if (OP1_TYPE == IS_VAR && !OP1_FREE) {
 					PZVAL_LOCK(*retval_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
 				}
@@ -2056,7 +2056,7 @@
 			ALLOC_ZVAL(ret);
 			INIT_PZVAL_COPY(ret, retval_ptr);
 			dup = zend_get_object_classname(retval_ptr, &class_name, &class_name_len TSRMLS_CC);
-			if (Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL) {
+			if (unlikely(Z_OBJ_HT_P(retval_ptr)->clone_obj == NULL)) {
 				zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s",  class_name);
 			}
 			zend_error(E_STRICT, "Implicit cloning object of class '%s' because of 'zend.ze1_compatibility_mode'", class_name);
@@ -2099,7 +2099,7 @@
 
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (Z_TYPE_P(value) != IS_OBJECT) {
+	if (unlikely(Z_TYPE_P(value) != IS_OBJECT)) {
 		zend_error_noreturn(E_ERROR, "Can only throw objects");
 	}
 	/* Not sure if a complete copy is what we want here */
@@ -2145,8 +2145,8 @@
 ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP|VAR|CV, ANY)
 {
 	zend_op *opline = EX(opline);
-	if (opline->extended_value==ZEND_DO_FCALL_BY_NAME
-		&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num)) {
+	if (unlikely(opline->extended_value==ZEND_DO_FCALL_BY_NAME
+		&& ARG_SHOULD_BE_SENT_BY_REF(EX(fbc), opline->op2.u.opline_num))) {
 			zend_error_noreturn(E_ERROR, "Cannot pass parameter %d by reference", opline->op2.u.opline_num);
 	}
 	{
@@ -2209,11 +2209,11 @@
 	}
 
 	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
-	if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
+	if (likely((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
 	     EX_T(opline->op1.u.var).var.fcall_returned_reference) &&
 	    varptr != &EG(uninitialized_zval) &&
 	    (PZVAL_IS_REF(varptr) ||
-	     (varptr->refcount == 1 && (OP1_TYPE == IS_CV || free_op1.var)))) {
+	     (varptr->refcount == 1 && (OP1_TYPE == IS_CV || free_op1.var))))) {
 		varptr->is_ref = 1;
 		varptr->refcount++;
 		zend_ptr_stack_push(&EG(argument_stack), varptr);
@@ -2240,7 +2240,7 @@
 	zval *varptr;
 	varptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-	if (!varptr_ptr) {
+	if (unlikely(!varptr_ptr)) {
 		zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
 	}
 
@@ -2270,7 +2270,7 @@
 	zval **param;
 	zend_uint arg_num = Z_LVAL(opline->op1.u.constant);
 
-	if (zend_ptr_stack_get_arg(arg_num, (void **) &param TSRMLS_CC)==FAILURE) {
+	if (unlikely(zend_ptr_stack_get_arg(arg_num, (void **) &param TSRMLS_CC)==FAILURE)) {
 		char *space;
 		char *class_name = get_active_class_name(&space TSRMLS_CC);
 		zend_execute_data *ptr = EX(prev_execute_data);
@@ -2424,7 +2424,7 @@
 	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)) {
+	if (unlikely(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;
 
 		if (EX_T(opline->op1.u.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
@@ -2472,7 +2472,7 @@
 	zend_function *clone;
 	zend_object_clone_obj_t clone_call;
 
-	if (!obj || Z_TYPE_P(obj) != IS_OBJECT) {
+	if (unlikely(!obj || Z_TYPE_P(obj) != IS_OBJECT)) {
 		zend_error(E_WARNING, "__clone method called on non-object");
 		EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
 		EX_T(opline->result.u.var).var.ptr->refcount++;
@@ -2483,7 +2483,7 @@
 	ce = Z_OBJCE_P(obj);
 	clone = ce ? ce->clone : NULL;
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
-	if (!clone_call) {
+	if (unlikely(!clone_call)) {
 		zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
 		EX_T(opline->result.u.var).var.ptr = EG(error_zval_ptr);
 		EX_T(opline->result.u.var).var.ptr->refcount++;
@@ -2493,10 +2493,10 @@
 		if (clone->op_array.fn_flags & ZEND_ACC_PRIVATE) {
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
-			if (ce != EG(scope)) {
+			if (unlikely(ce != EG(scope))) {
 				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
 			}
-		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
+		} else if (unlikely(clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (!zend_check_protected(clone->common.scope, EG(scope))) {
@@ -2512,7 +2512,7 @@
 		Z_TYPE_P(EX_T(opline->result.u.var).var.ptr) = IS_OBJECT;
 		EX_T(opline->result.u.var).var.ptr->refcount=1;
 		EX_T(opline->result.u.var).var.ptr->is_ref=1;
-		if (!RETURN_VALUE_USED(opline)) {
+		if (unlikely(!RETURN_VALUE_USED(opline))) {
 			zval_ptr_dtor(&EX_T(opline->result.u.var).var.ptr);
 		}
 	}
@@ -2538,7 +2538,7 @@
 			}
 		}
 */
-		if (!zend_get_constant(opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len, &EX_T(opline->result.u.var).tmp_var TSRMLS_CC)) {
+		if (unlikely(!zend_get_constant(opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len, &EX_T(opline->result.u.var).tmp_var TSRMLS_CC))) {
 			zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",
 						opline->op2.u.constant.value.str.val,
 						opline->op2.u.constant.value.str.val);
@@ -2550,7 +2550,7 @@
 
 	ce = EX_T(opline->op1.u.var).class_entry;
 
-	if (zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS) {
+	if (likely(zend_hash_find(&ce->constants_table, opline->op2.u.constant.value.str.val, opline->op2.u.constant.value.str.len+1, (void **) &value) == SUCCESS)) {
 		zval_update_constant(value, (void *) 1 TSRMLS_CC);
 		EX_T(opline->result.u.var).tmp_var = **value;
 		zval_copy_ctor(&EX_T(opline->result.u.var).tmp_var);
@@ -3013,7 +3013,7 @@
 		if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
 			ALLOC_INIT_ZVAL(array_ptr);
 		} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
-			if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
+			if (unlikely(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL)) {
 				zend_error(E_WARNING, "foreach() can not iterate over objects without PHP class");
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.u.opline_num);
 			}
@@ -3070,7 +3070,7 @@
 			} else {
 				FREE_OP1_IF_VAR();
 			}
-			if (!EG(exception)) {
+			if (unlikely(!EG(exception))) {
 				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
 			}
 			zend_throw_exception_internal(NULL TSRMLS_CC);
@@ -3633,7 +3633,7 @@
 	zend_class_entry *ce = EX_T(opline->op1.u.var).class_entry;
 	zend_class_entry *iface = EX_T(opline->op2.u.var).class_entry;
 
-	if (!(iface->ce_flags & ZEND_ACC_INTERFACE)) {
+	if (unlikely(!(iface->ce_flags & ZEND_ACC_INTERFACE))) {
 		zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
 	}