Fixed bug #78230

(cherry picked from commit 4892bbc167)

NEWS

@@ -1,111 +1,5 @@
 PHP                                                                        NEWS
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
-15 Aug 2019, PHP 7.3.9RC1
-
-- Core:
-  . Fixed bug #78363 (Buffer overflow in zendparse). (Nikita)
-  . Fixed bug #78379 (Cast to object confuses GC, causes crash). (Dmitry)
-
-- Curl:
-  . Fixed bug #77946 (Bad cURL resources returned by curl_multi_info_read()).
-    (Abyr Valg)
-
-- Exif:
-  . Fixed bug #78333 (Exif crash (bus error) due to wrong alignment and
-    invalid cast). (Nikita)
-
-- FPM:
-  . Fixed bug #77185 (Use-after-free in FPM master event handling).
-    (Maksim Nikulin)
-
-- Iconv:
-  . Fixed bug #78342 (Bus error in configure test for iconv //IGNORE). (Rainer
-    Jung)
-
-- LiteSpeed:
-  . Updated to LiteSpeed SAPI V7.5 (Fixed clean shutdown). (George Wang)
-
-- MySQLnd:
-  . Fixed bug #78179 (MariaDB server version incorrectly detected). (cmb)
-  . Fixed bug #78213 (Empty row pocket). (cmb)
-
-- Opcache:
-  . Fixed bug #77191 (Assertion failure in dce_live_ranges() when silencing is
-    used). (Nikita)
-
-- Standard:
-  . Fixed bug #69100 (Bus error from stream_copy_to_stream (file -> SSL stream)
-    with invalid length). (Nikita)
-  . Fixed bug #78282 (atime and mtime mismatch). (cmb)
-  . Fixed bug #78326 (improper memory deallocation on stream_get_contents()
-    with fixed length buffer). (Albert Casademont)
-  . Fixed bug #78346 (strip_tags no longer handling nested php tags). (cmb)
-
-01 Aug 2019, PHP 7.3.8
-
-- Core:
-  . Added syslog.filter=raw option. (Erik Lundin)
-  . Fixed bug #78212 (Segfault in built-in webserver). (cmb)
-
-- Date:
-  . Fixed bug #69044 (discrepency between time and microtime). (krakjoe)
-  . Updated timelib to 2018.02. (Derick)
-
-- EXIF:
-  . Fixed bug #78256 (heap-buffer-overflow on exif_process_user_comment).
-    (CVE-2019-11042) (Stas)
-  . Fixed bug #78222 (heap-buffer-overflow on exif_scan_thumbnail).
-    (CVE-2019-11041) (Stas)
-
-- FTP:
-  . Fixed bug #78039 (FTP with SSL memory leak). (Nikita)
-
-- Libxml:
-  . Fixed bug #78279 (libxml_disable_entity_loader settings is shared between
-    requests (cgi-fcgi)). (Nikita)
-
-- LiteSpeed:
-  . Updated to LiteSpeed SAPI V7.4.3 (increased response header count limit from
-    100 to 1000, added crash handler to cleanly shutdown PHP request, added
-    CloudLinux mod_lsapi mode). (George Wang)
-  . Fixed bug #76058 (After "POST data can't be buffered", using php://input
-    makes huge tmp files). (George Wang)
-
-- Openssl:
-  . Fixed bug #78231 (Segmentation fault upon stream_socket_accept of exported
-    socket-to-stream). (Nikita)
-
-- Opcache:
-  . Fixed bug #78189 (file cache strips last character of uname hash). (cmb)
-  . Fixed bug #78202 (Opcache stats for cache hits are capped at 32bit NUM).
-    (cmb)
-  . Fixed bug #78271 (Invalid result of if-else). (Nikita)
-  . Fixed bug #78291 (opcache_get_configuration doesn't list all directives).
-    (Andrew Collington)
-  . Fixed bug #78341 (Failure to detect smart branch in DFA pass). (Nikita)
-
-- PCRE:
-  . Fixed bug #78197 (PCRE2 version check in configure fails for "##.##-xxx"
-    version strings). (pgnet, Peter Kokot)
-  . Fixed bug #78338 (Array cross-border reading in PCRE). (cmb)
-
-- PDO_Sqlite:
-  . Fixed bug #78192 (SegFault when reuse statement after schema has changed).
-    (Vincent Quatrevieux)
-
-- Phar:
-  . Fixed bug #77919 (Potential UAF in Phar RSHUTDOWN). (cmb)
-
-- Phpdbg:
-  . Fixed bug #78297 (Include unexistent file memory leak). (Nikita)
-
-- SQLite:
-  . Upgraded to SQLite 3.28.0. (cmb)
-
-- Standard:
-  . Fixed bug #78241 (touch() does not handle dates after 2038 in PHP 64-bit). (cmb)
-  . Fixed bug #78269 (password_hash uses weak options for argon2). (Remi)
-
 04 Jul 2019, PHP 7.3.7
 
 - Core:
@@ -150,7 +44,7 @@ PHP                                                                        NEWS
 - Standard:
   . Fixed bug #77135 (Extract with EXTR_SKIP should skip $this).
     (Craig Duncan, Dmitry)
-  . Fixed bug #77937 (preg_match failed). (cmb, Anatol)
+  . Fixed bug ##77937	(preg_match failed). (cmb, Anatol)
 
 - Zip:
   . Fixed bug #76345 (zip.h not found). (Michael Maroszek)

TSRM/tsrm_win32.c

@@ -770,7 +770,7 @@ static zend_always_inline void UnixTimeToFileTime(time_t t, LPFILETIME pft) /* {
 	// Note that LONGLONG is a 64-bit value
 	LONGLONG ll;
 
-	ll = t * 10000000LL + 116444736000000000LL;
+	ll = Int32x32To64(t, 10000000) + 116444736000000000;
 	pft->dwLowDateTime = (DWORD)ll;
 	pft->dwHighDateTime = ll >> 32;
 }

Zend/tests/assert/expect_020.phpt

@@ -1,17 +0,0 @@
---TEST--
-AST pretty-printer
---INI--
-zend.assertions=1
-assert.exception=0
---FILE--
-<?php
-assert(0 && ($a = function () {
-	$var = 'test';
-	$str = "$var, $var[1], {$var}[], {$var[1]}[], ${var}[], ${var[1]}[]";
-}));
-?>
---EXPECTF--
-Warning: assert(): assert(0 && ($a = function () {
-    $var = 'test';
-    $str = "$var, {$var[1]}, {$var}[], {$var[1]}[], {$var}[], {$var[1]}[]";
-})) failed in %sexpect_020.php on line %d

Zend/tests/bug49908.phpt

@@ -13,18 +13,22 @@ spl_autoload_register(function ($className) {
 	}
 });
 
-new Foo;
+try {
+    new Foo();
+} catch (Exception $e) { }
+
+// We never reach here.
+var_dump(new Foo());
 
 ?>
 --EXPECTF--
 string(3) "Foo"
 string(3) "Bar"
 
-Fatal error: Uncaught Exception: Bar in %s:%d
+Fatal error: During class fetch: Uncaught Exception: Bar in %s:%d
 Stack trace:
 #0 [internal function]: {closure}('Bar')
 #1 %s(%d): spl_autoload_call('Bar')
 #2 [internal function]: {closure}('Foo')
 #3 %s(%d): spl_autoload_call('Foo')
-#4 {main}
-  thrown in %s on line %d
+#4 {main} in %s on line %d

Zend/tests/bug78010.phpt

@@ -1,32 +0,0 @@
---TEST--
-Bug #78010: Segmentation fault during GC
---INI--
-memory_limit=2G
---FILE--
-<?php
-
-class foo
-{
-    public function __construct()
-    {
-        $this->x = $this;
-
-        for ($i = 0; $i < 898; $i++) { //Will not trigger with <898
-            $obj = [new stdClass, new stdClass]; //This must have at least 2 elements
-            $this->y[] = $obj;
-        }
-    }
-}
-
-for ($i = 0; $i < 2; ++$i) { //This must run >=2 (increasing the number of elements in the array *2 will not do)
-    $x = []; //This must be reset
-    foreach (array_fill(0, 389, 'x') as &$params) { //Will not trigger <389
-        $x[] = new foo;
-    }
-}
-
-echo "Completed\n";
-
-?>
---EXPECT--
-Completed

Zend/tests/bug78271.phpt

@@ -1,27 +0,0 @@
---TEST--
-Bug #78271: Invalid result of if-else
---FILE--
-<?php
-function test($a, $b){
-    if ($a==10) {
-        $w="x";
-    } else {
-        $w="y";
-    }
-
-    if ($b) {
-        $d1="none";
-        $d2="block";
-    } else {
-        $d1="block";
-        $d2="none";
-    }
-
-    echo $d2.$b."\n";
-
-}
-
-test(1, 1);
-?>
---EXPECT--
-block1

Zend/tests/bug78379.phpt

@@ -1,32 +0,0 @@
---TEST--
-Bug #78379 (Cast to object confuses GC, causes crash)
---INI--
-opcache.enable=0
---FILE--
-<?php
-class C {
-	public function __construct() {
-		$this->p = (object)["x" => [1]];
-	}
-}
-class E {
-}
-$e = new E;
-$e->f = new E;
-$e->f->e = $e;
-$e->a = new C;
-$e = null;
-gc_collect_cycles();
-var_dump(new C);
-?>
---EXPECTF--
-object(C)#%d (1) {
-  ["p"]=>
-  object(stdClass)#%d (1) {
-    ["x"]=>
-    array(1) {
-      [0]=>
-      int(1)
-    }
-  }
-}

Zend/tests/bug78379_2.phpt

@@ -1,19 +0,0 @@
---TEST--
-Bug #78379.2 (Cast to object confuses GC, causes crash)
---FILE--
-<?php
-class E {}
-function f() {
-	$e1 = new E;
-	$e2 = new E;
-	$a = ['e2' => $e2];
-	$e1->a = (object)$a;
-	$e2->e1 = $e1;
-	$e2->a = (object)$a;
-}
-f();
-gc_collect_cycles();
-echo "End\n";
-?>
---EXPECT--
-End

Zend/tests/gc_041.phpt

@@ -1,35 +0,0 @@
---TEST--
-GC 041: Handling of references in nested data of objects with destructor
---INI--
-zend.enable_gc = 1
---FILE--
-<?php
-class ryat {
-	    var $ryat;
-        var $chtg;
-        var $nested;
-	    function __destruct() {
-	            $GLOBALS['x'] = $this;
-        }
-}
-$o = new ryat;
-$o->nested = [];
-$o->nested[] =& $o->nested;
-$o->ryat = $o;
-$x =& $o->chtg;
-unset($o);
-gc_collect_cycles();
-var_dump($x);
-?>
---EXPECT--
-object(ryat)#1 (3) {
-  ["ryat"]=>
-  *RECURSION*
-  ["chtg"]=>
-  *RECURSION*
-  ["nested"]=>
-  &array(1) {
-    [0]=>
-    *RECURSION*
-  }
-}

Zend/zend.h

@@ -20,7 +20,7 @@
 #ifndef ZEND_H
 #define ZEND_H
 
-#define ZEND_VERSION "3.3.9RC1"
+#define ZEND_VERSION "3.3.7"
 
 #define ZEND_ENGINE_3
 

Zend/zend_ast.c

@@ -995,11 +995,6 @@ static ZEND_COLD int zend_ast_valid_var_name(const char *s, size_t len)
 	return 1;
 }
 
-static ZEND_COLD int zend_ast_var_needs_braces(char ch)
-{
-	return ch == '[' || zend_ast_valid_var_char(ch);
-}
-
 static ZEND_COLD void zend_ast_export_var(smart_str *str, zend_ast *ast, int priority, int indent)
 {
 	if (ast->kind == ZEND_AST_ZVAL) {
@@ -1047,7 +1042,7 @@ static ZEND_COLD void zend_ast_export_encaps_list(smart_str *str, char quote, ze
 		           ast->child[0]->kind == ZEND_AST_ZVAL &&
 		           (i + 1 == list->children ||
 		            list->child[i + 1]->kind != ZEND_AST_ZVAL ||
-		            !zend_ast_var_needs_braces(
+		            !zend_ast_valid_var_char(
 		                *Z_STRVAL_P(
 		                    zend_ast_get_zval(list->child[i + 1]))))) {
 			zend_ast_export_ex(str, ast, 0, indent);
@@ -1664,8 +1659,6 @@ simple_list:
 				zend_ast_export_ex(str, ast->child[1], 80, indent);
 				smart_str_appends(str, " => ");
 			}
-			if (ast->attr)
-				smart_str_appendc(str, '&');
 			zend_ast_export_ex(str, ast->child[0], 80, indent);
 			break;
 		case ZEND_AST_NEW:

Zend/zend_compile.c

@@ -6694,7 +6694,6 @@ void zend_compile_use(zend_ast *ast) /* {{{ */
 		}
 
 		zend_string_addref(old_name);
-		old_name = zend_new_interned_string(old_name);
 		if (!zend_hash_add_ptr(current_import, lookup_name, old_name)) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use%s %s as %s because the name "
 				"is already in use", zend_get_use_type_str(type), ZSTR_VAL(old_name), ZSTR_VAL(new_name));

Zend/zend_execute_API.c

@@ -1359,14 +1359,28 @@ zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *
 	if (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) {
 		return zend_lookup_class_ex(class_name, key, 0);
 	} else if ((ce = zend_lookup_class_ex(class_name, key, 1)) == NULL) {
-		if ((fetch_type & ZEND_FETCH_CLASS_SILENT) == 0 && !EG(exception)) {
-			if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_INTERFACE) {
-				zend_throw_or_error(fetch_type, NULL, "Interface '%s' not found", ZSTR_VAL(class_name));
-			} else if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_TRAIT) {
-				zend_throw_or_error(fetch_type, NULL, "Trait '%s' not found", ZSTR_VAL(class_name));
-			} else {
-				zend_throw_or_error(fetch_type, NULL, "Class '%s' not found", ZSTR_VAL(class_name));
+		if (fetch_type & ZEND_FETCH_CLASS_SILENT) {
+			return NULL;
+		}
+		if (EG(exception)) {
+			if (!(fetch_type & ZEND_FETCH_CLASS_EXCEPTION)) {
+				zend_string *exception_str;
+				zval exception_zv;
+				ZVAL_OBJ(&exception_zv, EG(exception));
+				Z_ADDREF(exception_zv);
+				zend_clear_exception();
+				exception_str = zval_get_string(&exception_zv);
+				zend_error_noreturn(E_ERROR,
+					"During class fetch: Uncaught %s", ZSTR_VAL(exception_str));
 			}
+			return NULL;
+		}
+		if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_INTERFACE) {
+			zend_throw_or_error(fetch_type, NULL, "Interface '%s' not found", ZSTR_VAL(class_name));
+		} else if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_TRAIT) {
+			zend_throw_or_error(fetch_type, NULL, "Trait '%s' not found", ZSTR_VAL(class_name));
+		} else {
+			zend_throw_or_error(fetch_type, NULL, "Class '%s' not found", ZSTR_VAL(class_name));
 		}
 		return NULL;
 	}

Zend/zend_gc.c

@@ -86,22 +86,6 @@
 #define GC_GREY     0x200000
 #define GC_PURPLE   0x300000
 
-/* Debug tracing */
-#if ZEND_GC_DEBUG > 1
-# define GC_TRACE(format, ...) fprintf(stderr, format "\n", ##__VA_ARGS__);
-# define GC_TRACE_REF(ref, format, ...) \
-	do { \
-		gc_trace_ref((zend_refcounted *) ref); \
-		fprintf(stderr, format "\n", ##__VA_ARGS__); \
-	} while (0)
-# define GC_TRACE_SET_COLOR(ref, color) \
-	GC_TRACE_REF(ref, "->%s", gc_color_name(color))
-#else
-# define GC_TRACE_REF(ref, format, ...)
-# define GC_TRACE_SET_COLOR(ref, new_color)
-# define GC_TRACE(str)
-#endif
-
 /* GC_INFO access */
 #define GC_REF_ADDRESS(ref) \
 	(((GC_TYPE_INFO(ref)) & (GC_ADDRESS << GC_INFO_SHIFT)) >> GC_INFO_SHIFT)
@@ -119,19 +103,16 @@
 	} while (0)
 
 #define GC_REF_SET_COLOR(ref, c) do { \
-		GC_TRACE_SET_COLOR(ref, c); \
 		GC_TYPE_INFO(ref) = \
 			(GC_TYPE_INFO(ref) & ~(GC_COLOR << GC_INFO_SHIFT)) | \
 			((c) << GC_INFO_SHIFT); \
 	} while (0)
 
 #define GC_REF_SET_BLACK(ref) do { \
-		GC_TRACE_SET_COLOR(ref, GC_BLACK); \
 		GC_TYPE_INFO(ref) &= ~(GC_COLOR << GC_INFO_SHIFT); \
 	} while (0)
 
 #define GC_REF_SET_PURPLE(ref) do { \
-		GC_TRACE_SET_COLOR(ref, GC_PURPLE); \
 		GC_TYPE_INFO(ref) |= (GC_COLOR << GC_INFO_SHIFT); \
 	} while (0)
 
@@ -169,7 +150,7 @@
 #define GC_DEFAULT_BUF_SIZE  (16 * 1024)
 #define GC_BUF_GROW_STEP     (128 * 1024)
 
