Improve performance of ZEND_IS_IDENTICAL

And for ZEND_IS_NOT_IDENTICAL.

- Take advantage of branch prediction in cases that are false/true
- Avoid function call and duplicate fetches of Z_TYPE_P in common use cases
- Avoid checking for EG(exception) when it's impossible.

  I think that the zval would always be IS_NULL or lower for an exception,
  but may be wrong.

Aside 1: I see that ZEND_IS_EQUAL does have the `SMART_BRANCH` in the
`SPEC`, generating optimized implementations based on what type of smart
branch is used. Is excluding it from ZEND_IS_IDENTICAL deliberate,
and if so, what's the reasoning?
(e.g. is the use in common applications low?)

- The SMART_BRANCH specialization was introduced in
  27e01cd

Aside 2: The function pointer for ZEND_IS_EQUAL_LONG can probably be used
directly for ZEND_IS_IDENTICAL_LONG. I'm not sure how to generate that.
(and DOUBLE)

The amount of time for nestedloop_ni(20) decreased from 0.726s to
0.593s due to this change.
This is still worse than `!=` (0.434) and `<` (0.375), which
have implementations that take advantage of branch prediction for
IS_LONG

```php
function nestedloop_ni($n) {
  $x = 0;
  for ($a=0; $a!==$n; $a++)
    for ($b=0; $b!==$n; $b++)
      for ($c=0; $c!==$n; $c++)
        for ($d=0; $d!==$n; $d++)
          for ($e=0; $e!==$n; $e++)
            for ($f=0; $f!==$n; $f++)
             $x++;
  print "$x\n";
}
```

Author: TysonAndre

Zend/tests/bug70785.phpt

@@ -19,6 +19,11 @@ try  {
 	undefined_function();
 } catch (Exception $e) {
 }
+try  {
+	$d === $f; // ZEND_VM_NEXT_OPCODE
+	undefined_function();
+} catch (Exception $e) {
+}
 ?>
 okey
 --EXPECT--

Zend/zend_operators.c

@@ -2118,6 +2118,12 @@ ZEND_API zend_bool ZEND_FASTCALL zend_is_identical(zval *op1, zval *op2) /* {{{
 }
 /* }}} */
 
