Prepare PHP 7.3.8

We backport r1092 from pcre2.

(cherry picked from commit 8947fd9e9f)

NEWS

@@ -1,12 +1,71 @@
 PHP                                                                        NEWS
 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
-20 Jun 2019, PHP 7.3.7RC2
+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 #78106 (Path resolution fails if opcache disabled during request).
-    (Nikita)
+  . Fixed bug #78341 (Failure to detect smart branch in DFA pass). (Nikita)
+  . 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)
 
-13 Jun 2019, PHP 7.3.7RC1
+- PCRE:
+  . Fixed bug #78338 (Array cross-border reading in PCRE). (cmb)
+  . Fixed bug #78197 (PCRE2 version check in configure fails for "##.##-xxx"
+    version strings). (pgnet, Peter Kokot)
+
+- 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:
   . Fixed bug #76980 (Interface gets skipped if autoloader throws an exception).
@@ -29,6 +88,8 @@ PHP                                                                        NEWS
 - Opcache:
   . Fixed bug #78015 (Incorrect evaluation of expressions involving partials
     arrays in SCCP). (Nikita)
+  . Fixed bug #78106 (Path resolution fails if opcache disabled during request).
+    (Nikita)
 
 - OpenSSL:
   . Fixed bug #78079 (openssl_encrypt_ccm.phpt fails with OpenSSL 1.1.1c).
@@ -48,7 +109,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 = Int32x32To64(t, 10000000) + 116444736000000000;
+	ll = t * 10000000 + 116444736000000000;
 	pft->dwLowDateTime = (DWORD)ll;
 	pft->dwHighDateTime = ll >> 32;
 }

Zend/tests/assert/expect_020.phpt

@@ -0,0 +1,17 @@
+--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,22 +13,18 @@ spl_autoload_register(function ($className) {
 	}
 });
 
-try {
-    new Foo();
-} catch (Exception $e) { }
-
-// We never reach here.
-var_dump(new Foo());
+new Foo;
 
 ?>
 --EXPECTF--
 string(3) "Foo"
 string(3) "Bar"
 
-Fatal error: During class fetch: Uncaught Exception: Bar in %s:%d
+Fatal error: 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} in %s on line %d
+#4 {main}
+  thrown in %s on line %d

Zend/tests/bug78010.phpt

@@ -0,0 +1,32 @@
+--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

@@ -0,0 +1,27 @@
+--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/zend.h

@@ -20,7 +20,7 @@
 #ifndef ZEND_H
 #define ZEND_H
 
-#define ZEND_VERSION "3.3.7RC2"
+#define ZEND_VERSION "3.3.8"
 
 #define ZEND_ENGINE_3
 

Zend/zend_ast.c

@@ -995,6 +995,11 @@ 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) {
@@ -1042,7 +1047,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_valid_var_char(
+		            !zend_ast_var_needs_braces(
 		                *Z_STRVAL_P(
 		                    zend_ast_get_zval(list->child[i + 1]))))) {
 			zend_ast_export_ex(str, ast, 0, indent);
@@ -1659,6 +1664,8 @@ 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_execute_API.c

@@ -1359,28 +1359,14 @@ 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) {
-			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));
+		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));
 			}
-			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

@@ -150,7 +150,7 @@
 #define GC_DEFAULT_BUF_SIZE  (16 * 1024)
 #define GC_BUF_GROW_STEP     (128 * 1024)
 
-#define GC_MAX_UNCOMPRESSED  (1024 * 1024)
+#define GC_MAX_UNCOMPRESSED  (512 * 1024)
 #define GC_MAX_BUF_SIZE      0x40000000
 
 #define GC_THRESHOLD_DEFAULT 10000
@@ -314,7 +314,10 @@ static void gc_stack_free(gc_stack *stack)
 
 static zend_always_inline uint32_t gc_compress(uint32_t idx)
 {
-	return idx % GC_MAX_UNCOMPRESSED;
+	if (EXPECTED(idx < GC_MAX_UNCOMPRESSED)) {
+		return idx;
+	}
+	return (idx % GC_MAX_UNCOMPRESSED) | GC_MAX_UNCOMPRESSED;
 }
 
 static zend_always_inline gc_root_buffer* gc_decompress(zend_refcounted *ref, uint32_t idx)

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, TMPVARCV, 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, CV, 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, TMPVARCV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_INC, (op1_info == MAY_BE_LONG), ZEND_PRE_INC_LONG, CV, 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, TMPVARCV, 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, CV, 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, TMPVARCV, 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, CV, 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, TMPVARCV, ANY, SPEC(RETVAL))
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_PRE_DEC, (op1_info == MAY_BE_LONG), ZEND_PRE_DEC_LONG, CV, 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, TMPVARCV, 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, CV, 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, TMPVARCV, 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, CV, 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, TMPVARCV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_INC, (op1_info == MAY_BE_LONG), ZEND_POST_INC_LONG, CV, 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, TMPVARCV, ANY)
+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)
 {
 	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, TMPVARCV, 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, CV, 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, TMPVARCV, ANY)
+ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_POST_DEC, (op1_info == MAY_BE_LONG), ZEND_POST_DEC_LONG, CV, 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, TMPVARCV, ANY)
+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)
 {
 	USE_OPLINE
 	zval *var_ptr;

Zend/zend_vm_execute.h

@@ -11048,254 +11048,6 @@ 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
@@ -38219,6 +37971,254 @@ 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_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_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_QM_ASSIGN_DOUBLE_SPEC_CONST_LABEL,
 			(void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
 			(void*)&&ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV_LABEL,
@@ -56458,78 +56458,6 @@ 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);
@@ -59416,6 +59344,78 @@ 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_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_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_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" => "EX_VAR(opline->op1.var)",
+	"TMPVARCV" => "???",
 );
 
 $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" => "EX_VAR(opline->op2.var)",
+	"TMPVARCV" => "???",
 );
 
 $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" => "EX_VAR(opline->op1.var)",
+	"TMPVARCV" => "???",
 );
 
 $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" => "EX_VAR(opline->op2.var)",
+	"TMPVARCV" => "???",
 );
 
 $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_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) \