-#define GC_MAX_UNCOMPRESSED  (512 * 1024)
+#define GC_MAX_UNCOMPRESSED  (1024 * 1024)
 #define GC_MAX_BUF_SIZE      0x40000000
 
 #define GC_THRESHOLD_DEFAULT 10000
@@ -249,6 +230,21 @@ static zend_gc_globals gc_globals;
 # define GC_BENCH_PEAK(peak, counter)
 #endif
 
+#if ZEND_GC_DEBUG > 1
+# define GC_TRACE(format, ...) fprintf(stderr, format "\n", ##__VA_ARGS__);
+# define GC_TRACE_REF(ref, format, ...) \
+	do { \
+		gc_trace_ref((zend_refcounted *) ref); \
+		fprintf(stderr, format "\n", ##__VA_ARGS__); \
+	} while (0)
+# define GC_TRACE_SET_COLOR(ref, color) \
+	GC_TRACE_REF(ref, "->%s", gc_color_name(color))
+#else
+# define GC_TRACE_REF(ref, format, ...)
+# define GC_TRACE_SET_COLOR(ref, new_color)
+# define GC_TRACE(str)
+#endif
+
 
 #define GC_STACK_SEGMENT_SIZE (((4096 - ZEND_MM_OVERHEAD) / sizeof(void*)) - 2)
 
@@ -318,10 +314,7 @@ static void gc_stack_free(gc_stack *stack)
 
 static zend_always_inline uint32_t gc_compress(uint32_t idx)
 {
-	if (EXPECTED(idx < GC_MAX_UNCOMPRESSED)) {
-		return idx;
-	}
-	return (idx % GC_MAX_UNCOMPRESSED) | GC_MAX_UNCOMPRESSED;
+	return idx % GC_MAX_UNCOMPRESSED;
 }
 
 static zend_always_inline gc_root_buffer* gc_decompress(zend_refcounted *ref, uint32_t idx)
@@ -701,14 +694,11 @@ tail_call:
 			ZVAL_OBJ(&tmp, obj);
 			ht = get_gc(&tmp, &zv, &n);
 			end = zv + n;
-			if (EXPECTED(!ht) || UNEXPECTED(GC_REF_CHECK_COLOR(ht, GC_BLACK))) {
-				ht = NULL;
+			if (EXPECTED(!ht)) {
 				if (!n) goto next;
 				while (!Z_REFCOUNTED_P(--end)) {
 					if (zv == end) goto next;
 				}
-			} else {
-				GC_REF_SET_BLACK(ht);
 			}
 			while (zv != end) {
 				if (Z_REFCOUNTED_P(zv)) {
@@ -823,19 +813,15 @@ static void gc_mark_grey(zend_refcounted *ref, gc_stack *stack)
 				ZVAL_OBJ(&tmp, obj);
 				ht = get_gc(&tmp, &zv, &n);
 				end = zv + n;
-				if (EXPECTED(!ht) || UNEXPECTED(GC_REF_CHECK_COLOR(ht, GC_GREY))) {
-					ht = NULL;
+				if (EXPECTED(!ht)) {
 					if (!n) goto next;
 					while (!Z_REFCOUNTED_P(--end)) {
 						if (zv == end) goto next;
 					}
-				} else {
-					GC_REF_SET_COLOR(ht, GC_GREY);
 				}
 				while (zv != end) {
 					if (Z_REFCOUNTED_P(zv)) {
 						ref = Z_COUNTED_P(zv);
-						ZEND_ASSERT(GC_REFCOUNT(ref) > 0);
 						GC_DELREF(ref);
 						if (!GC_REF_CHECK_COLOR(ref, GC_GREY)) {
 							GC_REF_SET_COLOR(ref, GC_GREY);
@@ -846,7 +832,6 @@ static void gc_mark_grey(zend_refcounted *ref, gc_stack *stack)
 				}
 				if (EXPECTED(!ht)) {
 					ref = Z_COUNTED_P(zv);
-					ZEND_ASSERT(GC_REFCOUNT(ref) > 0);
 					GC_DELREF(ref);
 					if (!GC_REF_CHECK_COLOR(ref, GC_GREY)) {
 						GC_REF_SET_COLOR(ref, GC_GREY);
@@ -867,7 +852,6 @@ static void gc_mark_grey(zend_refcounted *ref, gc_stack *stack)
 		} else if (GC_TYPE(ref) == IS_REFERENCE) {
 			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
 				ref = Z_COUNTED(((zend_reference*)ref)->val);
-				ZEND_ASSERT(GC_REFCOUNT(ref) > 0);
 				GC_DELREF(ref);
 				if (!GC_REF_CHECK_COLOR(ref, GC_GREY)) {
 					GC_REF_SET_COLOR(ref, GC_GREY);
@@ -900,7 +884,6 @@ static void gc_mark_grey(zend_refcounted *ref, gc_stack *stack)
 			}
 			if (Z_REFCOUNTED_P(zv)) {
 				ref = Z_COUNTED_P(zv);
-				ZEND_ASSERT(GC_REFCOUNT(ref) > 0);
 				GC_DELREF(ref);
 				if (!GC_REF_CHECK_COLOR(ref, GC_GREY)) {
 					GC_REF_SET_COLOR(ref, GC_GREY);
@@ -914,7 +897,6 @@ static void gc_mark_grey(zend_refcounted *ref, gc_stack *stack)
 			zv = Z_INDIRECT_P(zv);
 		}
 		ref = Z_COUNTED_P(zv);
-		ZEND_ASSERT(GC_REFCOUNT(ref) > 0);
 		GC_DELREF(ref);
 		if (!GC_REF_CHECK_COLOR(ref, GC_GREY)) {
 			GC_REF_SET_COLOR(ref, GC_GREY);
@@ -1016,14 +998,11 @@ tail_call:
 					ZVAL_OBJ(&tmp, obj);
 					ht = get_gc(&tmp, &zv, &n);
 					end = zv + n;
-					if (EXPECTED(!ht) || UNEXPECTED(!GC_REF_CHECK_COLOR(ht, GC_GREY))) {
-						ht = NULL;
+					if (EXPECTED(!ht)) {
 						if (!n) goto next;
 						while (!Z_REFCOUNTED_P(--end)) {
 							if (zv == end) goto next;
 						}
-					} else {
-						GC_REF_SET_COLOR(ht, GC_WHITE);
 					}
 					while (zv != end) {
 						if (Z_REFCOUNTED_P(zv)) {
@@ -1190,8 +1169,7 @@ static int gc_collect_white(zend_refcounted *ref, uint32_t *flags, gc_stack *sta
 				ZVAL_OBJ(&tmp, obj);
 				ht = get_gc(&tmp, &zv, &n);
 				end = zv + n;
-				if (EXPECTED(!ht) || UNEXPECTED(GC_REF_CHECK_COLOR(ht, GC_BLACK))) {
-					ht = NULL;
+				if (EXPECTED(!ht)) {
 					if (!n) goto next;
 					while (!Z_REFCOUNTED_P(--end)) {
 						/* count non-refcounted for compatibility ??? */
@@ -1200,8 +1178,6 @@ static int gc_collect_white(zend_refcounted *ref, uint32_t *flags, gc_stack *sta
 						}
 						if (zv == end) goto next;
 					}
-				} else {
-					GC_REF_SET_BLACK(ht);
 				}
 				while (zv != end) {
 					if (Z_REFCOUNTED_P(zv)) {
@@ -1350,24 +1326,16 @@ static void gc_remove_nested_data_from_buffer(zend_refcounted *ref, gc_root_buff
 	zval *zv;
 
 tail_call:
-	do {
+	if (root ||
+	    (GC_REF_ADDRESS(ref) != 0 &&
+	     GC_REF_CHECK_COLOR(ref, GC_BLACK))) {
+		GC_TRACE_REF(ref, "removing from buffer");
 		if (root) {
-			GC_TRACE_REF(ref, "removing from buffer");
 			gc_remove_from_roots(root);
 			GC_REF_SET_INFO(ref, 0);
 			root = NULL;
-		} else if (GC_REF_ADDRESS(ref) != 0
-		 && GC_REF_CHECK_COLOR(ref, GC_BLACK)) {
-			GC_TRACE_REF(ref, "removing from buffer");
-			GC_REMOVE_FROM_BUFFER(ref);
-		} else if (GC_TYPE(ref) == IS_REFERENCE) {
-			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
-				ref = Z_COUNTED(((zend_reference*)ref)->val);
-				goto tail_call;
-			}
-			return;
 		} else {
-			return;
+			GC_REMOVE_FROM_BUFFER(ref);
 		}
 
 		if (GC_TYPE(ref) == IS_OBJECT) {
@@ -1405,6 +1373,12 @@ tail_call:
 			}
 		} else if (GC_TYPE(ref) == IS_ARRAY) {
 			ht = (zend_array*)ref;
+		} else if (GC_TYPE(ref) == IS_REFERENCE) {
+			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
+				ref = Z_COUNTED(((zend_reference*)ref)->val);
+				goto tail_call;
+			}
+			return;
 		} else {
 			return;
 		}
@@ -1440,7 +1414,7 @@ tail_call:
 		}
 		ref = Z_COUNTED_P(zv);
 		goto tail_call;
-	} while (0);
+	}
 }
 
 ZEND_API int zend_gc_collect_cycles(void)

Zend/zend_language_parser.y

@@ -1312,7 +1312,7 @@ static YYSIZE_T zend_yytnamerr(char *yyres, const char *yystr)
 
 		if (LANG_SCNG(yy_text)[0] == 0 &&
 			LANG_SCNG(yy_leng) == 1 &&
-			strcmp(yystr, "\"end of file\"") == 0) {
+			memcmp(yystr, "\"end of file\"", sizeof("\"end of file\"") - 1) == 0) {
 			if (yyres) {
 				yystpcpy(yyres, "end of file");
 			}

Zend/zend_object_handlers.c

@@ -124,11 +124,6 @@ ZEND_API HashTable *zend_std_get_gc(zval *object, zval **table, int *n) /* {{{ *
 		if (zobj->properties) {
 			*table = NULL;
 			*n = 0;
-			if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)
-			 && EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
-				GC_DELREF(zobj->properties);
-				zobj->properties = zend_array_dup(zobj->properties);
-			}
 			return zobj->properties;
 		} else {
 			*table = zobj->properties_table;

Zend/zend_objects.c

@@ -43,8 +43,7 @@ ZEND_API void zend_object_std_dtor(zend_object *object)
 
 	if (object->properties) {
 		if (EXPECTED(!(GC_FLAGS(object->properties) & IS_ARRAY_IMMUTABLE))) {
-			if (EXPECTED(GC_DELREF(object->properties) == 0)
-					&& EXPECTED(GC_TYPE(object->properties) != IS_NULL)) {
+			if (EXPECTED(GC_DELREF(object->properties) == 0)) {
 				zend_array_destroy(object->properties);
 			}
 		}

Zend/zend_signal.c

@@ -328,13 +328,13 @@ void zend_signal_activate(void)
 
 	SIGG(active) = 1;
 	SIGG(depth)  = 0;
-	SIGG(check)  = ZEND_DEBUG;
 } /* }}} */
 
 /* {{{ zend_signal_deactivate
  * */
 void zend_signal_deactivate(void)
 {
+
 	if (SIGG(check)) {
 		size_t x;
 		struct sigaction sa;
@@ -342,32 +342,21 @@ void zend_signal_deactivate(void)
 		if (SIGG(depth) != 0) {
 			zend_error(E_CORE_WARNING, "zend_signal: shutdown with non-zero blocking depth (%d)", SIGG(depth));
 		}
-
 		/* did anyone steal our installed handler */
 		for (x = 0; x < sizeof(zend_sigs) / sizeof(*zend_sigs); x++) {
 			sigaction(zend_sigs[x], NULL, &sa);
-			if (sa.sa_sigaction != zend_signal_handler_defer &&
-					sa.sa_sigaction != (void *) SIG_IGN) {
+			if (sa.sa_sigaction != zend_signal_handler_defer) {
 				zend_error(E_CORE_WARNING, "zend_signal: handler was replaced for signal (%d) after startup", zend_sigs[x]);
 			}
 		}
 	}
 
-	/* After active=0 is set, signal handlers will be called directly and other
-	 * state that is reset below will not be accessed. */
-	*((volatile int *) &SIGG(active)) = 0;
-
+	SIGNAL_BEGIN_CRITICAL();
+	SIGG(active) = 0;
 	SIGG(running) = 0;
 	SIGG(blocked) = 0;
 	SIGG(depth) = 0;
-
-	/* If there are any queued signals because of a missed unblock, drop them. */
-	if (SIGG(phead) && SIGG(ptail)) {
-		SIGG(ptail)->next = SIGG(pavail);
-		SIGG(pavail) = SIGG(phead);
-		SIGG(phead) = NULL;
-		SIGG(ptail) = NULL;
-	}
+	SIGNAL_END_CRITICAL();
 }
 /* }}} */
 

Zend/zend_vm_def.h

@@ -8506,7 +8506,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_IS_SMALLER_OR_EQUAL, (op1_info == MAY_BE_DOUB
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG_NO_OVERFLOW, TMPVARCV, ANY, SPEC(RETVAL))
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8519,7 +8519,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (res_info == MAY_BE_LONG && op1_info
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG, CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG, TMPVARCV, ANY, SPEC(RETVAL))
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8532,7 +8532,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_PRE_INC_LONG_OR_DOUBLE, CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_PRE_INC_LONG_OR_DOUBLE, TMPVARCV, ANY, SPEC(RETVAL))
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8549,7 +8549,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOU
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG_NO_OVERFLOW, CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG_NO_OVERFLOW, TMPVARCV, ANY, SPEC(RETVAL))
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8562,7 +8562,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (res_info == MAY_BE_LONG && op1_info
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG, CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG, TMPVARCV, ANY, SPEC(RETVAL))
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8575,7 +8575,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_PRE_DEC_LONG_OR_DOUBLE, CV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_PRE_DEC_LONG_OR_DOUBLE, TMPVARCV, ANY, SPEC(RETVAL))
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8592,7 +8592,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOU
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG_NO_OVERFLOW, CV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG_NO_OVERFLOW, TMPVARCV, ANY)
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8603,7 +8603,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (res_info == MAY_BE_LONG && op1_inf
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG, CV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG, TMPVARCV, ANY)
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8614,7 +8614,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == MAY_BE_LONG), ZEND_POS
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_POST_INC_LONG_OR_DOUBLE, CV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_POST_INC_LONG_OR_DOUBLE, TMPVARCV, ANY)
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8630,7 +8630,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == (MAY_BE_LONG|MAY_BE_DO
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG_NO_OVERFLOW, CV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG_NO_OVERFLOW, TMPVARCV, ANY)
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8641,7 +8641,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (res_info == MAY_BE_LONG && op1_inf
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG, CV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG, TMPVARCV, ANY)
 {
 	USE_OPLINE
 	zval *var_ptr;
@@ -8652,7 +8652,7 @@ ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == MAY_BE_LONG), ZEND_POS
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_POST_DEC_LONG_OR_DOUBLE, CV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == (MAY_BE_LONG|MAY_BE_DOUBLE)), ZEND_POST_DEC_LONG_OR_DOUBLE, TMPVARCV, ANY)
 {
 	USE_OPLINE
 	zval *var_ptr;

Zend/zend_vm_execute.h

@@ -11048,6 +11048,254 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZE
 	ZEND_VM_RETURN();
 }
 
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	Z_LVAL_P(var_ptr)++;
+	if (UNEXPECTED(0)) {
+		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	Z_LVAL_P(var_ptr)++;
+	if (UNEXPECTED(1)) {
+		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	fast_long_increment_function(var_ptr);
+	if (UNEXPECTED(0)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	fast_long_increment_function(var_ptr);
+	if (UNEXPECTED(1)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_long_increment_function(var_ptr);
+	} else {
+		Z_DVAL_P(var_ptr)++;
+	}
+	if (UNEXPECTED(0)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_long_increment_function(var_ptr);
+	} else {
+		Z_DVAL_P(var_ptr)++;
+	}
+	if (UNEXPECTED(1)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	Z_LVAL_P(var_ptr)--;
+	if (UNEXPECTED(0)) {
+		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	Z_LVAL_P(var_ptr)--;
+	if (UNEXPECTED(1)) {
+		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	fast_long_decrement_function(var_ptr);
+	if (UNEXPECTED(0)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	fast_long_decrement_function(var_ptr);
+	if (UNEXPECTED(1)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_long_decrement_function(var_ptr);
+	} else {
+		Z_DVAL_P(var_ptr)--;
+	}
+	if (UNEXPECTED(0)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_long_decrement_function(var_ptr);
+	} else {
+		Z_DVAL_P(var_ptr)--;
+	}
+	if (UNEXPECTED(1)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	Z_LVAL_P(var_ptr)++;
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	fast_long_increment_function(var_ptr);
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+		fast_long_increment_function(var_ptr);
+	} else {
+		ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
+		Z_DVAL_P(var_ptr)++;
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	Z_LVAL_P(var_ptr)--;
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+	fast_long_decrement_function(var_ptr);
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zval *var_ptr;
+
+	var_ptr = EX_VAR(opline->op1.var);
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
+		fast_long_decrement_function(var_ptr);
+	} else {
+		ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
+		Z_DVAL_P(var_ptr)--;
+	}
+	ZEND_VM_NEXT_OPCODE();
+}
+
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -37971,254 +38219,6 @@ type_check_resource:
 	}
 }
 
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	Z_LVAL_P(var_ptr)++;
-	if (UNEXPECTED(0)) {
-		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	Z_LVAL_P(var_ptr)++;
-	if (UNEXPECTED(1)) {
-		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	fast_long_increment_function(var_ptr);
-	if (UNEXPECTED(0)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	fast_long_increment_function(var_ptr);
-	if (UNEXPECTED(1)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-		fast_long_increment_function(var_ptr);
-	} else {
-		Z_DVAL_P(var_ptr)++;
-	}
-	if (UNEXPECTED(0)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-		fast_long_increment_function(var_ptr);
-	} else {
-		Z_DVAL_P(var_ptr)++;
-	}
-	if (UNEXPECTED(1)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	Z_LVAL_P(var_ptr)--;
-	if (UNEXPECTED(0)) {
-		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	Z_LVAL_P(var_ptr)--;
-	if (UNEXPECTED(1)) {
-		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	fast_long_decrement_function(var_ptr);
-	if (UNEXPECTED(0)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	fast_long_decrement_function(var_ptr);
-	if (UNEXPECTED(1)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-		fast_long_decrement_function(var_ptr);
-	} else {
-		Z_DVAL_P(var_ptr)--;
-	}
-	if (UNEXPECTED(0)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-		fast_long_decrement_function(var_ptr);
-	} else {
-		Z_DVAL_P(var_ptr)--;
-	}
-	if (UNEXPECTED(1)) {
-		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	Z_LVAL_P(var_ptr)++;
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	fast_long_increment_function(var_ptr);
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-		fast_long_increment_function(var_ptr);
-	} else {
-		ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
-		Z_DVAL_P(var_ptr)++;
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	Z_LVAL_P(var_ptr)--;
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-	fast_long_decrement_function(var_ptr);
-	ZEND_VM_NEXT_OPCODE();
-}
-
-static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	USE_OPLINE
-	zval *var_ptr;
-
-	var_ptr = EX_VAR(opline->op1.var);
-	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
-		ZVAL_LONG(EX_VAR(opline->result.var), Z_LVAL_P(var_ptr));
-		fast_long_decrement_function(var_ptr);
-	} else {
-		ZVAL_DOUBLE(EX_VAR(opline->result.var), Z_DVAL_P(var_ptr));
-		Z_DVAL_P(var_ptr)--;
-	}
-	ZEND_VM_NEXT_OPCODE();
-}
-
 static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
@@ -55240,24 +55240,24 @@ ZEND_API void execute_ex(zend_execute_data *ex)
 			(void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_LABEL,
 			(void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_LABEL,
 			(void*)&&ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_LABEL,
-			(void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
-			(void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
-			(void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
-			(void*)&&ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_LABEL,
-			(void*)&&ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_LABEL,
-			(void*)&&ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_LABEL,
-			(void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_LABEL,
-			(void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_LABEL,
-			(void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_LABEL,
-			(void*)&&ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_LABEL,
-			(void*)&&ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_LABEL,
-			(void*)&&ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_LABEL,
-			(void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
-			(void*)&&ZEND_POST_INC_LONG_SPEC_CV_LABEL,
-			(void*)&&ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_LABEL,
-			(void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_LABEL,
-			(void*)&&ZEND_POST_DEC_LONG_SPEC_CV_LABEL,
-			(void*)&&ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_LABEL,
+			(void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_LABEL,
+			(void*)&&ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_LABEL,
+			(void*)&&ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_LABEL,
+			(void*)&&ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED_LABEL,
+			(void*)&&ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_LABEL,
+			(void*)&&ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_LABEL,
+			(void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_LABEL,
+			(void*)&&ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_LABEL,
+			(void*)&&ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_LABEL,
+			(void*)&&ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED_LABEL,
+			(void*)&&ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_LABEL,
+			(void*)&&ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_LABEL,
+			(void*)&&ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_LABEL,
+			(void*)&&ZEND_POST_INC_LONG_SPEC_TMPVARCV_LABEL,
+			(void*)&&ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_LABEL,
+			(void*)&&ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_LABEL,
+			(void*)&&ZEND_POST_DEC_LONG_SPEC_TMPVARCV_LABEL,
+			(void*)&&ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_LABEL,
 			(void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
 			(void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
 			(void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
@@ -56458,6 +56458,78 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_YIELD_SPEC_CONST_CV)
 				ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED):
+				VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED)
+				ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED):
+				VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED)
+				ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED):
+				VM_TRACE(ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED)
+				ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED):
+				VM_TRACE(ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED)
+				ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED):
+				VM_TRACE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED)
+				ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED):
+				VM_TRACE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED)
+				ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED):
+				VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED)
+				ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED):
+				VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED)
+				ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED):
+				VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED)
+				ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED):
+				VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED)
+				ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED):
+				VM_TRACE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED)
+				ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED):
+				VM_TRACE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED)
+				ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV):
+				VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV)
+				ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_TMPVARCV):
+				VM_TRACE(ZEND_POST_INC_LONG_SPEC_TMPVARCV)
+				ZEND_POST_INC_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV):
+				VM_TRACE(ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV)
+				ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV):
+				VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV)
+				ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_TMPVARCV):
+				VM_TRACE(ZEND_POST_DEC_LONG_SPEC_TMPVARCV)
+				ZEND_POST_DEC_LONG_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
+			HYBRID_CASE(ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV):
+				VM_TRACE(ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV)
+				ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV):
 				VM_TRACE(ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV)
 				ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -59344,78 +59416,6 @@ zend_leave_helper_SPEC_LABEL:
 				VM_TRACE(ZEND_TYPE_CHECK_SPEC_CV)
 				ZEND_TYPE_CHECK_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
-				VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
-				ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
-				VM_TRACE(ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
-				ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED):
-				VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED)
-				ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED):
-				VM_TRACE(ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED)
-				ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED):
-				VM_TRACE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED)
-				ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED):
-				VM_TRACE(ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED)
-				ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED):
-				VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED)
-				ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED):
-				VM_TRACE(ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED)
-				ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED):
-				VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED)
-				ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED):
-				VM_TRACE(ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED)
-				ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED):
-				VM_TRACE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED)
-				ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED):
-				VM_TRACE(ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED)
-				ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV):
-				VM_TRACE(ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV)
-				ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_POST_INC_LONG_SPEC_CV):
-				VM_TRACE(ZEND_POST_INC_LONG_SPEC_CV)
-				ZEND_POST_INC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV):
-				VM_TRACE(ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV)
-				ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV):
-				VM_TRACE(ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV)
-				ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_POST_DEC_LONG_SPEC_CV):
-				VM_TRACE(ZEND_POST_DEC_LONG_SPEC_CV)
-				ZEND_POST_DEC_LONG_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
-			HYBRID_CASE(ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV):
-				VM_TRACE(ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV)
-				ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				HYBRID_BREAK();
 			HYBRID_CASE(ZEND_SEND_VAR_SIMPLE_SPEC_CV):
 				VM_TRACE(ZEND_SEND_VAR_SIMPLE_SPEC_CV)
 				ZEND_SEND_VAR_SIMPLE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