+ZEND_API zend_bool ZEND_FASTCALL zend_is_identical_array(HashTable *h1, HashTable *h2) /* {{{ */
+{
+    return (h1 == h2 ||
+        zend_hash_compare(h1, h2, (compare_func_t) hash_zval_identical_function, 1) == 0);
+}
+
 ZEND_API int ZEND_FASTCALL is_identical_function(zval *result, zval *op1, zval *op2) /* {{{ */
 {
 	ZVAL_BOOL(result, zend_is_identical(op1, op2));

Zend/zend_operators.h

@@ -55,6 +55,7 @@ ZEND_API int ZEND_FASTCALL shift_right_function(zval *result, zval *op1, zval *o
 ZEND_API int ZEND_FASTCALL concat_function(zval *result, zval *op1, zval *op2);
 
 ZEND_API zend_bool ZEND_FASTCALL zend_is_identical(zval *op1, zval *op2);
+ZEND_API zend_bool ZEND_FASTCALL zend_is_identical_array(HashTable *h1, HashTable *h2);
 
 ZEND_API int ZEND_FASTCALL is_equal_function(zval *result, zval *op1, zval *op2);
 ZEND_API int ZEND_FASTCALL is_identical_function(zval *result, zval *op1, zval *op2);

Zend/zend_vm_def.h

@@ -451,25 +451,102 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(16, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|T
 	SAVE_OPLINE();
 	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 	op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
-	result = fast_is_identical_function(op1, op2);
+	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
+		/* They are not identical, return false. Note that this has to check for undefined variable errors when IS_NULL is possible. */
+		ZEND_VM_C_LABEL(is_different_nothrow):
+		FREE_OP1();
+		FREE_OP2();
+		ZEND_VM_SMART_BRANCH(0, 1);
+		return;
+	}
+	if (Z_TYPE_P(op1) <= IS_TRUE) {
+		/* They are identical, return true */
+		FREE_OP1();
+		FREE_OP2();
+		ZEND_VM_SMART_BRANCH(1, 1);
+		return;
+	}
+	switch (Z_TYPE_P(op1)) {
+		case IS_LONG:
+			result = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+			break;
+		case IS_RESOURCE:
+			result = (Z_RES_P(op1) == Z_RES_P(op2));
+			break;
+		case IS_DOUBLE:
+			result = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+			break;
+		case IS_STRING:
+			result = zend_string_equals(Z_STR_P(op1), Z_STR_P(op2));
+			break;
+		case IS_ARRAY:
+			/* This may cause EG(exception) due to infinite nesting, but other zval types won't? */
+			/* XXX hash_zval_identical_function is not static */
+			result = zend_is_identical_array(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2));
+			break;
+		case IS_OBJECT:
+			result = (Z_OBJ_P(op1) == Z_OBJ_P(op2));
+			break;
+		default:
+			ZEND_VM_C_GOTO(is_different_nothrow);
+	}
 	FREE_OP1();
 	FREE_OP2();
-	ZEND_VM_SMART_BRANCH(result, 1);
+	ZEND_VM_SMART_BRANCH(result, 0);
 }
 
 ZEND_VM_COLD_CONSTCONST_HANDLER(17, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV, SPEC(COMMUTATIVE))
 {
 	USE_OPLINE
-	zval *op1, *op2;
+		zval *op1, *op2;
 	zend_bool result;
 
 	SAVE_OPLINE();
 	op1 = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 	op2 = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
-	result = fast_is_not_identical_function(op1, op2);
+
+	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
+		/* They are not identical, return true. Note that this has to check for undefined variable errors when IS_NULL is possible. */
+		ZEND_VM_C_LABEL(is_different_nothrow):
+			FREE_OP1();
+		FREE_OP2();
+		ZEND_VM_SMART_BRANCH(1, 1);
+		return;
+	}
+	if (Z_TYPE_P(op1) <= IS_TRUE) {
+		/* They are identical, return false */
+		FREE_OP1();
+		FREE_OP2();
+		ZEND_VM_SMART_BRANCH(0, 1);
+		return;
+	}
+	switch (Z_TYPE_P(op1)) {
+		case IS_LONG:
+			result = (Z_LVAL_P(op1) != Z_LVAL_P(op2));
+			break;
+		case IS_RESOURCE:
+			result = (Z_RES_P(op1) != Z_RES_P(op2));
+			break;
+		case IS_DOUBLE:
+			result = (Z_DVAL_P(op1) != Z_DVAL_P(op2));
+			break;
+		case IS_STRING:
+			result = !zend_string_equals(Z_STR_P(op1), Z_STR_P(op2));
+			break;
+		case IS_ARRAY:
+			/* This may cause EG(exception) due to infinite nesting, but other zval types won't? */
+			/* XXX hash_zval_identical_function is not static */
+			result = !zend_is_identical_array(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2));
+			break;
+		case IS_OBJECT:
+			result = (Z_OBJ_P(op1) != Z_OBJ_P(op2));
+			break;
+		default:
+			ZEND_VM_C_GOTO(is_different_nothrow);
+	}
 	FREE_OP1();
 	FREE_OP2();
-	ZEND_VM_SMART_BRANCH(result, 1);
+	ZEND_VM_SMART_BRANCH(result, 0);
 }
 
 ZEND_VM_HELPER(zend_is_equal_helper, ANY, ANY, zval *op_1, zval *op_2)
@@ -1496,7 +1573,7 @@ ZEND_VM_HELPER(zend_pre_dec_helper, VAR|CV, ANY)
 
 	SAVE_OPLINE();
 	if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_UNDEF)) {
-		ZVAL_NULL(var_ptr);		
+		ZVAL_NULL(var_ptr);
 		ZVAL_UNDEFINED_OP1();
 	}
 
@@ -2234,7 +2311,7 @@ ZEND_VM_C_LABEL(fetch_obj_is_fast_copy):
 		}
 
 		retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var));
- 
+
 		if (OP2_TYPE != IS_CONST) {
 			zend_tmp_string_release(tmp_name);
 		}
@@ -5528,10 +5605,10 @@ ZEND_VM_HANDLER(147, ZEND_ADD_ARRAY_UNPACK, ANY, ANY)
 {
 	USE_OPLINE
 	zval *op1;
-	
+
 	SAVE_OPLINE();
 	op1 = GET_OP1_ZVAL_PTR(BP_VAR_R);
-	
+
 ZEND_VM_C_LABEL(add_unpack_again):
 	if (EXPECTED(Z_TYPE_P(op1) == IS_ARRAY)) {
 		HashTable *ht = Z_ARRVAL_P(op1);
@@ -5572,11 +5649,11 @@ ZEND_VM_C_LABEL(add_unpack_again):
 				}
 				HANDLE_EXCEPTION();
 			}
-			
+
 			if (iter->funcs->rewind) {
 				iter->funcs->rewind(iter);
 			}
-			
+
 			for (; iter->funcs->valid(iter) == SUCCESS; ) {
 				zval *val;
 
@@ -5625,7 +5702,7 @@ ZEND_VM_C_LABEL(add_unpack_again):
 	} else {
 		zend_throw_error(NULL, "Only arrays and Traversables can be unpacked");
 	}
-	
+
 	FREE_OP1();
 	ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
 }