+	_(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) \
 	_(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=7
-PHP_EXTRA_VERSION="RC2"
+PHP_RELEASE_VERSION=8
+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/date/lib/LICENSE.rst

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2017 Derick Rethans
-Copyright (c) 2017 MongoDB, Inc.
+Copyright (c) 2015-2019 Derick Rethans
+Copyright (c) 2017-2019 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 Derick Rethans
+ * Copyright (c) 2015-2019 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 Derick Rethans
+ * Copyright (c) 2015-2019 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,4 +72,3 @@
 /* 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 Derick Rethans
+ * Copyright (c) 2015-2019 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 Derick Rethans
+ * Copyright (c) 2015-2019 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,7 +1,8 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015 Derick Rethans
+ * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2018 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/parse_iso_intervals.re

@@ -1,7 +1,7 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015 Derick Rethans
+ * Copyright (c) 2015-2019 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,7 +1,8 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015 Derick Rethans
+ * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2018 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
@@ -393,7 +394,7 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
 		tz->type[0].isgmtcnt
 		);
 	for (i = 0; i < tz->bit64.timecnt; i++) {
-		printf ("%016lX (%20ld) = %3d [%5ld %1d %3d '%s' (%d,%d)]\n",
+		printf ("%016" PRIX64 " (%20" PRId64 ") = %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,
@@ -404,7 +405,7 @@ void timelib_dump_tzinfo(timelib_tzinfo *tz)
 			);
 	}
 	for (i = 0; i < tz->bit64.leapcnt; i++) {
-		printf ("%016lX (%20ld) = %d\n",
+		printf ("%016" PRIX64 " (%20ld) = %d\n",
 			tz->leap_times[i].trans,
 			(long) tz->leap_times[i].trans,
 			tz->leap_times[i].offset);
@@ -502,11 +503,6 @@ 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);
@@ -521,6 +517,7 @@ 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);
@@ -607,8 +604,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;
@@ -619,6 +616,7 @@ 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-2017 Derick Rethans
+ * Copyright (c) 2015-2019 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,7 +1,8 @@
 /*
  * The MIT License (MIT)
  *
- * Copyright (c) 2015 Derick Rethans
+ * Copyright (c) 2015-2019 Derick Rethans
+ * Copyright (c) 2018 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
@@ -321,9 +322,9 @@ typedef struct _timelib_tzdb {
 # define timelib_free    free
 #endif
 
-#define TIMELIB_VERSION 201801
-#define TIMELIB_EXTENDED_VERSION 20180105
-#define TIMELIB_ASCII_VERSION "2018.01RC3"
+#define TIMELIB_VERSION 201802
+#define TIMELIB_EXTENDED_VERSION 20180201
+#define TIMELIB_ASCII_VERSION "2018.02"
 
 #define TIMELIB_NONE             0x00
 #define TIMELIB_OVERRIDE_TIME    0x01
@@ -649,7 +650,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
- * abbrevation to the 'tz_addr' field, making sure that if a value was already
+ * abbreviation 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 Derick Rethans
+ * Copyright (c) 2015-2019 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,13 +39,7 @@
 # endif
 #endif
 
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
-
-#ifdef HAVE_STRINGS_H
-# include <strings.h>
-#endif
+#include <string.h>
 
 #ifdef HAVE_SYS_TYPES_H
 #include <sys/types.h>
@@ -68,10 +62,7 @@
 #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,13 +4,7 @@
 	{ "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"               },
@@ -144,20 +138,16 @@
 	{ "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"                  },
@@ -299,7 +289,6 @@
 	{ "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"                  },
@@ -372,7 +361,6 @@
 	{ "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"               },
@@ -645,6 +633,8 @@
 	{ "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"                 },
@@ -672,6 +662,9 @@
 	{ "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"              },
@@ -680,20 +673,23 @@
 	{ "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"                },
@@ -703,7 +699,6 @@
 	{ "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"                  },
@@ -718,6 +713,7 @@
 	{ "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"                   },
@@ -728,8 +724,8 @@
 	{ "kdt",   1,  34200, "ROK"                           },
 	{ "kdt",   1,  36000, "ROK"                           },
 	{ "kmt",   0,   5736, "Europe/Vilnius"                },
-	{ "kmt",   0, -18431, "America/Grand_Turk"            },
-	{ "kmt",   0, -18431, "America/Jamaica"               },
+	{ "kmt",   0, -18430, "America/Grand_Turk"            },
+	{ "kmt",   0, -18430, "America/Jamaica"               },
 	{ "kmt",   0,   7324, "Europe/Kiev"                   },
 	{ "kst",   0,  30600, "Asia/Seoul"                    },
 	{ "kst",   0,  32400, "Asia/Pyongyang"                },
@@ -766,7 +762,7 @@
 	{ "met",   0,   3600, "MET"                           },
 	{ "mmt",   0,   9017, "Europe/Moscow"                 },
 	{ "mmt",   0,   9079, "Europe/Moscow"                 },
-	{ "mmt",   0, -13484, "America/Montevideo"            },
+	{ "mmt",   0, -13491, "America/Montevideo"            },
 	{ "mmt",   0, -20712, "America/Managua"               },
 	{ "mmt",   0,  -2588, "Africa/Monrovia"               },
 	{ "mmt",   0,  -2670, "Africa/Monrovia"               },
@@ -928,18 +924,15 @@
 	{ "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"                 },
@@ -979,6 +972,7 @@
 	{ "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"              },
@@ -995,9 +989,6 @@
 	{ "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"           },
@@ -1010,7 +1001,6 @@
 	{ "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"          },
@@ -1044,7 +1034,8 @@
 	{ "wat",   0,   3600, "Africa/Ndjamena"               },
 	{ "wat",   0,   3600, "Africa/Niamey"                 },
 	{ "wat",   0,   3600, "Africa/Porto-Novo"             },
-	{ "wat",   0,   3600, "Africa/Windhoek"               },
+	{ "wat",   0,   3600, "Africa/Sao_Tome"               },
+	{ "wat",   1,   3600, "Africa/Windhoek"               },
 	{ "wemt",  1,   7200, "Europe/Lisbon"                 },
 	{ "wemt",  1,   7200, "Europe/Madrid"                 },
 	{ "wemt",  1,   7200, "Europe/Monaco"                 },
@@ -1052,9 +1043,7 @@
 	{ "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"                },
@@ -1067,9 +1056,7 @@
 	{ "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 Derick Rethans
+ * Copyright (c) 2015-2019 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 Derick Rethans
+ * Copyright (c) 2015-2019 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,6 +60,22 @@ 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)
@@ -1283,7 +1299,7 @@ static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
 	ZEND_PARSE_PARAMETERS_END_EX(RETURN_FALSE);
 
 	if (ZEND_NUM_ARGS() == 1) {
-		ts = time(NULL);
+		ts = php_time();
 	}
 
 	RETURN_STR(php_format_date(ZSTR_VAL(format), ZSTR_LEN(format), ts, localtime));
@@ -1448,7 +1464,7 @@ PHP_FUNCTION(idate)
 	}
 
 	if (ZEND_NUM_ARGS() == 1) {
-		ts = time(NULL);
+		ts = php_time();
 	}
 
 	ret = php_idate(ZSTR_VAL(format)[0], ts, 0);
@@ -1520,7 +1536,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) time(NULL));
+		(ZEND_NUM_ARGS() == 2) ? (timelib_sll) preset_ts : (timelib_sll) php_time());
 
 	t = timelib_strtotime(ZSTR_VAL(times), ZSTR_LEN(times), &error,
 		DATE_TIMEZONEDB, php_date_parse_tzfile_wrapper);
@@ -1563,12 +1579,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) time(NULL));
+		timelib_unixtime2gmt(now, (timelib_sll) php_time());
 	} else {
 		tzi = get_timezone_info();
 		now->tz_info = tzi;
 		now->zone_type = TIMELIB_ZONETYPE_ID;
-		timelib_unixtime2local(now, (timelib_sll) time(NULL));
+		timelib_unixtime2local(now, (timelib_sll) php_time());
 	}
 	/* Fill in the new data */
 	switch (ZEND_NUM_ARGS()) {
@@ -1669,7 +1685,7 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 	timelib_time_offset *offset = NULL;
 	zend_string 		*buf;
 
-	timestamp = (zend_long) time(NULL);
+	timestamp = (zend_long) php_time();
 
 	ZEND_PARSE_PARAMETERS_START(1, 2)
 		Z_PARAM_STR(format)
@@ -1777,7 +1793,7 @@ PHP_FUNCTION(time)
 		return;
 	}
 
-	RETURN_LONG((zend_long)time(NULL));
+	RETURN_LONG((zend_long)php_time(NULL));
 }
 /* }}} */
 