@@ -64739,24 +64739,24 @@ void zend_vm_init(void)
 		ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_HANDLER,
 		ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ_HANDLER,
 		ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER,
-		ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
-		ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
-		ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
-		ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
-		ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER,
-		ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER,
-		ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED_HANDLER,
-		ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED_HANDLER,
-		ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED_HANDLER,
-		ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED_HANDLER,
-		ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED_HANDLER,
-		ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED_HANDLER,
-		ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
-		ZEND_POST_INC_LONG_SPEC_CV_HANDLER,
-		ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV_HANDLER,
-		ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV_HANDLER,
-		ZEND_POST_DEC_LONG_SPEC_CV_HANDLER,
-		ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV_HANDLER,
+		ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER,
+		ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_HANDLER,
+		ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER,
+		ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED_HANDLER,
+		ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER,
+		ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_HANDLER,
+		ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER,
+		ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED_HANDLER,
+		ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER,
+		ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED_HANDLER,
+		ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED_HANDLER,
+		ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED_HANDLER,
+		ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_HANDLER,
+		ZEND_POST_INC_LONG_SPEC_TMPVARCV_HANDLER,
+		ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_HANDLER,
+		ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_HANDLER,
+		ZEND_POST_DEC_LONG_SPEC_TMPVARCV_HANDLER,
+		ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_HANDLER,
 		ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST_HANDLER,
 		ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,
 		ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_HANDLER,

Zend/zend_vm_gen.php

