Merge remote-tracking branch 'origin/master' into native-tls

* origin/master: (37 commits)
  NEWS
  NEWS
  Fix bug #68601 buffer read overflow in gd_gif_in.c
  Fixed compilation warnings
  Removed unnecessary checks
  pcntl_signal_dispatch: Speed up by preventing system calls when unnecessary
  Merged PR php#911.
  Removed ZEND_ACC_FINAL_CLASS which is unnecessary. This also fixed some currently defined classes as final which were just not being considered as such before.
  Updated NEWS
  Updated NEWS
  Updated NEWS
  Fix bug #68532: convert.base64-encode omits padding bytes
  Updated NEWS
  Updated NEWS
  Updated NEWS
  Fixed Bug #65576 (Constructor from trait conflicts with inherited constructor)
  Updated NEWS
  Updated NEWS
  Fix MySQLi tests
  Fixed gd test
  ...

Author: weltling

NEWS

@@ -22,6 +22,10 @@ PHP                                                                        NEWS
     classes (https://wiki.php.net/rfc/secure_unserialize). (Stas)
   . Fixed bug #68185 ("Inconsistent insteadof definition."- incorrectly triggered). (Julien)
   . Fixed bug #65419 (Inside trait, self::class != __CLASS__). (Julien)
+  . Fixed bug #65576 (Constructor from trait conflicts with inherited
+    constructor). (dunglas at gmail dot com)
+  . Removed ZEND_ACC_FINAL_CLASS, promoting ZEND_ACC_FINAL as final class 
+    modifier. (Guilherme Blanco)
 
 - Date:
   . Fixed day_of_week function as it could sometimes return negative values
@@ -82,6 +86,10 @@ PHP                                                                        NEWS
   . Added intdiv() function. (Andrea)
   . Improved precision of log() function for base 2 and 10. (Marc Bennewitz)
 
+- Streams:
+  . Fixed bug #68532 (convert.base64-encode omits padding bytes).
+    (blaesius at krumedia dot de)
+
 - XSL:
   . Fixed bug #64776 (The XSLT extension is not thread safe). (Mike)
 

UPGRADING.INTERNALS

@@ -13,6 +13,7 @@ PHP 7.0 INTERNALS UPGRADE NOTES
   l. get_class_name object handler info
   m. Other portable macros info
   n. ZEND_ENGINE_2 removal
+  o. Updated final class modifier
 
 2. Build system changes
   a. Unix build system changes
@@ -123,6 +124,9 @@ PHP 7.0 INTERNALS UPGRADE NOTES
      ZEND_NORETURN is defined as __declspec(noreturn) on VS
 
   n. The ZEND_ENGINE_2 macro has been removed. A ZEND_ENGINE_3 macro has been added.
+  
+  o. Removed ZEND_ACC_FINAL_CLASS in favour of ZEND_ACC_FINAL, turning final class
+     modifier now a different class entry flag. Update your extensions.
 
 ========================
 2. Build system changes

Zend/tests/traits/bug65576a.phpt

@@ -0,0 +1,31 @@
+--TEST--
+Bug #65576 (Constructor from trait conflicts with inherited constructor)
+--FILE--
+<?php
+
+trait T
+{
+  public function __construct()
+  {
+    echo "Trait contructor\n";
+  }
+}
+
+class A
+{
+  public function __construct()
+  {
+    echo "Parent constructor\n";
+  }
+}
+
+class B extends A
+{
+  use T;
+}
+
+new B();
+
+--EXPECT--
+Trait contructor
+

Zend/tests/traits/bug65576b.phpt

@@ -0,0 +1,33 @@
+--TEST--
+Bug #65576 (Constructor from trait conflicts with inherited constructor)
+--FILE--
+<?php
+
+trait T
+{
+  public function __construct()
+  {
+    parent::__construct();
+    echo "Trait contructor\n";
+  }
+}
+
+class A
+{
+  public function __construct()
+  {
+    echo "Parent constructor\n";
+  }
+}
+
+class B extends A
+{
+  use T;
+}
+
+new B();
+
+--EXPECT--
+Parent constructor
+Trait contructor
+

Zend/zend_API.c