@@ -1785,7 +1801,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)time(NULL);
+	zend_long timestamp = (zend_long)php_time();
 	zend_bool associative = 0;
 	timelib_tzinfo *tzi;
 	timelib_time   *ts;
@@ -1834,7 +1850,7 @@ PHP_FUNCTION(localtime)
    Get date/time information */
 PHP_FUNCTION(getdate)
 {
-	zend_long timestamp = (zend_long)time(NULL);
+	zend_long timestamp = (zend_long)php_time();
 	timelib_tzinfo *tzi;
 	timelib_time   *ts;
 

ext/date/php_date.h

@@ -204,6 +204,8 @@ 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(%d)
+int(144)
 
 -- Format a sample entry --
-array(12) {
+array(6) {
   [0]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
     string(18) "Australia/Adelaide"
   }
@@ -46,90 +46,36 @@ array(12) {
     ["offset"]=>
     int(34200)
     ["timezone_id"]=>
-    string(18) "Australia/Adelaide"
+    string(21) "Australia/Broken_Hill"
   }
   [2]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
-    string(21) "Australia/Broken_Hill"
+    string(16) "Australia/Darwin"
   }
   [3]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
-    string(16) "Australia/Darwin"
+    string(15) "Australia/North"
   }
   [4]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
-    string(15) "Australia/North"
+    string(15) "Australia/South"
   }
   [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)
-    ["offset"]=>
-    int(34200)
-    ["timezone_id"]=>
-    string(16) "Australia/Darwin"
-  }
-  [9]=>
-  array(3) {
-    ["dst"]=>
-    bool(false)
-    ["offset"]=>
-    int(34200)
-    ["timezone_id"]=>
-    string(15) "Australia/North"
-  }
-  [10]=>
-  array(3) {
-    ["dst"]=>
-    bool(false)
-    ["offset"]=>
-    int(34200)
-    ["timezone_id"]=>
-    string(15) "Australia/South"
-  }
-  [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(%d)
+int(144)
 
 -- Format a sample entry --
-array(12) {
+array(6) {
   [0]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
     string(18) "Australia/Adelaide"
   }
@@ -46,90 +46,36 @@ array(12) {
     ["offset"]=>
     int(34200)
     ["timezone_id"]=>
-    string(18) "Australia/Adelaide"
+    string(21) "Australia/Broken_Hill"
   }
   [2]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
-    string(21) "Australia/Broken_Hill"
+    string(16) "Australia/Darwin"
   }
   [3]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
-    string(16) "Australia/Darwin"
+    string(15) "Australia/North"
   }
   [4]=>
   array(3) {
     ["dst"]=>
     bool(false)
     ["offset"]=>
-    int(32400)
+    int(34200)
     ["timezone_id"]=>
-    string(15) "Australia/North"
+    string(15) "Australia/South"
   }
   [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)