@@ -321,7 +321,7 @@ $op1_get_zval_ptr_ptr_undef = array(
 	"UNUSED"   => "NULL",
 	"CV"       => "EX_VAR(opline->op1.var)",
 	"TMPVAR"   => "???",
-	"TMPVARCV" => "???",
+	"TMPVARCV" => "EX_VAR(opline->op1.var)",
 );
 
 $op2_get_zval_ptr_ptr_undef = array(
@@ -332,7 +332,7 @@ $op2_get_zval_ptr_ptr_undef = array(
 	"UNUSED"   => "NULL",
 	"CV"       => "EX_VAR(opline->op2.var)",
 	"TMPVAR"   => "???",
-	"TMPVARCV" => "???",
+	"TMPVARCV" => "EX_VAR(opline->op2.var)",
 );
 
 $op1_get_obj_zval_ptr = array(
@@ -431,7 +431,7 @@ $op1_get_obj_zval_ptr_ptr_undef = array(
 	"UNUSED"   => "&EX(This)",
 	"CV"       => "EX_VAR(opline->op1.var)",
 	"TMPVAR"   => "???",
-	"TMPVARCV" => "???",
+	"TMPVARCV" => "EX_VAR(opline->op1.var)",
 );
 
 $op2_get_obj_zval_ptr_ptr_undef = array(
@@ -442,7 +442,7 @@ $op2_get_obj_zval_ptr_ptr_undef = array(
 	"UNUSED"   => "&EX(This)",
 	"CV"       => "EX_VAR(opline->op2.var)",
 	"TMPVAR"   => "???",
-	"TMPVARCV" => "???",
+	"TMPVARCV" => "EX_VAR(opline->op2.var)",
 );
 
 $op1_free_op = array(

Zend/zend_vm_handlers.h

@@ -2007,24 +2007,24 @@
 	_(3850, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \
 	_(3851, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \
 	_(3852, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \
-	_(3853, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3854, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3855, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3856, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3857, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED) \
-	_(3858, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED) \
-	_(3859, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \
-	_(3860, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \
-	_(3861, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \
-	_(3862, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \
-	_(3863, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_UNUSED) \
-	_(3864, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_CV_RETVAL_USED) \
-	_(3865, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3866, ZEND_POST_INC_LONG_SPEC_CV) \
-	_(3867, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_CV) \
-	_(3868, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \
-	_(3869, ZEND_POST_DEC_LONG_SPEC_CV) \
-	_(3870, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_CV) \
+	_(3853, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+	_(3854, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+	_(3855, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+	_(3856, ZEND_PRE_INC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+	_(3857, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+	_(3858, ZEND_PRE_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+	_(3859, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_UNUSED) \
+	_(3860, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV_RETVAL_USED) \
+	_(3861, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_UNUSED) \
+	_(3862, ZEND_PRE_DEC_LONG_SPEC_TMPVARCV_RETVAL_USED) \
+	_(3863, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_UNUSED) \
+	_(3864, ZEND_PRE_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV_RETVAL_USED) \
+	_(3865, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+	_(3866, ZEND_POST_INC_LONG_SPEC_TMPVARCV) \
+	_(3867, ZEND_POST_INC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
+	_(3868, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_TMPVARCV) \
+	_(3869, ZEND_POST_DEC_LONG_SPEC_TMPVARCV) \
+	_(3870, ZEND_POST_DEC_LONG_OR_DOUBLE_SPEC_TMPVARCV) \
 	_(3871, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \
 	_(3872, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \
 	_(3873, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \

configure.ac

@@ -107,8 +107,8 @@ int zend_sprintf(char *buffer, const char *format, ...);
 
 PHP_MAJOR_VERSION=7
 PHP_MINOR_VERSION=3
-PHP_RELEASE_VERSION=9
-PHP_EXTRA_VERSION="RC1"
+PHP_RELEASE_VERSION=7
+PHP_EXTRA_VERSION=""
 PHP_VERSION="$PHP_MAJOR_VERSION.$PHP_MINOR_VERSION.$PHP_RELEASE_VERSION$PHP_EXTRA_VERSION"
 PHP_VERSION_ID=`expr [$]PHP_MAJOR_VERSION \* 10000 + [$]PHP_MINOR_VERSION \* 100 + [$]PHP_RELEASE_VERSION`
 

ext/curl/interface.c

@@ -150,6 +150,8 @@ static void _php_curl_close_ex(php_curl *ch);
 static void _php_curl_close(zend_resource *rsrc);
 
 
+#define SAVE_CURL_ERROR(__handle, __err) (__handle)->err.no = (int) __err;
+
 #define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s) - 1, (zend_long) v);
 #define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s) - 1, (double) v);
 #define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s) - 1, (char *) (v ? v : ""));

ext/curl/multi.c

@@ -334,7 +334,6 @@ PHP_FUNCTION(curl_multi_info_read)
 	CURLMsg	  *tmp_msg;
 	int        queued_msgs;
 	zval      *zmsgs_in_queue = NULL;
-	php_curl  *ch;
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		Z_PARAM_RESOURCE(z_mh)
@@ -372,10 +371,6 @@ PHP_FUNCTION(curl_multi_info_read)
 			   being done in add_assoc_resource */
 			Z_ADDREF_P(pz_ch);
 
-			/* we must save result to be able to read error message */
-			ch = (php_curl*)zend_fetch_resource(Z_RES_P(pz_ch), le_curl_name, le_curl);
-			SAVE_CURL_ERROR(ch, tmp_msg->data.result);
-
 			/* add_assoc_resource automatically creates a new zval to
 			   wrap the "resource" represented by the current pz_ch */
 

ext/curl/php_curl.h

@@ -58,8 +58,6 @@ extern zend_module_entry curl_module_entry;
 #define PHP_CURL_RETURN 4
 #define PHP_CURL_IGNORE 7
 
-#define SAVE_CURL_ERROR(__handle, __err) (__handle)->err.no = (int) __err;
-
 extern int  le_curl;
 #define le_curl_name "cURL handle"
 extern int  le_curl_multi_handle;

ext/curl/tests/bug77946.phpt

@@ -1,43 +0,0 @@
---TEST--
-Bug #77946 (Errored cURL resources returned by curl_multi_info_read() must be compatible with curl_errno() and curl_error())
---SKIPIF--
-<?php
-
-if (!extension_loaded('curl')) {
-	exit('skip curl extension not loaded');
-}
-
-?>
---FILE--
-<?php
-$urls = array(
-   'unknown://scheme.tld',
-);
-
-$mh = curl_multi_init();
-
-foreach ($urls as $i => $url) {
-    $conn[$i] = curl_init($url);
-    curl_multi_add_handle($mh, $conn[$i]);
-}
-
-do {
-    $status = curl_multi_exec($mh, $active);
-    $info = curl_multi_info_read($mh);
-    if (false !== $info) {
-        var_dump($info['result']);
-        var_dump(curl_errno($info['handle']));
-        var_dump(curl_error($info['handle']));
-    }
-} while ($status === CURLM_CALL_MULTI_PERFORM || $active);
-
-foreach ($urls as $i => $url) {
-    curl_close($conn[$i]);
-}
-
-curl_multi_close($mh);
-?>
---EXPECTF--
-int(1)
-int(1)
-string(%d) "Protocol %Sunknown%S not supported or disabled in libcurl"

ext/date/lib/LICENSE.rst

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2019 Derick Rethans
-Copyright (c) 2017-2019 MongoDB, Inc.
+Copyright (c) 2015-2017 Derick Rethans
+Copyright (c) 2017 MongoDB, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

ext/date/lib/astro.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/astro.h

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -72,3 +72,4 @@
 /* below the horizon.                                                      */
 #define astronomical_twilight(ts,lon,lat,start,end)  \
         timelib_astro_rise_set_altitude( ts, lon, lat, -18.0, 0, start, end )
+

ext/date/lib/dow.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/interval.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/parse_date.re

@@ -1,8 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
- * Copyright (c) 2018 MongoDB, Inc.
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/parse_iso_intervals.re

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/parse_tz.c

@@ -1,8 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
- * Copyright (c) 2018 MongoDB, Inc.
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -394,7 +393,7 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
 		tz->type[0].isgmtcnt
 		);
 	for (i = 0; i < tz->bit64.timecnt; i++) {
-		printf ("%016" PRIX64 " (%20" PRId64 ") = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
+		printf ("%016lX (%20ld) = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
 			tz->trans[i], tz->trans[i], tz->trans_idx[i],
 			(long int) tz->type[tz->trans_idx[i]].offset,
 			tz->type[tz->trans_idx[i]].isdst,
@@ -405,7 +404,7 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
 			);
 	}
 	for (i = 0; i < tz->bit64.leapcnt; i++) {
-		printf ("%016" PRIX64 " (%20ld) = %d\n",
+		printf ("%016lX (%20ld) = %d\n",
 			tz->leap_times[i].trans,
 			(long) tz->leap_times[i].trans,
 			tz->leap_times[i].offset);
@@ -503,6 +502,11 @@ timelib_tzinfo *timelib_parse_tzfile(char *timezone, const timelib_tzdb *tzdb, i
 		tmp = timelib_tzinfo_ctor(timezone);
 
 		version = read_preamble(&tzf, tmp, &type);
+		if (version == -1) {
+			*error_code = TIMELIB_ERROR_UNSUPPORTED_VERSION;
+			timelib_tzinfo_dtor(tmp);
+			return NULL;
+		}
 		if (version < 2 || version > 3) {
 			*error_code = TIMELIB_ERROR_UNSUPPORTED_VERSION;
 			timelib_tzinfo_dtor(tmp);
@@ -517,7 +521,6 @@ timelib_tzinfo *timelib_parse_tzfile(char *timezone, const timelib_tzdb *tzdb, i
 		if (!skip_64bit_preamble(&tzf, tmp)) {
 			/* 64 bit preamble is not in place */
 			*error_code = TIMELIB_ERROR_CORRUPT_NO_64BIT_PREAMBLE;
-			timelib_tzinfo_dtor(tmp);
 			return NULL;
 		}
 		read_64bit_header(&tzf, tmp);
@@ -604,8 +607,8 @@ static ttinfo* fetch_timezone_offset(timelib_tzinfo *tz, timelib_sll ts, timelib
 	/* If there is no transition time, we pick the first one, if that doesn't
 	 * exist we return NULL */
 	if (!tz->bit64.timecnt || !tz->trans) {
+		*transition_time = 0;
 		if (tz->bit64.typecnt == 1) {
-			*transition_time = INT64_MIN;
 			return &(tz->type[0]);
 		}
 		return NULL;
@@ -616,7 +619,6 @@ static ttinfo* fetch_timezone_offset(timelib_tzinfo *tz, timelib_sll ts, timelib
 	 * one in case there are only DST entries. Not sure which smartass came up
 	 * with this idea in the first though :) */
 	if (ts < tz->trans[0]) {
-		*transition_time = INT64_MIN;
 		return &(tz->type[0]);
 	}
 

ext/date/lib/timelib.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015-2017 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/timelib.h

@@ -1,8 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
- * Copyright (c) 2018 MongoDB, Inc.
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -322,9 +321,9 @@ typedef struct _timelib_tzdb {
 # define timelib_free    free
 #endif
 
-#define TIMELIB_VERSION 201802
-#define TIMELIB_EXTENDED_VERSION 20180201
-#define TIMELIB_ASCII_VERSION "2018.02"
+#define TIMELIB_VERSION 201801
+#define TIMELIB_EXTENDED_VERSION 20180105
+#define TIMELIB_ASCII_VERSION "2018.01RC3"
 
 #define TIMELIB_NONE             0x00
 #define TIMELIB_OVERRIDE_TIME    0x01
@@ -650,7 +649,7 @@ void timelib_set_timezone_from_abbr(timelib_time *t, timelib_abbr_info abbr_info
  * It fetches the right UTC offset that is currently stored in the time
  * stamp field in 't' ('sse'), and assigns that to the 'z' field and 'dst'
  * field (whether DST is in effect at the time). It also sets the current
- * abbreviation to the 'tz_addr' field, making sure that if a value was already
+ * abbrevation to the 'tz_addr' field, making sure that if a value was already
  * set it was freed.
  *
  * The time zone information in 'tz' is *not* duplicated into the 't' field so

ext/date/lib/timelib_private.h

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -39,7 +39,13 @@
 # endif
 #endif
 
-#include <string.h>
+#ifdef HAVE_STRING_H
+# include <string.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
 
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
@@ -62,7 +68,10 @@
 #endif
 
 #include <stdio.h>
+
+#if HAVE_LIMITS_H
 #include <limits.h>
+#endif
 
 #define TIMELIB_SECOND   1
 #define TIMELIB_MINUTE   2

ext/date/lib/timezonemap.h

@@ -4,7 +4,13 @@
 	{ "acdt",  1,  37800, "Australia/North"               },
 	{ "acdt",  1,  37800, "Australia/South"               },
 	{ "acdt",  1,  37800, "Australia/Yancowinna"          },
+	{ "acst",  0,  32400, "Australia/Adelaide"            },
 	{ "acst",  0,  34200, "Australia/Adelaide"            },
+	{ "acst",  0,  32400, "Australia/Broken_Hill"         },
+	{ "acst",  0,  32400, "Australia/Darwin"              },
+	{ "acst",  0,  32400, "Australia/North"               },
+	{ "acst",  0,  32400, "Australia/South"               },
+	{ "acst",  0,  32400, "Australia/Yancowinna"          },
 	{ "acst",  0,  34200, "Australia/Broken_Hill"         },
 	{ "acst",  0,  34200, "Australia/Darwin"              },
 	{ "acst",  0,  34200, "Australia/North"               },
@@ -138,16 +144,20 @@
 	{ "bmt",   0, -14309, "America/Barbados"              },
 	{ "bmt",   0,   6264, "Europe/Tiraspol"               },
 	{ "bmt",   0, -17776, "America/Bogota"                },
+	{ "bmt",   0,   1050, "Europe/Brussels"               },
 	{ "bmt",   0,  10656, "Asia/Baghdad"                  },
+	{ "bmt",   0,   1786, "Europe/Busingen"               },
+	{ "bmt",   0,   1786, "Europe/Vaduz"                  },
+	{ "bmt",   0,   1786, "Europe/Zurich"                 },
 	{ "bmt",   0,  24124, "Asia/Bangkok"                  },
 	{ "bmt",   0,  24124, "Asia/Phnom_Penh"               },
 	{ "bmt",   0,  24124, "Asia/Vientiane"                },
 	{ "bmt",   0,  25632, "Asia/Jakarta"                  },
 	{ "bmt",   0,   6264, "Europe/Bucharest"              },
 	{ "bmt",   0,   6264, "Europe/Chisinau"               },
+	{ "bost",  1, -12756, "America/La_Paz"                },
 	{ "bst",   1,   3600, "Europe/London"                 },
 	{ "bst",   0,   3600, "Europe/London"                 },
-	{ "bst",   1, -12756, "America/La_Paz"                },
 	{ "bst",   0, -39600, "America/Adak"                  },
 	{ "bst",   0, -39600, "America/Atka"                  },
 	{ "bst",   0, -39600, "America/Nome"                  },
@@ -289,6 +299,7 @@
 	{ "cet",   0,   3600, "Europe/Berlin"                 },
 	{ "cet",   0,   7200, "Europe/Kaliningrad"            },
 	{ "cet",   0,   3600, "Africa/Algiers"                },
+	{ "cet",   0,   3600, "Africa/Casablanca"             },
 	{ "cet",   0,   3600, "Africa/Ceuta"                  },
 	{ "cet",   0,   3600, "Africa/Tripoli"                },
 	{ "cet",   0,   3600, "Africa/Tunis"                  },
@@ -361,6 +372,7 @@
 	{ "cmt",   0, -16356, "America/La_Paz"                },
 	{ "cmt",   0, -19176, "America/Cayman"                },
 	{ "cmt",   0, -19176, "America/Panama"                },
+	{ "cmt",   0,   3020, "Europe/Copenhagen"             },
 	{ "cmt",   0,   6900, "Europe/Chisinau"               },
 	{ "cmt",   0,   6900, "Europe/Tiraspol"               },
 	{ "cpt",   1, -18000, "America/Chicago"               },
@@ -633,8 +645,6 @@
 	{ "ewt",   1, -14400, "Canada/Eastern"                },
 	{ "ffmt",  0, -14660, "America/Martinique"            },
 	{ "fmt",   0,  -4056, "Atlantic/Madeira"              },
-	{ "gdt",   1,  39600, "Pacific/Guam"                  },
-	{ "gdt",   1,  39600, "Pacific/Saipan"                },
 	{ "gmt",   0,      0, "Africa/Abidjan"                },
 	{ "gmt",   0,      0, "Africa/Accra"                  },
 	{ "gmt",   0,      0, "Africa/Bamako"                 },
@@ -662,9 +672,6 @@
 	{ "gmt",   0,      0, "Europe/Jersey"                 },
 	{ "gmt",   0,      0, "Europe/London"                 },
 	{ "gmt",   0,      0, "GB"                            },
-	{ "gmt",   1,      0, "Europe/Bratislava"             },
-	{ "gmt",   1,      0, "Europe/Dublin"                 },
-	{ "gmt",   1,      0, "Europe/Prague"                 },
 	{ "gst",   0,  36000, "Pacific/Guam"                  },
 	{ "gst",   0,  36000, "Pacific/Saipan"                },
 	{ "hdt",   1, -34200, "Pacific/Honolulu"              },
@@ -673,23 +680,20 @@
 	{ "hdt",   1, -34200, "Pacific/Johnston"              },
 	{ "hkst",  1,  32400, "Asia/Hong_Kong"                },
 	{ "hkt",   0,  28800, "Asia/Hong_Kong"                },
-	{ "hkt",   0,  30600, "Asia/Hong_Kong"                },
 	{ "hmt",   0, -19776, "America/Havana"                },
 	{ "hmt",   0,  -6872, "Atlantic/Azores"               },
+	{ "hmt",   0,  21200, "Asia/Calcutta"                 },
 	{ "hmt",   0,  21200, "Asia/Dacca"                    },
 	{ "hmt",   0,  21200, "Asia/Dhaka"                    },
+	{ "hmt",   0,  21200, "Asia/Kolkata"                  },
 	{ "hmt",   0,   5989, "Europe/Helsinki"               },
 	{ "hmt",   0,   5989, "Europe/Mariehamn"              },
-	{ "hpt",   1, -34200, "Pacific/Honolulu"              },
-	{ "hpt",   1, -34200, "Pacific/Johnston"              },
 	{ "hst",   0, -36000, "Pacific/Honolulu"              },
 	{ "hst",   0, -37800, "Pacific/Honolulu"              },
 	{ "hst",   0, -36000, "America/Adak"                  },
 	{ "hst",   0, -36000, "America/Atka"                  },
 	{ "hst",   0, -36000, "Pacific/Johnston"              },
 	{ "hst",   0, -37800, "Pacific/Johnston"              },
-	{ "hwt",   1, -34200, "Pacific/Honolulu"              },
-	{ "hwt",   1, -34200, "Pacific/Johnston"              },
 	{ "iddt",  1,  14400, "Asia/Jerusalem"                },
 	{ "iddt",  1,  14400, "Asia/Tel_Aviv"                 },
 	{ "idt",   1,  10800, "Asia/Jerusalem"                },
@@ -699,6 +703,7 @@
 	{ "imt",   0,  25025, "Asia/Irkutsk"                  },
 	{ "imt",   0,   7016, "Asia/Istanbul"                 },
 	{ "imt",   0,   7016, "Europe/Istanbul"               },
+	{ "imt",   0,   7016, "Europe/Sofia"                  },
 	{ "ist",   0,   7200, "Asia/Jerusalem"                },
 	{ "ist",   0,  19800, "Asia/Calcutta"                 },
 	{ "ist",   0,  19800, "Asia/Kolkata"                  },
@@ -713,7 +718,6 @@
 	{ "jmt",   0,   8440, "Asia/Tel_Aviv"                 },
 	{ "jst",   0,  32400, "Asia/Tokyo"                    },
 	{ "jst",   0,  32400, "Asia/Hong_Kong"                },
-	{ "jst",   0,  32400, "Asia/Manila"                   },
 	{ "jst",   0,  32400, "Asia/Pyongyang"                },
 	{ "jst",   0,  32400, "Asia/Seoul"                    },
 	{ "jst",   0,  32400, "Asia/Taipei"                   },
@@ -724,8 +728,8 @@
 	{ "kdt",   1,  34200, "ROK"                           },
 	{ "kdt",   1,  36000, "ROK"                           },
 	{ "kmt",   0,   5736, "Europe/Vilnius"                },
-	{ "kmt",   0, -18430, "America/Grand_Turk"            },
-	{ "kmt",   0, -18430, "America/Jamaica"               },
+	{ "kmt",   0, -18431, "America/Grand_Turk"            },
+	{ "kmt",   0, -18431, "America/Jamaica"               },
 	{ "kmt",   0,   7324, "Europe/Kiev"                   },
 	{ "kst",   0,  30600, "Asia/Seoul"                    },
 	{ "kst",   0,  32400, "Asia/Pyongyang"                },
@@ -762,7 +766,7 @@
 	{ "met",   0,   3600, "MET"                           },
 	{ "mmt",   0,   9017, "Europe/Moscow"                 },
 	{ "mmt",   0,   9079, "Europe/Moscow"                 },
-	{ "mmt",   0, -13491, "America/Montevideo"            },
+	{ "mmt",   0, -13484, "America/Montevideo"            },
 	{ "mmt",   0, -20712, "America/Managua"               },
 	{ "mmt",   0,  -2588, "Africa/Monrovia"               },
 	{ "mmt",   0,  -2670, "Africa/Monrovia"               },
@@ -924,15 +928,18 @@
 	{ "pdt",   1, -25200, "Canada/Pacific"                },
 	{ "pdt",   1, -25200, "Canada/Yukon"                  },
 	{ "pdt",   1, -25200, "Mexico/BajaNorte"              },
-	{ "pdt",   1,  32400, "Asia/Manila"                   },
 	{ "pkst",  1,  21600, "Asia/Karachi"                  },
 	{ "pkt",   0,  18000, "Asia/Karachi"                  },
 	{ "plmt",  0,  25590, "Asia/Ho_Chi_Minh"              },
 	{ "plmt",  0,  25590, "Asia/Saigon"                   },
+	{ "pmmt",  0,  35312, "Pacific/Bougainville"          },
+	{ "pmmt",  0,  35312, "Pacific/Port_Moresby"          },
 	{ "pmt",   0, -13236, "America/Paramaribo"            },
 	{ "pmt",   0, -13252, "America/Paramaribo"            },
 	{ "pmt",   0,  13505, "Asia/Yekaterinburg"            },
 	{ "pmt",   0,  26240, "Asia/Pontianak"                },
+	{ "pmt",   0,   3464, "Europe/Bratislava"             },
+	{ "pmt",   0,   3464, "Europe/Prague"                 },
 	{ "pmt",   0,    561, "Africa/Algiers"                },
 	{ "pmt",   0,    561, "Africa/Tunis"                  },
 	{ "pmt",   0,    561, "Europe/Monaco"                 },
@@ -972,7 +979,6 @@
 	{ "pst",   0, -28800, "Canada/Yukon"                  },
 	{ "pst",   0, -28800, "Mexico/BajaNorte"              },
 	{ "pst",   0, -28800, "Mexico/BajaSur"                },
-	{ "pst",   0,  28800, "Asia/Manila"                   },
 	{ "pwt",   1, -25200, "America/Los_Angeles"           },
 	{ "pwt",   1, -25200, "America/Dawson_Creek"          },
 	{ "pwt",   1, -25200, "America/Ensenada"              },
@@ -989,6 +995,9 @@
 	{ "rmt",   0,   5794, "Europe/Riga"                   },
 	{ "rmt",   0,  23087, "Asia/Rangoon"                  },
 	{ "rmt",   0,  23087, "Asia/Yangon"                   },
+	{ "rmt",   0,   2996, "Europe/Rome"                   },
+	{ "rmt",   0,   2996, "Europe/San_Marino"             },
+	{ "rmt",   0,   2996, "Europe/Vatican"                },
 	{ "sast",  0,   7200, "Africa/Johannesburg"           },
 	{ "sast",  1,  10800, "Africa/Johannesburg"           },
 	{ "sast",  0,   5400, "Africa/Johannesburg"           },
@@ -1001,6 +1010,7 @@
 	{ "sast",  0,   7200, "Africa/Mbabane"                },
 	{ "sast",  0,   7200, "Africa/Windhoek"               },
 	{ "sdmt",  0, -16800, "America/Santo_Domingo"         },
+	{ "set",   0,   3614, "Europe/Stockholm"              },
 	{ "sjmt",  0, -20173, "America/Costa_Rica"            },
 	{ "smt",   0, -13884, "Atlantic/Stanley"              },
 	{ "smt",   0, -16966, "America/Punta_Arenas"          },
@@ -1034,8 +1044,7 @@
 	{ "wat",   0,   3600, "Africa/Ndjamena"               },
 	{ "wat",   0,   3600, "Africa/Niamey"                 },
 	{ "wat",   0,   3600, "Africa/Porto-Novo"             },
-	{ "wat",   0,   3600, "Africa/Sao_Tome"               },
-	{ "wat",   1,   3600, "Africa/Windhoek"               },
+	{ "wat",   0,   3600, "Africa/Windhoek"               },
 	{ "wemt",  1,   7200, "Europe/Lisbon"                 },
 	{ "wemt",  1,   7200, "Europe/Madrid"                 },
 	{ "wemt",  1,   7200, "Europe/Monaco"                 },
@@ -1043,7 +1052,9 @@
 	{ "west",  1,   3600, "Europe/Paris"                  },
 	{ "west",  1,   7200, "Europe/Luxembourg"             },
 	{ "west",  1,   3600, "Africa/Algiers"                },
+	{ "west",  1,   3600, "Africa/Casablanca"             },
 	{ "west",  1,   3600, "Africa/Ceuta"                  },
+	{ "west",  1,   3600, "Africa/El_Aaiun"               },
 	{ "west",  1,   3600, "Atlantic/Canary"               },
 	{ "west",  1,   3600, "Atlantic/Faeroe"               },
 	{ "west",  1,   3600, "Atlantic/Faroe"                },
@@ -1056,7 +1067,9 @@
 	{ "wet",   0,      0, "Europe/Paris"                  },
 	{ "wet",   0,   3600, "Europe/Luxembourg"             },
 	{ "wet",   0,      0, "Africa/Algiers"                },
+	{ "wet",   0,      0, "Africa/Casablanca"             },
 	{ "wet",   0,      0, "Africa/Ceuta"                  },
+	{ "wet",   0,      0, "Africa/El_Aaiun"               },
 	{ "wet",   0,      0, "Atlantic/Azores"               },
 	{ "wet",   0,      0, "Atlantic/Canary"               },
 	{ "wet",   0,      0, "Atlantic/Faeroe"               },

ext/date/lib/tm2unixtime.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/lib/unixtime2tm.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2015 Derick Rethans
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal

ext/date/php_date.c

@@ -60,22 +60,6 @@ static inline long long php_date_llabs( long long i ) { return i >= 0 ? i : -i;
 #endif
 #endif
 
-PHPAPI time_t php_time()
-{
-#ifdef HAVE_GETTIMEOFDAY
-    struct timeval tm;
-
-    if (UNEXPECTED(gettimeofday(&tm, NULL) != SUCCESS)) {
-        /* fallback, can't reasonably happen */
-        return time(NULL);
-    }
-
-    return tm.tv_sec;
-#else
-    return time(NULL);
-#endif
-}
-
 /* {{{ arginfo */
 ZEND_BEGIN_ARG_INFO_EX(arginfo_date, 0, 0, 1)
 	ZEND_ARG_INFO(0, format)
@@ -1299,7 +1283,7 @@ static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
 	ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
 	if (ZEND_NUM_ARGS() == 1) {
-		ts = php_time();
+		ts = time(NULL);
 	}
 
 	RETURN_STR(php_format_date(ZSTR_VAL(format), ZSTR_LEN(format), ts, localtime));
@@ -1464,7 +1448,7 @@ PHP_FUNCTION(idate)
 	}
 
 	if (ZEND_NUM_ARGS() == 1) {
-		ts = php_time();
+		ts = time(NULL);
 	}
 
 	ret = php_idate(ZSTR_VAL(format)[0], ts, 0);
@@ -1536,7 +1520,7 @@ PHP_FUNCTION(strtotime)
 	now->tz_info = tzi;
 	now->zone_type = TIMELIB_ZONETYPE_ID;
 	timelib_unixtime2local(now,
-		(ZEND_NUM_ARGS() == 2) ? (timelib_sll) preset_ts : (timelib_sll) php_time());
+		(ZEND_NUM_ARGS() == 2) ? (timelib_sll) preset_ts : (timelib_sll) time(NULL));
 
 	t = timelib_strtotime(ZSTR_VAL(times), ZSTR_LEN(times), &error,
 		DATE_TIMEZONEDB, php_date_parse_tzfile_wrapper);
@@ -1579,12 +1563,12 @@ PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 	/* Initialize structure with current time */
 	now = timelib_time_ctor();
 	if (gmt) {
-		timelib_unixtime2gmt(now, (timelib_sll) php_time());
+		timelib_unixtime2gmt(now, (timelib_sll) time(NULL));
 	} else {
 		tzi = get_timezone_info();
 		now->tz_info = tzi;
 		now->zone_type = TIMELIB_ZONETYPE_ID;
-		timelib_unixtime2local(now, (timelib_sll) php_time());
+		timelib_unixtime2local(now, (timelib_sll) time(NULL));
 	}
 	/* Fill in the new data */
 	switch (ZEND_NUM_ARGS()) {
@@ -1685,7 +1669,7 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 	timelib_time_offset *offset = NULL;
 	zend_string 		*buf;
 
-	timestamp = (zend_long) php_time();
+	timestamp = (zend_long) time(NULL);
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		Z_PARAM_STR(format)
@@ -1793,7 +1777,7 @@ PHP_FUNCTION(time)
 		return;
 	}
 
-	RETURN_LONG((zend_long)php_time(NULL));
+	RETURN_LONG((zend_long)time(NULL));
 }
 /* }}} */
 
@@ -1801,7 +1785,7 @@ PHP_FUNCTION(time)
    Returns the results of the C system call localtime as an associative array if the associative_array argument is set to 1 other wise it is a regular array */
 PHP_FUNCTION(localtime)
 {
-	zend_long timestamp = (zend_long)php_time();
+	zend_long timestamp = (zend_long)time(NULL);
 	zend_bool associative = 0;
 	timelib_tzinfo *tzi;
 	timelib_time   *ts;
@@ -1850,7 +1834,7 @@ PHP_FUNCTION(localtime)
    Get date/time information */
 PHP_FUNCTION(getdate)
 {
-	zend_long timestamp = (zend_long)php_time();
+	zend_long timestamp = (zend_long)time(NULL);
 	timelib_tzinfo *tzi;
 	timelib_time   *ts;
 

ext/date/php_date.h

@@ -204,8 +204,6 @@ ZEND_END_MODULE_GLOBALS(date)
 
 #define DATEG(v) ZEND_MODULE_GLOBALS_ACCESSOR(date, v)
 
-PHPAPI time_t php_time();
-
 /* Backwards compatibility wrapper */
 PHPAPI zend_long php_parse_date(char *string, zend_long *now);
 PHPAPI void php_mktime(INTERNAL_FUNCTION_PARAMETERS, int gmt);

ext/date/tests/DateTimeZone_listAbbreviations_basic1.phpt

@@ -26,16 +26,16 @@ var_dump( $abbr["acst"] );
 --EXPECTF--
 *** Testing DateTimeZone::listAbbreviations() : basic functionality ***
 string(5) "array"
-int(144)
+int(%d)
 
 -- Format a sample entry --
-array(6) {
+array(12) {
   [0]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(34200)
+    int(32400)
     ["timezone_id"]=>
     string(18) "Australia/Adelaide"
   }
@@ -46,9 +46,63 @@ array(6) {
     ["offset"]=>
     int(34200)
     ["timezone_id"]=>
-    string(21) "Australia/Broken_Hill"
+    string(18) "Australia/Adelaide"
   }
   [2]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(21) "Australia/Broken_Hill"
+  }
+  [3]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(16) "Australia/Darwin"
+  }
+  [4]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(15) "Australia/North"
+  }
+  [5]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(15) "Australia/South"
+  }
+  [6]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(20) "Australia/Yancowinna"
+  }
+  [7]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(34200)
+    ["timezone_id"]=>
+    string(21) "Australia/Broken_Hill"
+  }
+  [8]=>
   array(3) {
     ["dst"]=>
     bool(false)
@@ -57,7 +111,7 @@ array(6) {
     ["timezone_id"]=>
     string(16) "Australia/Darwin"
   }
-  [3]=>
+  [9]=>
   array(3) {
     ["dst"]=>
     bool(false)
@@ -66,7 +120,7 @@ array(6) {
     ["timezone_id"]=>
     string(15) "Australia/North"
   }
-  [4]=>
+  [10]=>
   array(3) {
     ["dst"]=>
     bool(false)
@@ -75,7 +129,7 @@ array(6) {
     ["timezone_id"]=>
     string(15) "Australia/South"
   }
-  [5]=>
+  [11]=>
   array(3) {
     ["dst"]=>
     bool(false)

ext/date/tests/timezone_abbreviations_list_basic1.phpt

@@ -26,16 +26,16 @@ var_dump( $abbr["acst"] );
 --EXPECTF--
 *** Testing timezone_abbreviations_list() : basic functionality ***
 string(5) "array"
-int(144)
+int(%d)
 
 -- Format a sample entry --
-array(6) {
+array(12) {
   [0]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(34200)
+    int(32400)
     ["timezone_id"]=>
     string(18) "Australia/Adelaide"
   }
@@ -46,9 +46,63 @@ array(6) {
     ["offset"]=>
     int(34200)
     ["timezone_id"]=>
-    string(21) "Australia/Broken_Hill"
+    string(18) "Australia/Adelaide"
   }
   [2]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(21) "Australia/Broken_Hill"
+  }
+  [3]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(16) "Australia/Darwin"
+  }
+  [4]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(15) "Australia/North"
+  }
+  [5]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(15) "Australia/South"
+  }
+  [6]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(32400)
+    ["timezone_id"]=>
+    string(20) "Australia/Yancowinna"
+  }
+  [7]=>
+  array(3) {
+    ["dst"]=>
+    bool(false)
+    ["offset"]=>
+    int(34200)
+    ["timezone_id"]=>
+    string(21) "Australia/Broken_Hill"
+  }
+  [8]=>
   array(3) {
     ["dst"]=>
     bool(false)
@@ -57,7 +111,7 @@ array(6) {
     ["timezone_id"]=>
     string(16) "Australia/Darwin"
   }
-  [3]=>
+  [9]=>
   array(3) {
     ["dst"]=>
     bool(false)
@@ -66,7 +120,7 @@ array(6) {
     ["timezone_id"]=>
     string(15) "Australia/North"
   }
-  [4]=>
+  [10]=>
   array(3) {
     ["dst"]=>
     bool(false)
@@ -75,7 +129,7 @@ array(6) {
     ["timezone_id"]=>
     string(15) "Australia/South"
   }
-  [5]=>
+  [11]=>
   array(3) {
     ["dst"]=>
     bool(false)

ext/exif/exif.c

@@ -1516,20 +1516,6 @@ static void php_ifd_set32u(char *data, size_t value, int motorola_intel)
 }
 /* }}} */
 
-static float php_ifd_get_float(char *data) {
-	/* Copy to avoid alignment issues */
-	float f;
-	memcpy(&f, data, sizeof(float));
-	return f;
-}
-
-static double php_ifd_get_double(char *data) {
-	/* Copy to avoid alignment issues */
-	double f;
-	memcpy(&f, data, sizeof(double));
-	return f;
-}
-
 #ifdef EXIF_DEBUG
 char * exif_dump_data(int *dump_free, int format, int components, int length, int motorola_intel, char *value_ptr) /* {{{ */
 {
@@ -1642,12 +1628,12 @@ static double exif_convert_any_format(void *value, int format, int motorola_inte
 #ifdef EXIF_DEBUG
 			php_error_docref(NULL, E_NOTICE, "Found value of type single");
 #endif
-			return (double) php_ifd_get_float(value);
+			return (double)*(float *)value;
 		case TAG_FMT_DOUBLE:
 #ifdef EXIF_DEBUG
 			php_error_docref(NULL, E_NOTICE, "Found value of type double");
 #endif
-			return php_ifd_get_double(value);
+			return *(double *)value;
 	}
 	return 0;
 }
@@ -1705,12 +1691,12 @@ static size_t exif_convert_any_to_int(void *value, int format, int motorola_inte
 #ifdef EXIF_DEBUG
 			php_error_docref(NULL, E_NOTICE, "Found value of type single");
 #endif
-			return (size_t) php_ifd_get_float(value);
+			return (size_t)*(float *)value;
 		case TAG_FMT_DOUBLE:
 #ifdef EXIF_DEBUG
 			php_error_docref(NULL, E_NOTICE, "Found value of type double");
 #endif
-			return (size_t) php_ifd_get_double(value);
+			return (size_t)*(double *)value;
 	}
 	return 0;
 }
@@ -2177,13 +2163,13 @@ static void exif_iif_add_value(image_info_type *image_info, int section_index, c
 #ifdef EXIF_DEBUG
 						php_error_docref(NULL, E_WARNING, "Found value of type single");
 #endif
-						info_value->f = php_ifd_get_float(value);
+						info_value->f = *(float *)value;
 						break;
 					case TAG_FMT_DOUBLE:
 #ifdef EXIF_DEBUG
 						php_error_docref(NULL, E_WARNING, "Found value of type double");
 #endif
-						info_value->d = php_ifd_get_double(value);
+						info_value->d = *(double *)value;
 						break;
 				}
 			}
@@ -3029,11 +3015,11 @@ static int exif_process_user_comment(image_info_type *ImageInfo, char **pszInfoP
 			/* First try to detect BOM: ZERO WIDTH NOBREAK SPACE (FEFF 16)
 			 * since we have no encoding support for the BOM yet we skip that.
 			 */
-			if (ByteCount >=2 && !memcmp(szValuePtr, "\xFE\xFF", 2)) {
+			if (!memcmp(szValuePtr, "\xFE\xFF", 2)) {
 				decode = "UCS-2BE";
 				szValuePtr = szValuePtr+2;
 				ByteCount -= 2;
-			} else if (ByteCount >=2 && !memcmp(szValuePtr, "\xFF\xFE", 2)) {
+			} else if (!memcmp(szValuePtr, "\xFF\xFE", 2)) {
 				decode = "UCS-2LE";
 				szValuePtr = szValuePtr+2;
 				ByteCount -= 2;
@@ -3906,7 +3892,7 @@ static int exif_scan_thumbnail(image_info_type *ImageInfo)
 	size_t          length=2, pos=0;
 	jpeg_sof_info   sof_info;
 
-	if (!data || ImageInfo->Thumbnail.size < 4) {
+	if (!data) {
 		return FALSE; /* nothing to do here */
 	}
 	if (memcmp(data, "\xFF\xD8\xFF", 3)) {

ext/exif/tests/bug78222.phpt

@@ -1,11 +0,0 @@
---TEST--
-Bug #78222 (heap-buffer-overflow on exif_scan_thumbnail)
---SKIPIF--
-<?php if (!extension_loaded('exif')) print 'skip exif extension not available';?>
---FILE--
-<?php
-exif_read_data(__DIR__."/bug78222.jpg", 'THUMBNAIL', FALSE, TRUE);
-?>
-DONE
---EXPECTF--
-DONE

ext/exif/tests/bug78256.phpt

@@ -1,11 +0,0 @@
---TEST--
-Bug #78256 (heap-buffer-overflow on exif_process_user_comment)
---SKIPIF--
-<?php if (!extension_loaded('exif')) print 'skip exif extension not available';?>
---FILE--
-<?php
-@exif_read_data(__DIR__."/bug78256.jpg", 'COMMENT', FALSE, TRUE);
-?>
-DONE
---EXPECTF--
-DONE

ext/fileinfo/tests/finfo_file_002.phpt

@@ -37,8 +37,6 @@ array(%d) {
   string(9) "image/png"
   ["%s/resources/test.ppt"]=>
   string(29) "application/vnd.ms-powerpoint"
-  ["%s/resources/test.tga"]=>
-  string(11) "image/x-tga"
   ["%s/resources/test.webm"]=>
   string(10) "video/webm"
 }

ext/ftp/ftp.c

@@ -287,10 +287,9 @@ ftp_login(ftpbuf_t *ftp, const char *user, const size_t user_len, const char *pa
 		SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_BOTH);
 
 		ftp->ssl_handle = SSL_new(ctx);
-		SSL_CTX_free(ctx);
-
 		if (ftp->ssl_handle == NULL) {
 			php_error_docref(NULL, E_WARNING, "failed to create the SSL handle");
+			SSL_CTX_free(ctx);
 			return 0;
 		}
 

ext/iconv/config.m4

@@ -161,9 +161,6 @@ int main() {
 
 int main() {
   iconv_t cd = iconv_open( "UTF-8//IGNORE", "UTF-8" );
-  if(cd == (iconv_t)-1) {
-    return 1;
-  }
   char *in_p = "\xC3\xC3\xC3\xB8";
   size_t in_left = 4, out_left = 4096;
   char *out = malloc(out_left);

ext/ldap/ldap.c

@@ -279,24 +279,21 @@ static void _php_ldap_control_to_array(LDAP *ld, LDAPControl* ctrl, zval* array,
 static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* array)
 {
 	zval* val;
-	zend_string *control_oid;
+	char * control_oid = NULL;
 	int control_iscritical = 0, rc = LDAP_SUCCESS;
 	char** ldap_attrs = NULL;
 	LDAPSortKey** sort_keys = NULL;
-	zend_string *tmpstring = NULL;
 
 	if ((val = zend_hash_str_find(Z_ARRVAL_P(array), "oid", sizeof("oid") - 1)) == NULL) {
 		php_error_docref(NULL, E_WARNING, "Control must have an oid key");
 		return -1;
 	}
-
-	control_oid = zval_get_string(val);
-	if (EG(exception)) {
-		return -1;
-	}
+	convert_to_string_ex(val);
+	control_oid = Z_STRVAL_P(val);
 
 	if ((val = zend_hash_str_find(Z_ARRVAL_P(array), "iscritical", sizeof("iscritical") - 1)) != NULL) {
-		control_iscritical = zend_is_true(val);
+		convert_to_boolean_ex(val);
+		control_iscritical = (Z_TYPE_P(val) == IS_TRUE);
 	} else {
 		control_iscritical = 0;
 	}
@@ -305,20 +302,16 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 
 	if ((val = zend_hash_str_find(Z_ARRVAL_P(array), "value", sizeof("value") - 1)) != NULL) {
 		if (Z_TYPE_P(val) != IS_ARRAY) {
+			convert_to_string_ex(val);
 			control_value = ber_memalloc(sizeof * control_value);
 			if (control_value == NULL) {
 				rc = -1;
 				php_error_docref(NULL, E_WARNING, "Failed to allocate control value");
 			} else {
-				tmpstring = zval_get_string(val);
-				if (EG(exception)) {
-					rc = -1;
-					goto failure;
-				}
-				control_value->bv_val = ZSTR_VAL(tmpstring);
-				control_value->bv_len = ZSTR_LEN(tmpstring);
+				control_value->bv_val = Z_STRVAL_P(val);
+				control_value->bv_len = Z_STRLEN_P(val);
 			}
-		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_PAGEDRESULTS) == 0) {
+		} else if (strcmp(control_oid, LDAP_CONTROL_PAGEDRESULTS) == 0) {
 			zval* tmp;
 			int pagesize = 1;
 			struct berval cookie = { 0, NULL };
@@ -326,13 +319,9 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 				pagesize = zval_get_long(tmp);
 			}
 			if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "cookie", sizeof("cookie") - 1)) != NULL) {
-				tmpstring = zval_get_string(tmp);
-				if (EG(exception)) {
-					rc = -1;
-					goto failure;
-				}
-				cookie.bv_val = ZSTR_VAL(tmpstring);
-				cookie.bv_len = ZSTR_LEN(tmpstring);
+				convert_to_string_ex(tmp);
+				cookie.bv_val = Z_STRVAL_P(tmp);
+				cookie.bv_len = Z_STRLEN_P(tmp);
 			}
 			control_value = ber_memalloc(sizeof * control_value);
 			if (control_value == NULL) {
@@ -344,18 +333,15 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					php_error_docref(NULL, E_WARNING, "Failed to create paged result control value: %s (%d)", ldap_err2string(rc), rc);
 				}
 			}
-		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_ASSERT) == 0) {
+		} else if (strcmp(control_oid, LDAP_CONTROL_ASSERT) == 0) {
 			zval* tmp;
-			zend_string* assert;
+			char* assert;
 			if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "filter", sizeof("filter") - 1)) == NULL) {
 				rc = -1;
 				php_error_docref(NULL, E_WARNING, "Filter missing from assert control value array");
 			} else {
-				assert = zval_get_string(tmp);
-				if (EG(exception)) {
-					rc = -1;
-					goto failure;
-				}
+				convert_to_string_ex(tmp);
+				assert = Z_STRVAL_P(tmp);
 				control_value = ber_memalloc(sizeof * control_value);
 				if (control_value == NULL) {
 					rc = -1;
@@ -365,14 +351,13 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					// See http://www.openldap.org/its/index.cgi/Incoming?id=8674
 					int success = LDAP_SUCCESS;
 					ldap_set_option(ld, LDAP_OPT_RESULT_CODE, &success);
-					rc = ldap_create_assertion_control_value(ld, ZSTR_VAL(assert), control_value);
+					rc = ldap_create_assertion_control_value(ld, assert, control_value);
 					if (rc != LDAP_SUCCESS) {
 						php_error_docref(NULL, E_WARNING, "Failed to create assert control value: %s (%d)", ldap_err2string(rc), rc);
 					}
 				}
-				zend_string_release(assert);
 			}
-		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_VALUESRETURNFILTER) == 0) {
+		} else if (strcmp(control_oid, LDAP_CONTROL_VALUESRETURNFILTER) == 0) {
 			zval* tmp;
 			if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "filter", sizeof("filter") - 1)) == NULL) {
 				rc = -1;
@@ -384,15 +369,11 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					rc = -1;
 					php_error_docref(NULL, E_WARNING, "Failed to allocate control value");
 				} else {
-					tmpstring = zval_get_string(tmp);
-					if (EG(exception)) {
-						rc = -1;
-						goto failure;
-					}
-					if (ldap_put_vrFilter(vrber, ZSTR_VAL(tmpstring)) == -1) {
+					convert_to_string_ex(tmp);
+					if (ldap_put_vrFilter(vrber, Z_STRVAL_P(tmp)) == -1) {
 						ber_free(vrber, 1);
 						rc = -1;
-						php_error_docref(NULL, E_WARNING, "Failed to create control value: Bad ValuesReturnFilter: %s", ZSTR_VAL(tmpstring));
+						php_error_docref(NULL, E_WARNING, "Failed to create control value: Bad ValuesReturnFilter: %s", Z_STRVAL_P(tmp));
 					} else {
 						if (ber_flatten2(vrber, control_value, 0) == -1) {
 							rc = -1;
@@ -401,7 +382,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					}
 				}
 			}
-		} else if ((strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_PRE_READ) == 0) || (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_POST_READ) == 0)) {
+		} else if ((strcmp(control_oid, LDAP_CONTROL_PRE_READ) == 0) || (strcmp(control_oid, LDAP_CONTROL_POST_READ) == 0)) {
 			zval* tmp;
 			if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "attrs", sizeof("attrs") - 1)) == NULL) {
 				rc = -1;
@@ -427,12 +408,8 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 							goto failure;
 						}
 
-						tmpstring = zval_get_string(attr);
-						if (EG(exception)) {
-							rc = -1;
-							goto failure;
-						}
-						ldap_attrs[i] = ZSTR_VAL(tmpstring);
+						convert_to_string_ex(attr);
+						ldap_attrs[i] = Z_STRVAL_P(attr);
 					}
 					ldap_attrs[num_attribs] = NULL;
 
@@ -451,7 +428,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					}
 				}
 			}
-		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_SORTREQUEST) == 0) {
+		} else if (strcmp(control_oid, LDAP_CONTROL_SORTREQUEST) == 0) {
 			int num_keys, i;
 			zval *sortkey, *tmp;
 
@@ -471,26 +448,19 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					goto failure;
 				}
 				sort_keys[i] = emalloc(sizeof(LDAPSortKey));
-				tmpstring = zval_get_string(tmp);
-				if (EG(exception)) {
-					rc = -1;
-					goto failure;
-				}
-				sort_keys[i]->attributeType = ZSTR_VAL(tmpstring);
+				convert_to_string_ex(tmp);
+				sort_keys[i]->attributeType = Z_STRVAL_P(tmp);
 
 				if ((tmp = zend_hash_str_find(Z_ARRVAL_P(sortkey), "oid", sizeof("oid") - 1)) != NULL) {
-					tmpstring = zval_get_string(tmp);
-					if (EG(exception)) {
-						rc = -1;
-						goto failure;
-					}
-					sort_keys[i]->orderingRule = ZSTR_VAL(tmpstring);
+					convert_to_string_ex(tmp);
+					sort_keys[i]->orderingRule = Z_STRVAL_P(tmp);
 				} else {
 					sort_keys[i]->orderingRule = NULL;
 				}
 
 				if ((tmp = zend_hash_str_find(Z_ARRVAL_P(sortkey), "reverse", sizeof("reverse") - 1)) != NULL) {
-					sort_keys[i]->reverseOrder = zend_is_true(tmp);
+					convert_to_boolean_ex(tmp);
+					sort_keys[i]->reverseOrder = (Z_TYPE_P(tmp) == IS_TRUE);
 				} else {
 					sort_keys[i]->reverseOrder = 0;
 				}
@@ -506,7 +476,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					php_error_docref(NULL, E_WARNING, "Failed to create sort control value: %s (%d)", ldap_err2string(rc), rc);
 				}
 			}
-		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_VLVREQUEST) == 0) {
+		} else if (strcmp(control_oid, LDAP_CONTROL_VLVREQUEST) == 0) {
 			zval* tmp;
 			LDAPVLVInfo vlvInfo;
 			struct berval attrValue;
@@ -529,13 +499,9 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 			}
 
 			if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "attrvalue", sizeof("attrvalue") - 1)) != NULL) {
-				tmpstring = zval_get_string(tmp);
-				if (EG(exception)) {
-					rc = -1;
-					goto failure;
-				}
-				attrValue.bv_val = ZSTR_VAL(tmpstring);
-				attrValue.bv_len = ZSTR_LEN(tmpstring);
+				convert_to_string_ex(tmp);
+				attrValue.bv_val = Z_STRVAL_P(tmp);
+				attrValue.bv_len = Z_STRLEN_P(tmp);
 				vlvInfo.ldvlv_attrvalue = &attrValue;
 			} else if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "offset", sizeof("offset") - 1)) != NULL) {
 				vlvInfo.ldvlv_attrvalue = NULL;
@@ -554,13 +520,9 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 			}
 
 			if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "context", sizeof("context") - 1)) != NULL) {
-				tmpstring = zval_get_string(tmp);
-				if (EG(exception)) {
-					rc = -1;
-					goto failure;
-				}
-				context.bv_val = ZSTR_VAL(tmpstring);
-				context.bv_len = ZSTR_LEN(tmpstring);
+				convert_to_string_ex(tmp);
+				context.bv_val = Z_STRVAL_P(tmp);
+				context.bv_len = Z_STRLEN_P(tmp);
 				vlvInfo.ldvlv_context = &context;
 			} else {
 				vlvInfo.ldvlv_context = NULL;
@@ -577,20 +539,16 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 				}
 			}
 		} else {
-			php_error_docref(NULL, E_WARNING, "Control OID %s does not expect an array as value", ZSTR_VAL(control_oid));
+			php_error_docref(NULL, E_WARNING, "Control OID %s does not expect an array as value", control_oid);
 			rc = -1;
 		}
 	}
 
 	if (rc == LDAP_SUCCESS) {
-		rc = ldap_control_create(ZSTR_VAL(control_oid), control_iscritical, control_value, 1, ctrl);
+		rc = ldap_control_create(control_oid, control_iscritical, control_value, 1, ctrl);
 	}
 
 failure:
-	zend_string_release(control_oid);
-	if (tmpstring != NULL) {
-		zend_string_release(tmpstring);
-	}
 	if (control_value != NULL) {
 		ber_memfree(control_value);
 		control_value = NULL;
@@ -1462,8 +1420,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 {
 	zval *link, *base_dn, *filter, *attrs = NULL, *attr, *serverctrls = NULL;
 	zend_long attrsonly, sizelimit, timelimit, deref;
-	zend_string *ldap_filter = NULL, *ldap_base_dn = NULL;
-	char **ldap_attrs = NULL;
+	char *ldap_base_dn = NULL, *ldap_filter = NULL, **ldap_attrs = NULL;
 	ldap_linkdata *ld = NULL;
 	LDAPMessage *ldap_res;
 	LDAPControl **lserverctrls = NULL;
@@ -1471,7 +1428,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 	int old_ldap_sizelimit = -1, old_ldap_timelimit = -1, old_ldap_deref = -1;
 	int num_attribs = 0, ret = 1, i, errno, argcount = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(argcount, "zzz|alllla/", &link, &base_dn, &filter, &attrs, &attrsonly,
+	if (zend_parse_parameters(argcount, "zzz|alllla", &link, &base_dn, &filter, &attrs, &attrsonly,
 		&sizelimit, &timelimit, &deref, &serverctrls) == FAILURE) {
 		return;
 	}
@@ -1498,11 +1455,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 					goto cleanup;
 				}
 
-				convert_to_string(attr);
-				if (EG(exception)) {
-					ret = 0;
-					goto cleanup;
-				}
+				convert_to_string_ex(attr);
 				ldap_attrs[i] = Z_STRVAL_P(attr);
 			}
 			ldap_attrs[num_attribs] = NULL;
@@ -1533,10 +1486,11 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 			zend_hash_internal_pointer_reset(Z_ARRVAL_P(base_dn));
 		} else {
 			nbases = 0; /* this means string, not array */
-			ldap_base_dn = zval_get_string(base_dn);
-			if (EG(exception)) {
-				ret = 0;
-				goto cleanup;
+			/* If anything else than string is passed, ldap_base_dn = NULL */
+			if (Z_TYPE_P(base_dn) == IS_STRING) {
+				ldap_base_dn = Z_STRVAL_P(base_dn);
+			} else {
+				ldap_base_dn = NULL;
 			}
 		}
 
@@ -1550,11 +1504,8 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 			zend_hash_internal_pointer_reset(Z_ARRVAL_P(filter));
 		} else {
 			nfilters = 0; /* this means string, not array */
-			ldap_filter = zval_get_string(filter);
-			if (EG(exception)) {
-				ret = 0;
-				goto cleanup;
-			}
+			convert_to_string_ex(filter);
+			ldap_filter = Z_STRVAL_P(filter);
 		}
 
 		lds = safe_emalloc(nlinks, sizeof(ldap_linkdata), 0);