@@ -404,14 +404,16 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 							if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), p, &d, -1)) == 0) {
 								return "long";
 							} else if (type == IS_DOUBLE) {
-								if (c == 'L') {
-									if (d > ZEND_LONG_MAX) {
-										*p = ZEND_LONG_MAX;
-										break;
-									} else if (d < ZEND_LONG_MIN) {
-										*p = ZEND_LONG_MIN;
-										break;
+								if (zend_isnan(d)) {
+									return "long";
+								}
+								if (!ZEND_DOUBLE_FITS_LONG(d)) {
+									if (c == 'L') {
+										*p = (d > 0) ? ZEND_LONG_MAX : ZEND_LONG_MIN;
+									} else {
+										return "long";
 									}
+									break;
 								}
 
 								*p = zend_dval_to_lval(d);
@@ -420,14 +422,16 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
 						break;
 
 					case IS_DOUBLE:
-						if (c == 'L') {
-							if (Z_DVAL_P(arg) > ZEND_LONG_MAX) {
-								*p = ZEND_LONG_MAX;
-								break;
-							} else if (Z_DVAL_P(arg) < ZEND_LONG_MIN) {
-								*p = ZEND_LONG_MIN;
-								break;
+						if (zend_isnan(Z_DVAL_P(arg))) {
+							return "long";
+						}
+						if (!ZEND_DOUBLE_FITS_LONG(Z_DVAL_P(arg))) {
+							if (c == 'L') {
+								*p = (Z_DVAL_P(arg) > 0) ? ZEND_LONG_MAX : ZEND_LONG_MIN;
+							} else {
+								return "long";
 							}
+							break;
 						}
 					case IS_NULL:
 					case IS_FALSE:
@@ -1127,7 +1131,7 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties TSRMLS_DC)
 }
 /* }}} */
 
-static int zval_update_class_constant(zval *pp, int is_static, int offset TSRMLS_DC) /* {{{ */
+static int zval_update_class_constant(zval *pp, int is_static, uint32_t offset TSRMLS_DC) /* {{{ */
 {
 	ZVAL_DEREF(pp);
 	if (Z_CONSTANT_P(pp)) {
@@ -2195,7 +2199,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 			internal_function->arg_info = (zend_internal_arg_info*)ptr->arg_info+1;
 			internal_function->num_args = ptr->num_args;
 			/* Currently you cannot denote that the function can accept less arguments than num_args */
-			if (info->required_num_args == -1) {
+			if (info->required_num_args == (zend_uintptr_t)-1) {
 				internal_function->required_num_args = ptr->num_args;
 			} else {
 				internal_function->required_num_args = info->required_num_args;

Zend/zend_API.h

@@ -525,7 +525,7 @@ ZEND_API zend_array *zend_rebuild_symbol_table(TSRMLS_D);
 ZEND_API void zend_attach_symbol_table(zend_execute_data *execute_data);
 ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data);
 ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force TSRMLS_DC);
-ZEND_API int zend_set_local_var_str(const char *name, int len, zval *value, int force TSRMLS_DC);
+ZEND_API int zend_set_local_var_str(const char *name, size_t len, zval *value, int force TSRMLS_DC);
 
 ZEND_API zend_string *zend_find_alias_name(zend_class_entry *ce, zend_string *name);
 ZEND_API zend_string *zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
@@ -1064,10 +1064,16 @@ static zend_always_inline int _z_param_long(zval *arg, zend_long *dest, zend_boo
 	if (EXPECTED(Z_TYPE_P(arg) == IS_LONG)) {
 		*dest = Z_LVAL_P(arg);
 	} else if (EXPECTED(Z_TYPE_P(arg) == IS_DOUBLE)) {
-		if (strict && UNEXPECTED(Z_DVAL_P(arg) > ZEND_LONG_MAX)) {
-			*dest = ZEND_LONG_MAX;
-		} else if (strict && UNEXPECTED(Z_DVAL_P(arg) < ZEND_LONG_MIN)) {
-			*dest = ZEND_LONG_MIN;
+		if (UNEXPECTED(zend_isnan(Z_DVAL_P(arg)))) {
+			return 0;
+		}
+		if (UNEXPECTED(!ZEND_DOUBLE_FITS_LONG(Z_DVAL_P(arg)))) {
+			/* Ironically, the strict parameter makes zpp *non*-strict here */
+			if (strict) {
+				*dest = (Z_DVAL_P(arg) > 0) ? ZEND_LONG_MAX : ZEND_LONG_MIN;
+			} else {
+				return 0;
+			}
 		} else {
 			*dest = zend_dval_to_lval(Z_DVAL_P(arg));
 		}
@@ -1077,10 +1083,15 @@ static zend_always_inline int _z_param_long(zval *arg, zend_long *dest, zend_boo
 
 		if (UNEXPECTED((type = is_numeric_str_function(Z_STR_P(arg), dest, &d)) != IS_LONG)) {
 			if (EXPECTED(type != 0)) {
-				if (strict && UNEXPECTED(d > ZEND_LONG_MAX)) {
-					*dest = ZEND_LONG_MAX;
-				} else if (strict && UNEXPECTED(d < ZEND_LONG_MIN)) {
-					*dest = ZEND_LONG_MIN;
+				if (UNEXPECTED(zend_isnan(d))) {
+					return 0;
+				}
+				if (UNEXPECTED(!ZEND_DOUBLE_FITS_LONG(d))) {
+					if (strict) {
+						*dest = (d > 0) ? ZEND_LONG_MAX : ZEND_LONG_MIN;
+					} else {
+						return 0;
+					}
 				} else {
 					*dest = zend_dval_to_lval(d);
 				}

Zend/zend_closures.c

@@ -436,7 +436,7 @@ static const zend_function_entry closure_functions[] = {
 	ZEND_ME(Closure, bind, arginfo_closure_bind, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_MALIAS(Closure, bindTo, bind, arginfo_closure_bindto, ZEND_ACC_PUBLIC)
 	ZEND_ME(Closure, call, arginfo_closure_call, ZEND_ACC_PUBLIC)
-	{NULL, NULL, NULL}
+	ZEND_FE_END
 };
 
 void zend_register_closure_ce(TSRMLS_D) /* {{{ */
@@ -445,7 +445,7 @@ void zend_register_closure_ce(TSRMLS_D) /* {{{ */
 
 	INIT_CLASS_ENTRY(ce, "Closure", closure_functions);
 	zend_ce_closure = zend_register_internal_class(&ce TSRMLS_CC);
-	zend_ce_closure->ce_flags |= ZEND_ACC_FINAL_CLASS;
+	zend_ce_closure->ce_flags |= ZEND_ACC_FINAL;
 	zend_ce_closure->create_object = zend_closure_new;
 	zend_ce_closure->serialize = zend_class_serialize_deny;
 	zend_ce_closure->unserialize = zend_class_unserialize_deny;

Zend/zend_compile.c

@@ -1033,7 +1033,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 				    if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
 						uint32_t *opline_num = &CG(active_op_array)->early_binding;
 
-						while (*opline_num != -1) {
+						while (*opline_num != (uint32_t)-1) {
 							opline_num = &CG(active_op_array)->opcodes[*opline_num].result.opline_num;
 						}
 						*opline_num = opline - CG(active_op_array)->opcodes;
@@ -1074,13 +1074,13 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 
 ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS_DC) /* {{{ */
 {
-	if (op_array->early_binding != -1) {
+	if (op_array->early_binding != (uint32_t)-1) {
 		zend_bool orig_in_compilation = CG(in_compilation);
 		uint32_t opline_num = op_array->early_binding;
 		zend_class_entry *ce;
 
 		CG(in_compilation) = 1;
-		while (opline_num != -1) {
+		while (opline_num != (uint32_t)-1) {
 			if ((ce = zend_lookup_class(Z_STR_P(RT_CONSTANT(op_array, op_array->opcodes[opline_num-1].op2)) TSRMLS_CC)) != NULL) {
 				do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
 			}
@@ -1973,7 +1973,7 @@ static zend_op *zend_compile_simple_var_no_cv(znode *result, zend_ast *ast, uint
 
 	/* there is a chance someone is accessing $this */
 	if (ast->kind != ZEND_AST_ZVAL
-		&& CG(active_op_array)->scope && CG(active_op_array)->this_var == -1
+		&& CG(active_op_array)->scope && CG(active_op_array)->this_var == (uint32_t)-1
 	) {
 		zend_string *key = zend_string_init("this", sizeof("this") - 1, 0);
 		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);

Zend/zend_compile.h

@@ -182,7 +182,6 @@ typedef struct _zend_try_catch_element {
 /* ZEND_ACC_EXPLICIT_ABSTRACT_CLASS denotes that a class was explicitly defined as abstract by using the keyword. */
 #define ZEND_ACC_IMPLICIT_ABSTRACT_CLASS	0x10
 #define ZEND_ACC_EXPLICIT_ABSTRACT_CLASS	0x20
-#define ZEND_ACC_FINAL_CLASS	            0x40
 #define ZEND_ACC_INTERFACE		            0x80
 #define ZEND_ACC_TRAIT						0x120
 

Zend/zend_exceptions.c

@@ -664,7 +664,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_exception___construct, 0, 0, 0)
 	ZEND_ARG_INFO(0, previous)
 ZEND_END_ARG_INFO()
 
-const static zend_function_entry default_exception_functions[] = {
+static const zend_function_entry default_exception_functions[] = {
 	ZEND_ME(exception, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
 	ZEND_ME(exception, __construct, arginfo_exception___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(exception, getMessage, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
@@ -675,7 +675,7 @@ const static zend_function_entry default_exception_functions[] = {
 	ZEND_ME(exception, getPrevious, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
 	ZEND_ME(exception, getTraceAsString, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
 	ZEND_ME(exception, __toString, NULL, 0)
-	{NULL, NULL, NULL}
+	ZEND_FE_END
 };
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_error_exception___construct, 0, 0, 0)
@@ -690,7 +690,7 @@ ZEND_END_ARG_INFO()
 static const zend_function_entry error_exception_functions[] = {
 	ZEND_ME(error_exception, __construct, arginfo_error_exception___construct, ZEND_ACC_PUBLIC)
 	ZEND_ME(error_exception, getSeverity, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
-	{NULL, NULL, NULL}
+	ZEND_FE_END
 };
 /* }}} */
 

Zend/zend_execute.c

@@ -1168,7 +1168,7 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht
 	return retval;
 }
 
-static zend_never_inline zend_long zend_check_string_offset(zval *container, zval *dim, int type TSRMLS_DC)
+static zend_never_inline zend_long zend_check_string_offset(zval *dim, int type TSRMLS_DC)
 {
 	zend_long offset;
 
@@ -1211,7 +1211,7 @@ static zend_never_inline zend_long zend_check_string_offset(zval *container, zva
 
 static zend_always_inline zend_long zend_fetch_string_offset(zval *container, zval *dim, int type TSRMLS_DC)
 {
-	zend_long offset = zend_check_string_offset(container, dim, type TSRMLS_CC);
+	zend_long offset = zend_check_string_offset(dim, type TSRMLS_CC);
 
 	if (Z_REFCOUNTED_P(container)) {
 		if (Z_REFCOUNT_P(container) > 1) {
@@ -1250,7 +1250,7 @@ static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *
 			goto fetch_from_array;
 		}
 
-		zend_check_string_offset(container, dim, type TSRMLS_CC);
+		zend_check_string_offset(dim, type TSRMLS_CC);
 
 		ZVAL_INDIRECT(result, NULL); /* wrong string offset */
 	} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
@@ -1666,12 +1666,12 @@ static zend_always_inline void i_init_func_execute_data(zend_execute_data *execu
 		} while (var != end);
 	}
 
-	if (op_array->this_var != -1 && Z_OBJ(EX(This))) {
+	if (op_array->this_var != (uint32_t)-1 && EXPECTED(Z_OBJ(EX(This)))) {
 		ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EX(This)));
 		GC_REFCOUNT(Z_OBJ(EX(This)))++;
 	}
 
-	if (!op_array->run_time_cache && op_array->last_cache_slot) {
+	if (UNEXPECTED(!op_array->run_time_cache)) {
 		op_array->run_time_cache = zend_arena_calloc(&CG(arena), op_array->last_cache_slot, sizeof(void*));
 	}
 	EX_LOAD_RUN_TIME_CACHE(op_array);
@@ -1691,12 +1691,12 @@ static zend_always_inline void i_init_code_execute_data(zend_execute_data *execu
 
 	zend_attach_symbol_table(execute_data);
 
-	if (op_array->this_var != -1 && Z_OBJ(EX(This))) {
+	if (op_array->this_var != (uint32_t)-1 && EXPECTED(Z_OBJ(EX(This)))) {
 		ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EX(This)));
 		GC_REFCOUNT(Z_OBJ(EX(This)))++;
 	}
 
-	if (!op_array->run_time_cache && op_array->last_cache_slot) {
+	if (!op_array->run_time_cache) {
 		op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*));
 	}
 	EX_LOAD_RUN_TIME_CACHE(op_array);
@@ -1762,12 +1762,12 @@ static zend_always_inline void i_init_execute_data(zend_execute_data *execute_da
 		}
 	}
 
-	if (op_array->this_var != -1 && Z_OBJ(EX(This))) {
+	if (op_array->this_var != (uint32_t)-1 && EXPECTED(Z_OBJ(EX(This)))) {
 		ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EX(This)));
 		GC_REFCOUNT(Z_OBJ(EX(This)))++;
 	}
 
-	if (!op_array->run_time_cache && op_array->last_cache_slot) {
+	if (!op_array->run_time_cache) {
 		if (op_array->function_name) {
 			op_array->run_time_cache = zend_arena_calloc(&CG(arena), op_array->last_cache_slot, sizeof(void*));
 		} else {

Zend/zend_execute_API.c

@@ -218,7 +218,7 @@ void shutdown_destructors(TSRMLS_D) /* {{{ */
 		EG(symbol_table).ht.pDestructor = zend_unclean_zval_ptr_dtor;
 	}
 	zend_try {
-		int symbols;
+		uint32_t symbols;
 		do {
 			symbols = zend_hash_num_elements(&EG(symbol_table).ht);
 			zend_hash_reverse_apply(&EG(symbol_table).ht, (apply_func_t) zval_call_destructor TSRMLS_CC);
@@ -1542,7 +1542,7 @@ ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force TSRMLS
 }
 /* }}} */
 
-ZEND_API int zend_set_local_var_str(const char *name, int len, zval *value, int force TSRMLS_DC) /* {{{ */
+ZEND_API int zend_set_local_var_str(const char *name, size_t len, zval *value, int force TSRMLS_DC) /* {{{ */
 {
 	zend_execute_data *execute_data = EG(current_execute_data);