-    ["offset"]=>
-    int(34200)
-    ["timezone_id"]=>
-    string(16) "Australia/Darwin"
-  }
-  [9]=>
-  array(3) {
-    ["dst"]=>
-    bool(false)
-    ["offset"]=>
-    int(34200)
-    ["timezone_id"]=>
-    string(15) "Australia/North"
-  }
-  [10]=>
-  array(3) {
-    ["dst"]=>
-    bool(false)
-    ["offset"]=>
-    int(34200)
-    ["timezone_id"]=>
-    string(15) "Australia/South"
-  }
-  [11]=>
   array(3) {
     ["dst"]=>
     bool(false)

ext/exif/exif.c

@@ -3015,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 (!memcmp(szValuePtr, "\xFE\xFF", 2)) {
+			if (ByteCount >=2 && !memcmp(szValuePtr, "\xFE\xFF", 2)) {
 				decode = "UCS-2BE";
 				szValuePtr = szValuePtr+2;
 				ByteCount -= 2;
-			} else if (!memcmp(szValuePtr, "\xFF\xFE", 2)) {
+			} else if (ByteCount >=2 && !memcmp(szValuePtr, "\xFF\xFE", 2)) {
 				decode = "UCS-2LE";
 				szValuePtr = szValuePtr+2;
 				ByteCount -= 2;
@@ -3892,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) {
+	if (!data || ImageInfo->Thumbnail.size < 4) {
 		return FALSE; /* nothing to do here */
 	}
 	if (memcmp(data, "\xFF\xD8\xFF", 3)) {

ext/exif/tests/bug78222.phpt

@@ -0,0 +1,11 @@
+--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

@@ -0,0 +1,11 @@
+--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,6 +37,8 @@ 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,9 +287,10 @@ 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/ldap/ldap.c

@@ -279,21 +279,24 @@ 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;
-	char * control_oid = NULL;
+	zend_string *control_oid;
 	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;
 	}
-	convert_to_string_ex(val);
-	control_oid = Z_STRVAL_P(val);
+
+	control_oid = zval_get_string(val);
+	if (EG(exception)) {
+		return -1;
+	}
 
 	if ((val = zend_hash_str_find(Z_ARRVAL_P(array), "iscritical", sizeof("iscritical") - 1)) != NULL) {
-		convert_to_boolean_ex(val);
-		control_iscritical = (Z_TYPE_P(val) == IS_TRUE);
+		control_iscritical = zend_is_true(val);
 	} else {
 		control_iscritical = 0;
 	}
@@ -302,16 +305,20 @@ 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 {
-				control_value->bv_val = Z_STRVAL_P(val);
-				control_value->bv_len = Z_STRLEN_P(val);
+				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);
 			}
-		} else if (strcmp(control_oid, LDAP_CONTROL_PAGEDRESULTS) == 0) {
+		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_PAGEDRESULTS) == 0) {
 			zval* tmp;
 			int pagesize = 1;
 			struct berval cookie = { 0, NULL };
@@ -319,9 +326,13 @@ 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) {
-				convert_to_string_ex(tmp);
-				cookie.bv_val = Z_STRVAL_P(tmp);
-				cookie.bv_len = Z_STRLEN_P(tmp);
+				tmpstring = zval_get_string(tmp);
+				if (EG(exception)) {
+					rc = -1;
+					goto failure;
+				}
+				cookie.bv_val = ZSTR_VAL(tmpstring);
+				cookie.bv_len = ZSTR_LEN(tmpstring);
 			}
 			control_value = ber_memalloc(sizeof * control_value);
 			if (control_value == NULL) {
@@ -333,15 +344,18 @@ 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(control_oid, LDAP_CONTROL_ASSERT) == 0) {
+		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_ASSERT) == 0) {
 			zval* tmp;
-			char* assert;
+			zend_string* 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 {
-				convert_to_string_ex(tmp);
-				assert = Z_STRVAL_P(tmp);
+				assert = zval_get_string(tmp);
+				if (EG(exception)) {
+					rc = -1;
+					goto failure;
+				}
 				control_value = ber_memalloc(sizeof * control_value);
 				if (control_value == NULL) {
 					rc = -1;
@@ -351,13 +365,14 @@ 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, assert, control_value);
+					rc = ldap_create_assertion_control_value(ld, ZSTR_VAL(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(control_oid, LDAP_CONTROL_VALUESRETURNFILTER) == 0) {
+		} else if (strcmp(ZSTR_VAL(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;
@@ -369,11 +384,15 @@ 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 {
-					convert_to_string_ex(tmp);
-					if (ldap_put_vrFilter(vrber, Z_STRVAL_P(tmp)) == -1) {
+					tmpstring = zval_get_string(tmp);
+					if (EG(exception)) {
+						rc = -1;
+						goto failure;
+					}
+					if (ldap_put_vrFilter(vrber, ZSTR_VAL(tmpstring)) == -1) {
 						ber_free(vrber, 1);
 						rc = -1;
-						php_error_docref(NULL, E_WARNING, "Failed to create control value: Bad ValuesReturnFilter: %s", Z_STRVAL_P(tmp));
+						php_error_docref(NULL, E_WARNING, "Failed to create control value: Bad ValuesReturnFilter: %s", ZSTR_VAL(tmpstring));
 					} else {
 						if (ber_flatten2(vrber, control_value, 0) == -1) {
 							rc = -1;
@@ -382,7 +401,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					}
 				}
 			}
-		} else if ((strcmp(control_oid, LDAP_CONTROL_PRE_READ) == 0) || (strcmp(control_oid, LDAP_CONTROL_POST_READ) == 0)) {
+		} else if ((strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_PRE_READ) == 0) || (strcmp(ZSTR_VAL(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;
@@ -408,8 +427,12 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 							goto failure;
 						}
 
-						convert_to_string_ex(attr);
-						ldap_attrs[i] = Z_STRVAL_P(attr);
+						tmpstring = zval_get_string(attr);
+						if (EG(exception)) {
+							rc = -1;
+							goto failure;
+						}
+						ldap_attrs[i] = ZSTR_VAL(tmpstring);
 					}
 					ldap_attrs[num_attribs] = NULL;
 
@@ -428,7 +451,7 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					}
 				}
 			}
-		} else if (strcmp(control_oid, LDAP_CONTROL_SORTREQUEST) == 0) {
+		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_SORTREQUEST) == 0) {
 			int num_keys, i;
 			zval *sortkey, *tmp;
 
@@ -448,19 +471,26 @@ static int _php_ldap_control_from_array(LDAP *ld, LDAPControl** ctrl, zval* arra
 					goto failure;
 				}
 				sort_keys[i] = emalloc(sizeof(LDAPSortKey));
-				convert_to_string_ex(tmp);
-				sort_keys[i]->attributeType = Z_STRVAL_P(tmp);
+				tmpstring = zval_get_string(tmp);
+				if (EG(exception)) {
+					rc = -1;
+					goto failure;
+				}
+				sort_keys[i]->attributeType = ZSTR_VAL(tmpstring);
 
 				if ((tmp = zend_hash_str_find(Z_ARRVAL_P(sortkey), "oid", sizeof("oid") - 1)) != NULL) {
-					convert_to_string_ex(tmp);
-					sort_keys[i]->orderingRule = Z_STRVAL_P(tmp);
+					tmpstring = zval_get_string(tmp);
+					if (EG(exception)) {
+						rc = -1;
+						goto failure;
+					}
+					sort_keys[i]->orderingRule = ZSTR_VAL(tmpstring);
 				} else {
 					sort_keys[i]->orderingRule = NULL;
 				}
 
 				if ((tmp = zend_hash_str_find(Z_ARRVAL_P(sortkey), "reverse", sizeof("reverse") - 1)) != NULL) {
-					convert_to_boolean_ex(tmp);
-					sort_keys[i]->reverseOrder = (Z_TYPE_P(tmp) == IS_TRUE);
+					sort_keys[i]->reverseOrder = zend_is_true(tmp);
 				} else {
 					sort_keys[i]->reverseOrder = 0;
 				}
@@ -476,7 +506,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(control_oid, LDAP_CONTROL_VLVREQUEST) == 0) {
+		} else if (strcmp(ZSTR_VAL(control_oid), LDAP_CONTROL_VLVREQUEST) == 0) {
 			zval* tmp;
 			LDAPVLVInfo vlvInfo;
 			struct berval attrValue;
@@ -499,9 +529,13 @@ 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) {
-				convert_to_string_ex(tmp);
-				attrValue.bv_val = Z_STRVAL_P(tmp);
-				attrValue.bv_len = Z_STRLEN_P(tmp);
+				tmpstring = zval_get_string(tmp);
+				if (EG(exception)) {
+					rc = -1;
+					goto failure;
+				}
+				attrValue.bv_val = ZSTR_VAL(tmpstring);
+				attrValue.bv_len = ZSTR_LEN(tmpstring);
 				vlvInfo.ldvlv_attrvalue = &attrValue;
 			} else if ((tmp = zend_hash_str_find(Z_ARRVAL_P(val), "offset", sizeof("offset") - 1)) != NULL) {
 				vlvInfo.ldvlv_attrvalue = NULL;
@@ -520,9 +554,13 @@ 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) {
-				convert_to_string_ex(tmp);
-				context.bv_val = Z_STRVAL_P(tmp);
-				context.bv_len = Z_STRLEN_P(tmp);
+				tmpstring = zval_get_string(tmp);
+				if (EG(exception)) {
+					rc = -1;
+					goto failure;
+				}
+				context.bv_val = ZSTR_VAL(tmpstring);
+				context.bv_len = ZSTR_LEN(tmpstring);
 				vlvInfo.ldvlv_context = &context;
 			} else {
 				vlvInfo.ldvlv_context = NULL;
@@ -539,16 +577,20 @@ 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", control_oid);
+			php_error_docref(NULL, E_WARNING, "Control OID %s does not expect an array as value", ZSTR_VAL(control_oid));
 			rc = -1;
 		}
 	}
 
 	if (rc == LDAP_SUCCESS) {
-		rc = ldap_control_create(control_oid, control_iscritical, control_value, 1, ctrl);
+		rc = ldap_control_create(ZSTR_VAL(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;
@@ -1420,7 +1462,8 @@ 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;
-	char *ldap_base_dn = NULL, *ldap_filter = NULL, **ldap_attrs = NULL;
+	zend_string *ldap_filter = NULL, *ldap_base_dn = NULL;
+	char **ldap_attrs = NULL;
 	ldap_linkdata *ld = NULL;
 	LDAPMessage *ldap_res;
 	LDAPControl **lserverctrls = NULL;
@@ -1428,7 +1471,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;
 	}
@@ -1455,7 +1498,11 @@ static void php_ldap_do_search(INTERNAL_FUNCTION_PARAMETERS, int scope)
 					goto cleanup;
 				}
 
-				convert_to_string_ex(attr);
+				convert_to_string(attr);
+				if (EG(exception)) {
+					ret = 0;
+					goto cleanup;
+				}
 				ldap_attrs[i] = Z_STRVAL_P(attr);
 			}
 			ldap_attrs[num_attribs] = NULL;
@@ -1486,11 +1533,10 @@ 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 */
-			/* 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;
+			ldap_base_dn = zval_get_string(base_dn);
+			if (EG(exception)) {
+				ret = 0;
+				goto cleanup;
 			}
 		}
 
@@ -1504,8 +1550,11 @@ 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 */
-			convert_to_string_ex(filter);
-			ldap_filter = Z_STRVAL_P(filter);
+			ldap_filter = zval_get_string(filter);
+			if (EG(exception)) {
+				ret = 0;
+				goto cleanup;
+			}
 		}
 
 		lds = safe_emalloc(nlinks, sizeof(ldap_linkdata), 0);