@@ -1572,20 +1523,19 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 			if (nbases != 0) { /* base_dn an array? */
 				entry = zend_hash_get_current_data(Z_ARRVAL_P(base_dn));
 				zend_hash_move_forward(Z_ARRVAL_P(base_dn));
-				ldap_base_dn = zval_get_string(entry);
-				if (EG(exception)) {
-					ret = 0;
-					goto cleanup_parallel;
+
+				/* If anything else than string is passed, ldap_base_dn = NULL */
+				if (Z_TYPE_P(entry) == IS_STRING) {
+					ldap_base_dn = Z_STRVAL_P(entry);
+				} else {
+					ldap_base_dn = NULL;
 				}
 			}
 			if (nfilters != 0) { /* filter an array? */
 				entry = zend_hash_get_current_data(Z_ARRVAL_P(filter));
 				zend_hash_move_forward(Z_ARRVAL_P(filter));
-				ldap_filter = zval_get_string(entry);
-				if (EG(exception)) {
-					ret = 0;
-					goto cleanup_parallel;
-				}
+				convert_to_string_ex(entry);
+				ldap_filter = Z_STRVAL_P(entry);
 			}
 
 			if (argcount > 8) {
@@ -1601,7 +1551,7 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 			php_set_opts(ld->link, ldap_sizelimit, ldap_timelimit, ldap_deref, &old_ldap_sizelimit, &old_ldap_timelimit, &old_ldap_deref);
 
 			/* Run the actual search */
-			ldap_search_ext(ld->link, ZSTR_VAL(ldap_base_dn), scope, ZSTR_VAL(ldap_filter), ldap_attrs, ldap_attrsonly, lserverctrls, NULL, NULL, ldap_sizelimit, &rcs[i]);
+			ldap_search_ext(ld->link, ldap_base_dn, scope, ldap_filter, ldap_attrs, ldap_attrsonly, lserverctrls, NULL, NULL, ldap_sizelimit, &rcs[i]);
 			lds[i] = ld;
 			zend_hash_move_forward(Z_ARRVAL_P(link));
 		}
@@ -1625,16 +1575,12 @@ cleanup_parallel:
 		efree(lds);
 		efree(rcs);
 	} else {
-		ldap_filter = zval_get_string(filter);
-		if (EG(exception)) {
-			ret = 0;
-			goto cleanup;
-		}
+		convert_to_string_ex(filter);
+		ldap_filter = Z_STRVAL_P(filter);
 
-		ldap_base_dn = zval_get_string(base_dn);
-		if (EG(exception)) {
-			ret = 0;
-			goto cleanup;
+		/* If anything else than string is passed, ldap_base_dn = NULL */
+		if (Z_TYPE_P(base_dn) == IS_STRING) {
+			ldap_base_dn = Z_STRVAL_P(base_dn);
 		}
 
 		ld = (ldap_linkdata *) zend_fetch_resource_ex(link, "ldap link", le_link);
@@ -1654,7 +1600,7 @@ cleanup_parallel:
 		php_set_opts(ld->link, ldap_sizelimit, ldap_timelimit, ldap_deref, &old_ldap_sizelimit, &old_ldap_timelimit, &old_ldap_deref);
 
 		/* Run the actual search */
-		errno = ldap_search_ext_s(ld->link, ZSTR_VAL(ldap_base_dn), scope, ZSTR_VAL(ldap_filter), ldap_attrs, ldap_attrsonly, lserverctrls, NULL, NULL, ldap_sizelimit, &ldap_res);
+		errno = ldap_search_ext_s(ld->link, ldap_base_dn, scope, ldap_filter, ldap_attrs, ldap_attrsonly, lserverctrls, NULL, NULL, ldap_sizelimit, &ldap_res);
 
 		if (errno != LDAP_SUCCESS
 			&& errno != LDAP_SIZELIMIT_EXCEEDED
@@ -1686,12 +1632,6 @@ cleanup:
 		/* Restoring previous options */
 		php_set_opts(ld->link, old_ldap_sizelimit, old_ldap_timelimit, old_ldap_deref, &ldap_sizelimit, &ldap_timelimit, &ldap_deref);
 	}
-	if (ldap_filter) {
-		zend_string_release(ldap_filter);
-	}
-	if (ldap_base_dn) {
-		zend_string_release(ldap_base_dn);
-	}
 	if (ldap_attrs != NULL) {
 		efree(ldap_attrs);
 	}
@@ -2286,14 +2226,10 @@ static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper, int ext)
 
 /* allow for arrays with one element, no allowance for arrays with none but probably not required, gerrit thomson. */
 		if ((num_values == 1) && (Z_TYPE_P(value) != IS_ARRAY)) {
-			convert_to_string(value);
-			if (EG(exception)) {
-				RETVAL_FALSE;
-				goto cleanup;
-			}
+			convert_to_string_ex(value);
 			ldap_mods[i]->mod_bvalues[0] = (struct berval *) emalloc (sizeof(struct berval));
-			ldap_mods[i]->mod_bvalues[0]->bv_val = Z_STRVAL_P(value);
 			ldap_mods[i]->mod_bvalues[0]->bv_len = Z_STRLEN_P(value);
+			ldap_mods[i]->mod_bvalues[0]->bv_val = Z_STRVAL_P(value);
 		} else {
 			for (j = 0; j < num_values; j++) {
 				if ((ivalue = zend_hash_index_find(Z_ARRVAL_P(value), j)) == NULL) {
@@ -2303,14 +2239,10 @@ static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper, int ext)
 					RETVAL_FALSE;
 					goto cleanup;
 				}
-				convert_to_string(ivalue);
-				if (EG(exception)) {
-					RETVAL_FALSE;
-					goto cleanup;
-				}
+				convert_to_string_ex(ivalue);
 				ldap_mods[i]->mod_bvalues[j] = (struct berval *) emalloc (sizeof(struct berval));
-				ldap_mods[i]->mod_bvalues[j]->bv_val = Z_STRVAL_P(ivalue);
 				ldap_mods[i]->mod_bvalues[j]->bv_len = Z_STRLEN_P(ivalue);
+				ldap_mods[i]->mod_bvalues[j]->bv_val = Z_STRVAL_P(ivalue);
 			}
 		}
 		ldap_mods[i]->mod_bvalues[num_values] = NULL;