@@ -1523,19 +1572,20 @@ 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));
-
-				/* 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;
+				ldap_base_dn = zval_get_string(entry);
+				if (EG(exception)) {
+					ret = 0;
+					goto cleanup_parallel;
 				}
 			}
 			if (nfilters != 0) { /* filter an array? */
 				entry = zend_hash_get_current_data(Z_ARRVAL_P(filter));
 				zend_hash_move_forward(Z_ARRVAL_P(filter));
-				convert_to_string_ex(entry);
-				ldap_filter = Z_STRVAL_P(entry);
+				ldap_filter = zval_get_string(entry);
+				if (EG(exception)) {
+					ret = 0;
+					goto cleanup_parallel;
+				}
 			}
 
 			if (argcount > 8) {
@@ -1551,7 +1601,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, ldap_base_dn, scope, ldap_filter, ldap_attrs, ldap_attrsonly, lserverctrls, NULL, NULL, ldap_sizelimit, &rcs[i]);
+			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]);
 			lds[i] = ld;
 			zend_hash_move_forward(Z_ARRVAL_P(link));
 		}
@@ -1575,12 +1625,16 @@ cleanup_parallel:
 		efree(lds);
 		efree(rcs);
 	} else {
-		convert_to_string_ex(filter);
-		ldap_filter = Z_STRVAL_P(filter);
+		ldap_filter = zval_get_string(filter);
+		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);
+		ldap_base_dn = zval_get_string(base_dn);
+		if (EG(exception)) {
+			ret = 0;
+			goto cleanup;
 		}
 
 		ld = (ldap_linkdata *) zend_fetch_resource_ex(link, "ldap link", le_link);