@@ -2582,8 +2514,7 @@ PHP_FUNCTION(ldap_modify_batch)
 {
 	zval *serverctrls = NULL;
 	ldap_linkdata *ld;
-	zval *link, *mods, *mod, *modinfo;
-	zend_string *modval;
+	zval *link, *mods, *mod, *modinfo, *modval;
 	zval *attrib, *modtype, *vals;
 	zval *fetched;
 	char *dn;
@@ -2759,6 +2690,13 @@ PHP_FUNCTION(ldap_modify_batch)
 							php_error_docref(NULL, E_WARNING, "A '" LDAP_MODIFY_BATCH_VALUES "' array must have consecutive indices 0, 1, ...");
 							RETURN_FALSE;
 						}
+						modval = fetched;
+
+						/* is the data element a string? */
+						if (Z_TYPE_P(modval) != IS_STRING) {
+							php_error_docref(NULL, E_WARNING, "Each element of a '" LDAP_MODIFY_BATCH_VALUES "' array must be a string");
+							RETURN_FALSE;
+						}
 					}
 				}
 
@@ -2821,21 +2759,14 @@ PHP_FUNCTION(ldap_modify_batch)
 			for (j = 0; j < num_modvals; j++) {
 				/* fetch it */
 				fetched = zend_hash_index_find(Z_ARRVAL_P(vals), j);
-				modval = zval_get_string(fetched);
-				if (EG(exception)) {
-					RETVAL_FALSE;
-					ldap_mods[i]->mod_bvalues[j] = NULL;
-					num_mods = i + 1;
-					goto cleanup;
-				}
+				modval = fetched;
 
 				/* allocate the data struct */
 				ldap_mods[i]->mod_bvalues[j] = safe_emalloc(1, sizeof(struct berval), 0);
 
 				/* fill it */
-				ldap_mods[i]->mod_bvalues[j]->bv_len = ZSTR_LEN(modval);
-				ldap_mods[i]->mod_bvalues[j]->bv_val = estrndup(ZSTR_VAL(modval), ZSTR_LEN(modval));
-				zend_string_release(modval);
+				ldap_mods[i]->mod_bvalues[j]->bv_len = Z_STRLEN_P(modval);
+				ldap_mods[i]->mod_bvalues[j]->bv_val = estrndup(Z_STRVAL_P(modval), Z_STRLEN_P(modval));
 			}
 
 			/* NULL-terminate values */
@@ -3200,7 +3131,6 @@ PHP_FUNCTION(ldap_get_option)
 				}
 				RETURN_FALSE;
 			}
-			zval_ptr_dtor(retval);
 			_php_ldap_controls_to_array(ld->link, ctrls, retval, 1);
 		} break;
 /* options not implemented
@@ -3339,16 +3269,12 @@ PHP_FUNCTION(ldap_set_option)
 	case LDAP_OPT_MATCHED_DN:
 #endif
 		{
-			zend_string *val;
-			val = zval_get_string(newval);
-			if (EG(exception)) {
+			char *val;
+			convert_to_string_ex(newval);
+			val = Z_STRVAL_P(newval);
+			if (ldap_set_option(ldap, option, val)) {
 				RETURN_FALSE;
 			}
-			if (ldap_set_option(ldap, option, ZSTR_VAL(val))) {
-				zend_string_release(val);
-				RETURN_FALSE;
-			}
-			zend_string_release(val);
 		} break;
 		/* options with boolean value */
 	case LDAP_OPT_REFERRALS:
@@ -3360,7 +3286,9 @@ PHP_FUNCTION(ldap_set_option)
 #endif
 		{
 			void *val;
-			val = zend_is_true(newval) ? LDAP_OPT_ON : LDAP_OPT_OFF;
+			convert_to_boolean_ex(newval);
+			val = Z_TYPE_P(newval) == IS_TRUE
+				? LDAP_OPT_ON : LDAP_OPT_OFF;
 			if (ldap_set_option(ldap, option, val)) {
 				RETURN_FALSE;
 			}
@@ -4286,7 +4214,7 @@ PHP_FUNCTION(ldap_exop)
    Passwd modify extended operation */
 PHP_FUNCTION(ldap_exop_passwd)
 {
-	zval *link, *serverctrls;
+	zval *link, *user, *newpw, *oldpw, *serverctrls;
 	struct berval luser, loldpw, lnewpw, lgenpasswd;
 	LDAPControl **lserverctrls = NULL, **requestctrls = NULL;
 	LDAPControl *ctrl, **ctrlp;
@@ -4295,18 +4223,18 @@ PHP_FUNCTION(ldap_exop_passwd)
 	int rc, myargcount = ZEND_NUM_ARGS(), msgid, err;
 	char* errmsg;
 
-	luser.bv_len = 0;
-	loldpw.bv_len = 0;
-	lnewpw.bv_len = 0;
-
-	if (zend_parse_parameters(myargcount, "r|sssz/", &link, &luser.bv_val, &luser.bv_len, &loldpw.bv_val, &loldpw.bv_len, &lnewpw.bv_val, &lnewpw.bv_len, &serverctrls) == FAILURE) {
-		return;
+	if (zend_parse_parameters(myargcount, "r|zzzz/", &link, &user, &oldpw, &newpw, &serverctrls) == FAILURE) {
+		WRONG_PARAM_COUNT;
 	}
 
 	if ((ld = (ldap_linkdata *)zend_fetch_resource(Z_RES_P(link), "ldap link", le_link)) == NULL) {
 		RETURN_FALSE;
 	}
 
+	luser.bv_len = 0;
+	loldpw.bv_len = 0;
+	lnewpw.bv_len = 0;
+
 	switch (myargcount) {
 		case 5:
 			requestctrls = safe_emalloc(2, sizeof(*requestctrls), 0);
@@ -4319,6 +4247,20 @@ PHP_FUNCTION(ldap_exop_passwd)
 			}
 
 			*ctrlp = NULL;
+		case 4:
+			convert_to_string_ex(newpw);
+			lnewpw.bv_val = Z_STRVAL_P(newpw);
+			lnewpw.bv_len = Z_STRLEN_P(newpw);
+
+		case 3:
+			convert_to_string_ex(oldpw);
+			loldpw.bv_val = Z_STRVAL_P(oldpw);
+			loldpw.bv_len = Z_STRLEN_P(oldpw);
+
+		case 2:
+			convert_to_string_ex(user);
+			luser.bv_val = Z_STRVAL_P(user);
+			luser.bv_len = Z_STRLEN_P(user);
 	}
 
 	/* asynchronous call to get result and controls */
@@ -4415,14 +4357,14 @@ PHP_FUNCTION(ldap_exop_whoami)
    DDS refresh extended operation */
 PHP_FUNCTION(ldap_exop_refresh)
 {
-	zval *link, *ttl;
+	zval *link, *dn, *ttl;
 	struct berval ldn;
 	ber_int_t lttl;
 	ber_int_t newttl;
 	ldap_linkdata *ld;
 	int rc;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz", &link, &ldn.bv_val, &ldn.bv_len, &ttl) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rzz", &link, &dn, &ttl) != SUCCESS) {
 		WRONG_PARAM_COUNT;
 	}
 
@@ -4430,6 +4372,10 @@ PHP_FUNCTION(ldap_exop_refresh)
 		RETURN_FALSE;
 	}
 
+	convert_to_string_ex(dn);
+	ldn.bv_val = Z_STRVAL_P(dn);
+	ldn.bv_len = Z_STRLEN_P(dn);
+
 	lttl = (ber_int_t)zval_get_long(ttl);
 
 	rc = ldap_refresh_s(ld->link, &ldn, lttl, &newttl, NULL, NULL);

ext/ldap/tests/bug77958.phpt

@@ -1,55 +0,0 @@
---TEST--
-ldap_modify_batch() - bug 77958 - values in ldap_modify_batch must be "string"
---CREDITS--
-Côme Chilliet <mcmic@php.net>
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
-<?php require_once('skipifbindfailure.inc'); ?>
---FILE--
-<?php
-require "connect.inc";
-
-$link = ldap_connect_and_bind($host, $port, $user, $passwd, $protocol_version);
-insert_dummy_data($link, $base);
-
-$mods = array(
-	array(
-		"attrib"	=> "telephoneNumber",
-		"modtype"	=> LDAP_MODIFY_BATCH_ADD,
-		"values"	=> array(
-			123456
-		)
-	),
-	array(
-		"attrib"	=> "description",
-		"modtype"	=> LDAP_MODIFY_BATCH_REMOVE_ALL
-	)
-);
-
-var_dump(
-	ldap_modify_batch($link, "cn=userA,$base", $mods),
-	$entry = ldap_first_entry($link, ldap_read($link, "cn=userA,$base", "(telephoneNumber=*)")),
-	ldap_get_values($link, $entry, "telephoneNumber")
-);
-?>
-===DONE===
---CLEAN--
-<?php
-require "connect.inc";
-
-$link = ldap_connect_and_bind($host, $port, $user, $passwd, $protocol_version);
-
-remove_dummy_data($link, $base);
-?>
---EXPECTF--
-bool(true)
-resource(%d) of type (ldap result entry)
-array(3) {
-  [0]=>
-  string(14) "xx-xx-xx-xx-xx"
-  [1]=>
-  string(6) "123456"
-  ["count"]=>
-  int(2)
-}
-===DONE===

ext/libxml/libxml.c

@@ -877,14 +877,13 @@ static PHP_RINIT_FUNCTION(libxml)
 		xmlSetGenericErrorFunc(NULL, php_libxml_error_handler);
 		xmlParserInputBufferCreateFilenameDefault(php_libxml_input_buffer_create_filename);
 		xmlOutputBufferCreateFilenameDefault(php_libxml_output_buffer_create_filename);
+
+		/* Enable the entity loader by default. This ensures that
+		 * other threads/requests that might have disabled the loader
+		 * do not affect the current request.
+		 */
+		LIBXML(entity_loader_disabled) = 0;
 	}
-
-	/* Enable the entity loader by default. This ensures that
-	 * other threads/requests that might have disabled the loader
-	 * do not affect the current request.
-	 */
-	LIBXML(entity_loader_disabled) = 0;
-
 	return SUCCESS;
 }
 

ext/mysqli/mysqli_api.c

@@ -637,7 +637,7 @@ PHP_FUNCTION(mysqli_change_user)
 		RETURN_FALSE;
 	}
 #if !defined(MYSQLI_USE_MYSQLND) && defined(HAVE_MYSQLI_SET_CHARSET)