@@ -1600,7 +1654,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, ldap_base_dn, scope, ldap_filter, ldap_attrs, ldap_attrsonly, lserverctrls, NULL, NULL, ldap_sizelimit, &ldap_res);
+		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);
 
 		if (errno != LDAP_SUCCESS
 			&& errno != LDAP_SIZELIMIT_EXCEEDED
@@ -1632,6 +1686,12 @@ 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);
 	}
@@ -2226,10 +2286,14 @@ 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_ex(value);
+			convert_to_string(value);
+			if (EG(exception)) {
+				RETVAL_FALSE;
+				goto cleanup;
+			}
 			ldap_mods[i]->mod_bvalues[0] = (struct berval *) emalloc (sizeof(struct berval));
-			ldap_mods[i]->mod_bvalues[0]->bv_len = Z_STRLEN_P(value);
 			ldap_mods[i]->mod_bvalues[0]->bv_val = Z_STRVAL_P(value);
+			ldap_mods[i]->mod_bvalues[0]->bv_len = Z_STRLEN_P(value);
 		} else {
 			for (j = 0; j < num_values; j++) {
 				if ((ivalue = zend_hash_index_find(Z_ARRVAL_P(value), j)) == NULL) {
@@ -2239,10 +2303,14 @@ static void php_ldap_do_modify(INTERNAL_FUNCTION_PARAMETERS, int oper, int ext)
 					RETVAL_FALSE;
 					goto cleanup;
 				}
-				convert_to_string_ex(ivalue);
+				convert_to_string(ivalue);
+				if (EG(exception)) {
+					RETVAL_FALSE;
+					goto cleanup;
+				}
 				ldap_mods[i]->mod_bvalues[j] = (struct berval *) emalloc (sizeof(struct berval));
-				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[j]->bv_len = Z_STRLEN_P(ivalue);
 			}
 		}
 		ldap_mods[i]->mod_bvalues[num_values] = NULL;
@@ -2514,7 +2582,8 @@ PHP_FUNCTION(ldap_modify_batch)
 {
 	zval *serverctrls = NULL;
 	ldap_linkdata *ld;
-	zval *link, *mods, *mod, *modinfo, *modval;
+	zval *link, *mods, *mod, *modinfo;
+	zend_string *modval;
 	zval *attrib, *modtype, *vals;
 	zval *fetched;
 	char *dn;
@@ -2690,13 +2759,6 @@ 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;
-						}
 					}
 				}
 
@@ -2759,14 +2821,21 @@ 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 = fetched;
+				modval = zval_get_string(fetched);
+				if (EG(exception)) {
+					RETVAL_FALSE;
+					ldap_mods[i]->mod_bvalues[j] = NULL;
+					num_mods = i + 1;
+					goto cleanup;
+				}
 
 				/* 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 = Z_STRLEN_P(modval);
-				ldap_mods[i]->mod_bvalues[j]->bv_val = estrndup(Z_STRVAL_P(modval), Z_STRLEN_P(modval));
+				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);
 			}
 
 			/* NULL-terminate values */