-	if (mysql_get_server_version(mysql->mysql) < 50123L) {
+	if (mysql_get_server_version(mysql->mysql) < 501023L) {
 		/*
 		  Request the current charset, or it will be reset to the system one.
 		  5.0 doesn't support it. Support added in 5.1.23 by fixing the following bug :
@@ -2029,8 +2029,8 @@ PHP_FUNCTION(mysqli_stmt_send_long_data)
 }
 /* }}} */
 
-/* {{{ proto string|int|false mysqli_stmt_affected_rows(object stmt)
-   Return the number of rows affected in the last query for the given link. */
+/* {{{ proto mixed mysqli_stmt_affected_rows(object stmt)
+   Return the number of rows affected in the last query for the given link */
 PHP_FUNCTION(mysqli_stmt_affected_rows)
 {
 	MY_STMT			*stmt;

ext/mysqli/mysqli_priv.h

@@ -90,7 +90,6 @@ PHP_MYSQLI_EXPORT(zend_object *) mysqli_objects_new(zend_class_entry *);
 	mysql->multi_query = 1; \
 }
 
-/* Numbers that cannot be represented as a signed int are converted to a string instead (affects 32-bit builds). */
 #define MYSQLI_RETURN_LONG_INT(__val) \
 { \
 	if ((__val) < ZEND_LONG_MAX) {		\

ext/mysqlnd/mysqlnd_block_alloc.c

@@ -161,7 +161,7 @@ mysqlnd_mempool_create(size_t arena_size)
 	MYSQLND_MEMORY_POOL * ret;
 
 	DBG_ENTER("mysqlnd_mempool_create");
-	arena = mysqlnd_arena_create(MAX(arena_size, ZEND_MM_ALIGNED_SIZE(sizeof(zend_arena))));
+	arena = mysqlnd_arena_create(MAX(arena_size, sizeof(zend_arena)));
 	ret = mysqlnd_arena_alloc(&arena, sizeof(MYSQLND_MEMORY_POOL));
 	ret->arena = arena;
 	ret->last = NULL;

ext/mysqlnd/mysqlnd_connection.c

@@ -1436,14 +1436,6 @@ MYSQLND_METHOD(mysqlnd_conn_data, get_server_version)(const MYSQLND_CONN_DATA *
 		return 0;
 	}
 
-#define MARIA_DB_VERSION_HACK_PREFIX "5.5.5-"
-
-	if (conn->server_capabilities & CLIENT_PLUGIN_AUTH
-		&& !strncmp(p, MARIA_DB_VERSION_HACK_PREFIX, sizeof(MARIA_DB_VERSION_HACK_PREFIX)-1))
-	{
-		p += sizeof(MARIA_DB_VERSION_HACK_PREFIX)-1;
-	}
-
 	major = ZEND_STRTOL(p, &p, 10);
 	p += 1; /* consume the dot */
 	minor = ZEND_STRTOL(p, &p, 10);

ext/mysqlnd/mysqlnd_wireprotocol.c

@@ -392,7 +392,6 @@ php_mysqlnd_greet_read(MYSQLND_CONN_DATA * conn, void * _packet)
 	packet->server_capabilities = uint2korr(p);
 	p+= 2;
 	BAIL_IF_NO_MORE_DATA;
-	DBG_INF_FMT("4.1 server_caps=%u\n", (uint32_t) packet->server_capabilities);
 
 	packet->charset_no = uint1korr(p);
 	p++;
@@ -422,8 +421,7 @@ php_mysqlnd_greet_read(MYSQLND_CONN_DATA * conn, void * _packet)
 		p--;
 
     	/* Additional 16 bits for server capabilities */
-		DBG_INF_FMT("additional 5.5+ caps=%u\n", (uint32_t) uint2korr(pad_start));
-		packet->server_capabilities |= ((uint32_t) uint2korr(pad_start)) << 16;
+		packet->server_capabilities |= uint2korr(pad_start) << 16;
 		/* And a length of the server scramble in one byte */
 		packet->authentication_plugin_data.l = uint1korr(pad_start + 2);
 		if (packet->authentication_plugin_data.l > SCRAMBLE_LENGTH) {

ext/opcache/Optimizer/dce.c

@@ -491,8 +491,7 @@ static void dce_live_ranges(context *ctx, zend_op_array *op_array, zend_ssa *ssa
 
 			if ((op_array->opcodes[def].result_type == IS_UNUSED) &&
 					(UNEXPECTED(op_array->opcodes[def].opcode == ZEND_EXT_STMT) ||
-					UNEXPECTED(op_array->opcodes[def].opcode == ZEND_EXT_FCALL_END) ||
-					UNEXPECTED(op_array->opcodes[def].opcode == ZEND_END_SILENCE))) {
+					UNEXPECTED(op_array->opcodes[def].opcode == ZEND_EXT_FCALL_END))) {
 				def--;
 			}
 

ext/opcache/Optimizer/dfa_pass.c

@@ -125,37 +125,10 @@ int zend_dfa_analyze_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx,
 	return SUCCESS;
 }
 
-static zend_bool is_smart_branch_inhibiting_nop(
-		zend_op_array *op_array, uint32_t target, uint32_t current,
-		zend_basic_block *b, zend_basic_block *blocks_end)
-{
-	uint32_t next;
-	/* Target points one past the last non-nop instruction. Make sure there is one. */
-	if (target == 0) {
-		return 0;
-	}
-
-	/* Find the next instruction, skipping unreachable or empty blocks. */
-	next = current + 1;
-	if (next >= b->start + b->len) {
-		do {
-			b++;
-			if (b == blocks_end) {
-				return 0;
-			}
-		} while (!(b->flags & ZEND_BB_REACHABLE) || b->len == 0);
-		next = b->start;
-	}
-
-	return (op_array->opcodes[next].opcode == ZEND_JMPZ ||
-		 op_array->opcodes[next].opcode == ZEND_JMPNZ) &&
-		zend_is_smart_branch(op_array->opcodes + target - 1);
-}
-
 static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_optimizer_ctx *ctx)
 {
 	zend_basic_block *blocks = ssa->cfg.blocks;
-	zend_basic_block *blocks_end = blocks + ssa->cfg.blocks_count;
+	zend_basic_block *end = blocks + ssa->cfg.blocks_count;
 	zend_basic_block *b;
 	zend_func_info *func_info;
 	int j;
@@ -179,10 +152,11 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 		}
 	}
 
-	for (b = blocks; b < blocks_end; b++) {
+	for (b = blocks; b < end; b++) {
 		if (b->flags & (ZEND_BB_REACHABLE|ZEND_BB_UNREACHABLE_FREE)) {
+			uint32_t end;
+
 			if (b->len) {
-				uint32_t new_start, old_end;
 				while (i < b->start) {
 					shiftlist[i] = i - target;
 					i++;
@@ -195,12 +169,18 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 					b->len = 1;
 				}
 
-				new_start = target;
-				old_end = b->start + b->len;
-				while (i < old_end) {
+				end = b->start + b->len;
+				b->start = target;
+				while (i < end) {
 					shiftlist[i] = i - target;
 					if (EXPECTED(op_array->opcodes[i].opcode != ZEND_NOP) ||
-						is_smart_branch_inhibiting_nop(op_array, target, i, b, blocks_end)) {
+					   /* Keep NOP to support ZEND_VM_SMART_BRANCH. Using "target-1" instead of
+					    * "i-1" here to check the last non-NOP instruction. */
+					   (target > 0 &&
+					    i + 1 < op_array->last &&
+					    (op_array->opcodes[i+1].opcode == ZEND_JMPZ ||
+					     op_array->opcodes[i+1].opcode == ZEND_JMPNZ) &&
+					    zend_is_smart_branch(op_array->opcodes + target - 1))) {
 						if (i != target) {
 							op_array->opcodes[target] = op_array->opcodes[i];
 							ssa->ops[target] = ssa->ops[i];
@@ -210,13 +190,12 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 					}
 					i++;
 				}
-				b->start = new_start;
-				if (target != old_end) {
+				if (target != end) {
 					zend_op *opline;
 					zend_op *new_opline;
 
 					b->len = target - b->start;
-					opline = op_array->opcodes + old_end - 1;
+					opline = op_array->opcodes + end - 1;
 					if (opline->opcode == ZEND_NOP) {
 						continue;
 					}
@@ -261,7 +240,7 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 		}
 
 		/* update branch targets */
-		for (b = blocks; b < blocks_end; b++) {
+		for (b = blocks; b < end; b++) {
 			if ((b->flags & ZEND_BB_REACHABLE) && b->len != 0) {
 				zend_op *opline = op_array->opcodes + b->start + b->len - 1;
 				zend_optimizer_shift_jump(op_array, opline, shiftlist);

ext/opcache/Optimizer/zend_func_info.c

@@ -1019,7 +1019,7 @@ static const func_info_t func_infos[] = {
 	F1("mysqli_query",							MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE | MAY_BE_OBJECT),
 	F0("mysqli_multi_query",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_set_charset",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-	F1("mysqli_get_charset", 					MAY_BE_NULL | MAY_BE_OBJECT),
+	F1("mysqli_get_charset", 					MAY_BE_NULL | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
 	F0("mysqli_begin_transaction",				MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_savepoint",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_release_savepoint",				MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
@@ -1028,7 +1028,7 @@ static const func_info_t func_infos[] = {
 	F1("mysqli_fetch_all",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_ARRAY | MAY_BE_ARRAY_KEY_ANY | MAY_BE_ARRAY_OF_ANY),
 	F1("mysqli_fetch_object",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_OBJECT),
 	F0("mysqli_free_result",					MAY_BE_NULL),
-	F1("mysqli_affected_rows",					MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+	F0("mysqli_affected_rows",					MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_autocommit",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_bind_param",				MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_bind_result",				MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
@@ -1064,14 +1064,14 @@ static const func_info_t func_infos[] = {
 	F0("mysqli_get_server_version",				MAY_BE_NULL | MAY_BE_LONG),
 	F1("mysqli_info",							MAY_BE_NULL | MAY_BE_STRING),
 	F1("mysqli_init",							MAY_BE_FALSE | MAY_BE_OBJECT),
-	F1("mysqli_insert_id",						MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+	F0("mysqli_insert_id",						MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_kill",							MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_more_results",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_next_result",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_more_results",				MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_next_result",				MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_num_fields",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
-	F1("mysqli_num_rows",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG | MAY_BE_STRING),
+	F0("mysqli_num_rows",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),
 	F0("mysqli_options",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_ping",							MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F1("mysqli_prepare",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_OBJECT),
@@ -1080,19 +1080,19 @@ static const func_info_t func_infos[] = {
 	F1("mysqli_real_escape_string",				MAY_BE_NULL | MAY_BE_STRING),
 	F0("mysqli_rollback",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_send_long_data",			MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-	F1("mysqli_stmt_affected_rows",				MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+	F0("mysqli_stmt_affected_rows",				MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_stmt_close",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_data_seek",					MAY_BE_NULL | MAY_BE_FALSE),
 	F0("mysqli_stmt_field_count",				MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_stmt_free_result",				MAY_BE_NULL),
-	F1("mysqli_stmt_insert_id",					MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+	F0("mysqli_stmt_insert_id",					MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_stmt_param_count",				MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_stmt_reset",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-	F1("mysqli_stmt_num_rows",					MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
+	F0("mysqli_stmt_num_rows",					MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_select_db",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F1("mysqli_sqlstate",						MAY_BE_NULL | MAY_BE_STRING),
 	F0("mysqli_ssl_set",						MAY_BE_NULL | MAY_BE_TRUE),
-	F1("mysqli_stat",							MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_STRING),
+	F1("mysqli_stat",							MAY_BE_NULL | MAY_BE_STRING),
 	F0("mysqli_refresh",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_attr_set",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
 	F0("mysqli_stmt_attr_get",					MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_LONG),

ext/opcache/Optimizer/zend_inference.c

@@ -3227,9 +3227,6 @@ static int zend_update_type_info(const zend_op_array *op_array,
 						case ZEND_FETCH_DIM_RW:
 						case ZEND_FETCH_DIM_FUNC_ARG:
 						case ZEND_FETCH_LIST_W:
-						case ZEND_ASSIGN_DIM:
-							tmp |= MAY_BE_ARRAY | MAY_BE_ARRAY_OF_ARRAY;
-							break;
 						case ZEND_ASSIGN_ADD:
 						case ZEND_ASSIGN_SUB:
 						case ZEND_ASSIGN_MUL:
@@ -3242,11 +3239,8 @@ static int zend_update_type_info(const zend_op_array *op_array,
 						case ZEND_ASSIGN_BW_AND:
 						case ZEND_ASSIGN_BW_XOR:
 						case ZEND_ASSIGN_POW:
-							if (op_array->opcodes[j].extended_value == ZEND_ASSIGN_DIM) {
-								tmp |= MAY_BE_ARRAY | MAY_BE_ARRAY_OF_ARRAY;
-							} else if (op_array->opcodes[j].extended_value == ZEND_ASSIGN_OBJ) {
-								tmp |= MAY_BE_ARRAY_OF_OBJECT;
-							}
+						case ZEND_ASSIGN_DIM:
+							tmp |= MAY_BE_ARRAY | MAY_BE_ARRAY_OF_ARRAY;
 							break;
 						case ZEND_FETCH_OBJ_W:
 						case ZEND_FETCH_OBJ_RW:
@@ -3270,7 +3264,6 @@ static int zend_update_type_info(const zend_op_array *op_array,
 						case ZEND_RETURN_BY_REF:
 						case ZEND_VERIFY_RETURN_TYPE:
 						case ZEND_MAKE_REF:
-						case ZEND_FE_RESET_RW:
 							tmp |= MAY_BE_ARRAY_OF_ANY | MAY_BE_ARRAY_OF_REF;
 							break;
 						case ZEND_PRE_INC:

ext/opcache/ZendAccelerator.c

@@ -1707,9 +1707,7 @@ static zend_persistent_script *opcache_compile_file(zend_file_handle *file_handl
 
 	/* check blacklist right after ensuring that file was opened */
 	if (file_handle->opened_path && zend_accel_blacklist_is_blacklisted(&accel_blacklist, ZSTR_VAL(file_handle->opened_path), ZSTR_LEN(file_handle->opened_path))) {
-		SHM_UNPROTECT();
 		ZCSG(blacklist_misses)++;
-		SHM_PROTECT();
 		*op_array_p = accelerator_orig_compile_file(file_handle, type);
 		return NULL;
 	}
@@ -1740,9 +1738,7 @@ static zend_persistent_script *opcache_compile_file(zend_file_handle *file_handl
 		}
 
 		if (ZCG(accel_directives).max_file_size > 0 && size > (size_t)ZCG(accel_directives).max_file_size) {
-			SHM_UNPROTECT();
 			ZCSG(blacklist_misses)++;
-			SHM_PROTECT();
 			*op_array_p = accelerator_orig_compile_file(file_handle, type);
 			return NULL;
 		}
@@ -1910,29 +1906,6 @@ zend_op_array *file_cache_compile_file(zend_file_handle *file_handle, int type)
 }
 #endif
 
-int check_persistent_script_access(zend_persistent_script *persistent_script)
-{
-    char *phar_path, *ptr;
-    int ret;
-    if ((ZSTR_LEN(persistent_script->script.filename)<sizeof("phar://.phar")) ||
-         memcmp(ZSTR_VAL(persistent_script->script.filename), "phar://", sizeof("phar://")-1)) {
-
-        return access(ZSTR_VAL(persistent_script->script.filename), R_OK) != 0;
-
-    } else {
-        /* we got a cached file from .phar, so we have to strip prefix and path inside .phar to check access() */
-        phar_path = estrdup(ZSTR_VAL(persistent_script->script.filename)+sizeof("phar://")-1);
-        if ((ptr = strstr(phar_path, ".phar/")) != NULL)
-        {
-            *(ptr+sizeof(".phar/")-2) = 0; /* strip path inside .phar file */
-        }
-        ret = access(phar_path, R_OK) != 0;
-        efree(phar_path);
-        return ret;
-    }
-}
-
-
 /* zend_compile() replacement */
 zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 {
@@ -2069,7 +2042,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 	if (EXPECTED(persistent_script != NULL) &&
 	    UNEXPECTED(ZCG(accel_directives).validate_permission) &&
 	    file_handle->type == ZEND_HANDLE_FILENAME &&
-	    UNEXPECTED(check_persistent_script_access(persistent_script))) {
+	    UNEXPECTED(access(ZSTR_VAL(persistent_script->script.filename), R_OK) != 0)) {
 		if (type == ZEND_REQUIRE) {
 			zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
 			zend_bailout();
@@ -2153,16 +2126,11 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 			return accelerator_orig_compile_file(file_handle, type);
 		}
 
-		SHM_PROTECT();
-		HANDLE_UNBLOCK_INTERRUPTIONS();
-		persistent_script = opcache_compile_file(file_handle, type, key, &op_array);
-		HANDLE_BLOCK_INTERRUPTIONS();
-		SHM_UNPROTECT();
-
 		/* Try and cache the script and assume that it is returned from_shared_memory.
          * If it isn't compile_and_cache_file() changes the flag to 0
          */
        	from_shared_memory = 0;
+		persistent_script = opcache_compile_file(file_handle, type, key, &op_array);
 		if (persistent_script) {
 			persistent_script = cache_script_in_shared_memory(persistent_script, key, key ? key_length : 0, &from_shared_memory);
 		}

ext/opcache/tests/assign_obj_op_of_fetch_dim.phpt

@@ -1,20 +0,0 @@
---TEST--
-Type inference for $ary[$idx]->prop +=
---FILE--
-<?php
-
-function test() {
-    $ary = [];
-    $ary[0]->y += 2;
-    var_dump(is_object($ary[0]));
-}
-test();
-
-?>
---EXPECTF--
-Notice: Undefined offset: 0 in %s on line %d
-
-Warning: Creating default object from empty value in %s on line %d
-
-Notice: Undefined property: stdClass::$y in %s on line %d
-bool(true)

ext/opcache/tests/block_pass_001.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Block pass: Bugs in BOOL/QM_ASSIGN elision
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 (bool) (true ? $x : $y);

ext/opcache/tests/block_removal_with_duplicate_successors.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Removing a block that has duplicate successors
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function test($foo) {

ext/opcache/tests/bool_cp_in_pass1.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Incorrect constant propagation on BOOL in pass 1
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function test($foo) {

ext/opcache/tests/bug70423.phpt

@@ -5,8 +5,6 @@ open_basedir=.
 opcache.enabled=1
 opcache.enable_cli=1
 opcache.log_verbosity_level=2
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug72762.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #72762: Infinite loop while parsing a file with opcache enabled
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug73654.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #73654: Segmentation fault in zend_call_function
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 echo xyz();

ext/opcache/tests/bug73668.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #73668: "SIGFPE Arithmetic exception" in opcache when divide by minus 1
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 $a/-1;

ext/opcache/tests/bug73746.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #73746 (Method that returns string returns UNKNOWN:0 instead)
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 namespace Core\Bundle\Service\Property\Room\Rooms;

ext/opcache/tests/bug73789.phpt

@@ -1,7 +1,6 @@
 --TEST--
 Bug #73789 (Strange behavior of class constants in switch/case block)
 --SKIPIF--
-<?php require_once('skipif.inc'); ?>
 <?php if (!extension_loaded('ctype')) die('skip extension ctype not loaded'); ?>
 --FILE--
 <?php

ext/opcache/tests/bug73847.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #73847: Recursion when a variable is redefined as array
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function test() {

ext/opcache/tests/bug74431.phpt

@@ -4,8 +4,6 @@ Bug #74431 - foreach infinite loop
 opcache.enable=1
 opcache.enable_cli=1
 opcache.optimization_level=0xffffffff
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function test(){

ext/opcache/tests/bug74442.phpt

@@ -2,8 +2,6 @@
 Bug #74442: Opcached version produces a nested array
 --CREDITS--
 Eric Norris <erictnorris@gmail.com>
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 class Schema_Base {

ext/opcache/tests/bug74623.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #74623: Infinite loop in type inference when using HTMLPurifier
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug75255.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #75255 (Request hangs and not finish)
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function generatePlanImage() {

ext/opcache/tests/bug75570.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #75570 ("Narrowing occurred during type inference" error)
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function renderRawGraph(array $parents) {

ext/opcache/tests/bug75608.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #75608 ("Narrowing occurred during type inference" error)
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 class ReactionRatingService

ext/opcache/tests/bug75729.phpt

@@ -1,7 +1,6 @@
 --TEST--
 Bug #75729: opcache segfault when installing Bitrix
 --SKIPIF--
-<?php require_once('skipif.inc'); ?>
 <?php if (!extension_loaded('mbstring')) die('skip mbstring not loaded'); ?>
 --INI--
 opcache.enable_cli=1

ext/opcache/tests/bug75893.phpt

@@ -3,8 +3,6 @@ Bug #75893: file_get_contents $http_response_header variable bugged with opcache
 --INI--
 opcache.enable_cli=1
 track_errors=1
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug75938.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #75938: Modulus value not stored in variable
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function borken($columns) {

ext/opcache/tests/bug75969.phpt

@@ -3,8 +3,6 @@ Bug #75969: Assertion failure in live range DCE due to block pass misoptimizatio
 --INI--
 opcache.enable_cli=1
 opcache.optimization_level=-1
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug76074.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #76074 (opcache corrupts variable in for-loop)
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug76275.phpt

@@ -4,8 +4,6 @@ Bug #76275: Assertion failure in file cache when unserializing empty try_catch_a
 opcache.enabled=1
 opcache.enable_cli=1
 opcache.file_cache={TMP}
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 if (PHP_VERSION_ID >= 70000) {

ext/opcache/tests/bug76281.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #76281: Opcache causes incorrect "undefined variable" errors
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug76337.phpt

@@ -1,7 +1,6 @@
 --TEST--
 Bug 76337: segmentation fault when an extension use zend_register_class_alias() and opcache enabled
 --SKIPIF--
-<?php require_once('skipif.inc'); ?>
 <?php if (!extension_loaded('zend-test')) die('skip zend-test extension not loaded');
 --INI--
 opcache.enable=1

ext/opcache/tests/bug76796.phpt

@@ -5,8 +5,6 @@ opcache.enable=1
 opcache.enable_cli=1
 opcache.optimization_level=-1
 disable_functions=strpos
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug77058.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #77058: Type inference in opcache causes side effects
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php 
 

ext/opcache/tests/bug77092.phpt

@@ -3,8 +3,6 @@ Bug #77092: array_diff_key() - segmentation fault
 --INI--
 opcache.enable_cli=1
 opcache.optimization_level=-1
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function test() {

ext/opcache/tests/bug77191.phpt

@@ -1,17 +0,0 @@
---TEST--
-Bug #77191: Assertion failure in dce_live_ranges() when silencing is used
---FILE--
-<?php
-function test($x) {
-	switch (@$x['y']) {
-		case 1: return 'a';
-		case 2: return 'b';
-		case 3: return 'c';
-		case 4: return 'd';
-	}
-	return 'e';
-}
-var_dump(test([]));
-?>
---EXPECT--
-string(1) "e"

ext/opcache/tests/bug77215.phpt

@@ -3,8 +3,6 @@ Bug #77215: CFG assertion failure on multiple finalizing switch frees in one blo
 --INI--
 opcache.enable_cli=1
 opcache.optimization_level=-1
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug77257.phpt

@@ -1,7 +1,5 @@
 --TEST--
 Bug #77257: value of variable assigned in a switch() construct gets lost
---SKIPIF--
-<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function test($x) {