@@ -3131,6 +3200,7 @@ 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
@@ -3269,12 +3339,16 @@ PHP_FUNCTION(ldap_set_option)
 	case LDAP_OPT_MATCHED_DN:
 #endif
 		{
-			char *val;
-			convert_to_string_ex(newval);
-			val = Z_STRVAL_P(newval);
-			if (ldap_set_option(ldap, option, val)) {
+			zend_string *val;
+			val = zval_get_string(newval);
+			if (EG(exception)) {
 				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:
@@ -3286,9 +3360,7 @@ PHP_FUNCTION(ldap_set_option)
 #endif
 		{
 			void *val;
-			convert_to_boolean_ex(newval);
-			val = Z_TYPE_P(newval) == IS_TRUE
-				? LDAP_OPT_ON : LDAP_OPT_OFF;
+			val = zend_is_true(newval) ? LDAP_OPT_ON : LDAP_OPT_OFF;
 			if (ldap_set_option(ldap, option, val)) {
 				RETURN_FALSE;
 			}
@@ -4214,7 +4286,7 @@ PHP_FUNCTION(ldap_exop)
    Passwd modify extended operation */
 PHP_FUNCTION(ldap_exop_passwd)
 {
-	zval *link, *user, *newpw, *oldpw, *serverctrls;
+	zval *link, *serverctrls;
 	struct berval luser, loldpw, lnewpw, lgenpasswd;
 	LDAPControl **lserverctrls = NULL, **requestctrls = NULL;
 	LDAPControl *ctrl, **ctrlp;
@@ -4223,18 +4295,18 @@ PHP_FUNCTION(ldap_exop_passwd)
 	int rc, myargcount = ZEND_NUM_ARGS(), msgid, err;
 	char* errmsg;
 
-	if (zend_parse_parameters(myargcount, "r|zzzz/", &link, &user, &oldpw, &newpw, &serverctrls) == FAILURE) {
-		WRONG_PARAM_COUNT;
+	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 ((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);
@@ -4247,20 +4319,6 @@ 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 */
@@ -4357,14 +4415,14 @@ PHP_FUNCTION(ldap_exop_whoami)
    DDS refresh extended operation */
 PHP_FUNCTION(ldap_exop_refresh)
 {
-	zval *link, *dn, *ttl;
+	zval *link, *ttl;
 	struct berval ldn;
 	ber_int_t lttl;
 	ber_int_t newttl;
 	ldap_linkdata *ld;
 	int rc;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rzz", &link, &dn, &ttl) != SUCCESS) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS(), "rsz", &link, &ldn.bv_val, &ldn.bv_len, &ttl) != SUCCESS) {
 		WRONG_PARAM_COUNT;
 	}
 
@@ -4372,10 +4430,6 @@ 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

@@ -0,0 +1,55 @@
+--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,13 +877,14 @@ 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) < 501023L) {
+	if (mysql_get_server_version(mysql->mysql) < 50123L) {
 		/*
 		  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 mixed mysqli_stmt_affected_rows(object stmt)
-   Return the number of rows affected in the last query for the given link */
+/* {{{ proto string|int|false 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,6 +90,7 @@ 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_wireprotocol.c

@@ -392,6 +392,7 @@ 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++;
@@ -421,7 +422,8 @@ php_mysqlnd_greet_read(MYSQLND_CONN_DATA * conn, void * _packet)
 		p--;
 
     	/* Additional 16 bits for server capabilities */
-		packet->server_capabilities |= uint2korr(pad_start) << 16;
+		DBG_INF_FMT("additional 5.5+ caps=%u\n", (uint32_t) uint2korr(pad_start));
+		packet->server_capabilities |= ((uint32_t) 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/dfa_pass.c

@@ -125,10 +125,37 @@ 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 *end = blocks + ssa->cfg.blocks_count;
+	zend_basic_block *blocks_end = blocks + ssa->cfg.blocks_count;
 	zend_basic_block *b;
 	zend_func_info *func_info;
 	int j;
@@ -152,11 +179,10 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 		}
 	}
 
-	for (b = blocks; b < end; b++) {
+	for (b = blocks; b < blocks_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++;
@@ -169,18 +195,12 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 					b->len = 1;
 				}
 
-				end = b->start + b->len;
-				b->start = target;
-				while (i < end) {
+				new_start = target;
+				old_end = b->start + b->len;
+				while (i < old_end) {
 					shiftlist[i] = i - target;
 					if (EXPECTED(op_array->opcodes[i].opcode != ZEND_NOP) ||
-					   /* 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))) {
+						is_smart_branch_inhibiting_nop(op_array, target, i, b, blocks_end)) {
 						if (i != target) {
 							op_array->opcodes[target] = op_array->opcodes[i];
 							ssa->ops[target] = ssa->ops[i];
@@ -190,12 +210,13 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 					}
 					i++;
 				}
-				if (target != end) {
+				b->start = new_start;
+				if (target != old_end) {
 					zend_op *opline;
 					zend_op *new_opline;
 
 					b->len = target - b->start;
-					opline = op_array->opcodes + end - 1;
+					opline = op_array->opcodes + old_end - 1;
 					if (opline->opcode == ZEND_NOP) {
 						continue;
 					}
@@ -240,7 +261,7 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa, zend_op
 		}
 
 		/* update branch targets */
-		for (b = blocks; b < end; b++) {
+		for (b = blocks; b < blocks_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/sccp.c

@@ -2204,6 +2204,7 @@ static int try_remove_definition(sccp_ctx *ctx, int var_num, zend_ssa_var *var,
 				if (opline->opcode == ZEND_DO_ICALL) {
 					removed_ops = remove_call(ctx, opline, ssa_op);
 				} else if (opline->opcode == ZEND_TYPE_CHECK
+						&& opline->op1_type & (IS_VAR|IS_TMP_VAR)
 						&& !value_known(&ctx->values[ssa_op->op1_use])) {
 					/* For TYPE_CHECK we may compute the result value without knowing the
 					 * operand, based on type inference information. Make sure the operand is

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_ARRAY | MAY_BE_ARRAY_KEY_STRING | MAY_BE_ARRAY_OF_ANY),
+	F1("mysqli_get_charset", 					MAY_BE_NULL | MAY_BE_OBJECT),
 	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),
-	F0("mysqli_affected_rows",					MAY_BE_NULL | MAY_BE_LONG),
+	F1("mysqli_affected_rows",					MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
 	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),
-	F0("mysqli_insert_id",						MAY_BE_NULL | MAY_BE_LONG),
+	F1("mysqli_insert_id",						MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
 	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),
-	F0("mysqli_num_rows",						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_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),
-	F0("mysqli_stmt_affected_rows",				MAY_BE_NULL | MAY_BE_LONG),
+	F1("mysqli_stmt_affected_rows",				MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
 	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),
-	F0("mysqli_stmt_insert_id",					MAY_BE_NULL | MAY_BE_LONG),
+	F1("mysqli_stmt_insert_id",					MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
 	F0("mysqli_stmt_param_count",				MAY_BE_NULL | MAY_BE_LONG),
 	F0("mysqli_stmt_reset",						MAY_BE_NULL | MAY_BE_FALSE | MAY_BE_TRUE),
-	F0("mysqli_stmt_num_rows",					MAY_BE_NULL | MAY_BE_LONG),
+	F1("mysqli_stmt_num_rows",					MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING),
 	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_STRING),
+	F1("mysqli_stat",							MAY_BE_NULL | MAY_BE_FALSE | 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,6 +3227,9 @@ 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:
@@ -3239,8 +3242,11 @@ 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:
-						case ZEND_ASSIGN_DIM:
-							tmp |= MAY_BE_ARRAY | MAY_BE_ARRAY_OF_ARRAY;
+							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;
+							}
 							break;
 						case ZEND_FETCH_OBJ_W:
 						case ZEND_FETCH_OBJ_RW:
@@ -3264,6 +3270,7 @@ 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

@@ -1906,6 +1906,29 @@ 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)
 {
@@ -1918,6 +1941,13 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 		/* The Accelerator is disabled, act as if without the Accelerator */
 		ZCG(cache_opline) = NULL;
 		ZCG(cache_persistent_script) = NULL;
+#ifdef HAVE_OPCACHE_FILE_CACHE
+		if (file_handle->filename
+		 && ZCG(accel_directives).file_cache
+		 && ZCG(enabled) && accel_startup_ok) {
+			return file_cache_compile_file(file_handle, type);
+		}
+#endif
 		return accelerator_orig_compile_file(file_handle, type);
 #ifdef HAVE_OPCACHE_FILE_CACHE
 	} else if (file_cache_only) {
@@ -2035,7 +2065,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(access(ZSTR_VAL(persistent_script->script.filename), R_OK) != 0)) {
+	    UNEXPECTED(check_persistent_script_access(persistent_script))) {
 		if (type == ZEND_REQUIRE) {
 			zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename);
 			zend_bailout();

ext/opcache/tests/assign_obj_op_of_fetch_dim.phpt

@@ -0,0 +1,20 @@
+--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,5 +1,7 @@
 --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,5 +1,7 @@
 --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,5 +1,7 @@
 --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,6 +5,8 @@ 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,5 +1,7 @@
 --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,5 +1,7 @@
 --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,5 +1,7 @@
 --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,5 +1,7 @@
 --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,6 +1,7 @@
 --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,5 +1,7 @@
 --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,6 +4,8 @@ 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,6 +2,8 @@
 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,5 +1,7 @@
 --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,5 +1,7 @@
 --TEST--
 Bug #75255 (Request hangs and not finish)
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 function generatePlanImage() {

ext/opcache/tests/bug75570.phpt

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

ext/opcache/tests/bug76275.phpt

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

ext/opcache/tests/bug76337.phpt

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

ext/opcache/tests/bug77092.phpt

@@ -3,6 +3,8 @@ 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/bug77215.phpt

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

ext/opcache/tests/bug77275.phpt

@@ -3,6 +3,8 @@ Bug #77275: OPcache optimization problem for ArrayAccess->offsetGet(string)
 --INI--
 opcache.enable_cli=1
 opcache.optimization_level=-1
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 namespace Foo;

ext/opcache/tests/bug77310_1.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Bug #77310 (1): Incorrect SCCP for compound assign to arrays
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug77691.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Bug #77691: Opcache passes wrong value for inline array push assignments
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug77743.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Bug #77743: Incorrect pi node insertion for jmpznz with identical successors
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug78015.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Bug #78015: Incorrect evaluation of expressions involving partials array in SCCP
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug78106.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Bug #78106: Path resolution fails if opcache disabled during request
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/bug78185.phpt

@@ -0,0 +1,39 @@
+--TEST--
+Bug #78185: file cache only no longer works
+--INI--
+opcache.enable_cli=1
+opcache.optimization_level=-1
+opcache.file_cache={PWD}
+opcache.file_cache_only=1
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
+--FILE--
+<?php
+if (substr(PHP_OS, 0, 3) !== 'WIN') {
+	$pattern = __DIR__ . '/*/' . __DIR__ . '/*78185.php.bin';
+} else {
+	$pattern = __DIR__ . '/*/*/' . str_replace(':', '', __DIR__) . '/*78185.php.bin';
+}
+foreach (glob($pattern) as $p) {
+	var_dump($p);
+}
+?>
+--CLEAN--
+<?php
+if (substr(PHP_OS, 0, 3) !== 'WIN') {
+	$pattern = __DIR__ . '/*/' . __DIR__ . '/*78185.php.bin';
+} else {
+	$pattern = __DIR__ . '/*/*/' . str_replace(':', '', __DIR__) . '/*78185.php.bin';
+}
+foreach (glob($pattern) as $p) {
+	unlink($p);
+	$p = dirname($p);
+	while(strlen($p) > strlen(__DIR__)) {
+		rmdir($p);
+		$p = dirname($p);
+	}
+}
+?>
+--EXPECTF--
+string(%d) "%s78185.php.bin"
+

ext/opcache/tests/bug78189.phpt

@@ -0,0 +1,29 @@
+--TEST--
+Bug #78189 (file cache strips last character of uname hash)
+--SKIPIF--
+<?php
+if (!extension_loaded('Zend OPcache')) die('skip opcache extension not available');
+if (substr(PHP_OS, 0, 3) !== 'WIN') die('skip this test is for Windows platforms only');
+?>
+--INI--
+opcache.enable_cli=1
+opcache.optimization_level=-1
+opcache.file_cache={TMP}
+opcache.file_cache_only=1
+--FILE--
+<?php
+$tmpdir = sys_get_temp_dir();
+$pattern = $tmpdir . '/*/*/' . str_replace(':', '', __DIR__) . '/bug78189.php.bin';
+$filenames = glob($pattern);
+if (count($filenames)) {
+    foreach ($filenames as $filename) {
+        $part = substr($filename, strlen($tmpdir), 34);
+        if (!preg_match('~/[0-9a-f]{32}/~', $part)) {
+            echo "invalid opcache folder: $part\n";
+        }
+    }
+} else {
+    echo "no opcache file found!\n";
+}
+?>
+--EXPECT--

ext/opcache/tests/bug78230.phpt

@@ -0,0 +1,29 @@
+--TEST--
+Bug #78230: Incorrect type check optimization
+--FILE--
+<?php
+
+function test($x) {
+    $y = (array) $x;
+    var_dump(is_array($y));
+}
+
+$ary = [1, 2];
+$ary[] = 3;
+test($ary);
+$ary[] = 4;
+var_dump($ary);
+
+?>
+--EXPECT--
+bool(true)
+array(4) {
+  [0]=>
+  int(1)
+  [1]=>
+  int(2)
+  [2]=>
+  int(3)
+  [3]=>
+  int(4)
+}

ext/opcache/tests/bug78341.phpt

@@ -0,0 +1,21 @@
+--TEST--
+Bug #78341: Failure to detect smart branch in DFA pass
+--FILE--
+<?php
+
+function test($a) {
+    // Just some dead code...
+    if (strpos("foo", "foo") !== 0) {
+        echo "Foo";
+    }
+
+    $x = $a === null;
+    if ($x) {
+        var_dump($x);
+    }
+}
+test(null);
+
+?>
+--EXPECT--
+bool(true)

ext/opcache/tests/get_configuration_matches_ini.phpt

@@ -0,0 +1,17 @@
+--TEST--
+Test that the directives listed with `opcache_get_configuration` include all those from the ini settings.
+--INI--
+opcache.enable=1
+opcache.enable_cli=1
+opcache.opt_debug_level=0
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
+--FILE--
+<?php
+$opts = opcache_get_configuration()['directives'];
+$inis = ini_get_all('zend opcache');
+var_dump(array_diff_key($inis, $opts));
+?>
+--EXPECT--
+array(0) {
+}

ext/opcache/tests/invalid_array_key_type.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Don't add array value type is key type is illegal
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/invalid_new_dce.phpt

@@ -3,6 +3,8 @@ Throwings NEWs should not be DCEd
 --INI--
 opcache.enable_cli=1
 opcache.optimization_level=-1
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/jmp_elim_004.phpt

@@ -3,6 +3,8 @@ Incorrect empty basic block elimination
 --INI--
 opcache.enable_cli=1
 opcache.optimization_level=-1
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/jmpz_jmp_elim.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Edge-cases in elimination of JMPZ JMP with same target
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/method_call_on_literal.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Literal compaction should take method calls on literals into account
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/neg_range_inference.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Incorrect negative range inference
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php
 

ext/opcache/tests/optimize_func_calls_001.phpt

@@ -1,5 +1,7 @@
 --TEST--
 Don't create FETCH_DIM_R with UNUSED op2
+--SKIPIF--
+<?php require_once('skipif.inc'); ?>
 --FILE--
 <?php