From 1dd9de58fed5fe17f1ef1869ab1d11e5ef71c581 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:48 +0100 Subject: [PATCH 01/28] pcrelib produces sign-conversion warnings --- ext/pcre/config0.m4 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/pcre/config0.m4 b/ext/pcre/config0.m4 index 6d18b9ecf7919..f5773b503ccfb 100644 --- a/ext/pcre/config0.m4 +++ b/ext/pcre/config0.m4 @@ -66,7 +66,7 @@ else pcre2lib/pcre2_string_utils.c pcre2lib/pcre2_study.c pcre2lib/pcre2_substitute.c pcre2lib/pcre2_substring.c \ pcre2lib/pcre2_tables.c pcre2lib/pcre2_ucd.c pcre2lib/pcre2_valid_utf.c pcre2lib/pcre2_xclass.c \ pcre2lib/pcre2_find_bracket.c pcre2lib/pcre2_convert.c pcre2lib/pcre2_extuni.c pcre2lib/pcre2_script_run.c" - PHP_PCRE_CFLAGS="-Wno-implicit-fallthrough -DHAVE_CONFIG_H -DHAVE_MEMMOVE -I@ext_srcdir@/pcre2lib -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" + PHP_PCRE_CFLAGS="-Wno-implicit-fallthrough -Wno-sign-conversion -DHAVE_CONFIG_H -DHAVE_MEMMOVE -I@ext_srcdir@/pcre2lib -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" AC_DEFINE(HAVE_BUNDLED_PCRE, 1, [ ]) AC_DEFINE(PCRE2_CODE_UNIT_WIDTH, 8, [ ]) From 037d11f8c4b45796ee18e8a09c16741d6c05a36f Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:48 +0100 Subject: [PATCH 02/28] Timelib generates sign-conversion warnings --- ext/date/config0.m4 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/date/config0.m4 b/ext/date/config0.m4 index 6b803bf33e55b..140313007468f 100644 --- a/ext/date/config0.m4 +++ b/ext/date/config0.m4 @@ -4,7 +4,7 @@ AC_CHECK_HEADERS([io.h]) dnl Check for strtoll, atoll AC_CHECK_FUNCS(strtoll atoll) -PHP_DATE_CFLAGS="-Wno-implicit-fallthrough -I@ext_builddir@/lib -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1 -DHAVE_TIMELIB_CONFIG_H=1" +PHP_DATE_CFLAGS="-Wno-implicit-fallthrough -Wno-sign-conversion -I@ext_builddir@/lib -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1 -DHAVE_TIMELIB_CONFIG_H=1" timelib_sources="lib/astro.c lib/dow.c lib/parse_date.c lib/parse_tz.c lib/parse_posix.c lib/timelib.c lib/tm2unixtime.c lib/unixtime2tm.c lib/parse_iso_intervals.c lib/interval.c" From 5f0c1bb7cb1134b33d60d85f01434b2121b60ba2 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:49 +0100 Subject: [PATCH 03/28] Hash extension's algorithm generate sign-conversion warnings --- ext/hash/config.m4 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/hash/config.m4 b/ext/hash/config.m4 index f87d00bf86e34..7946074315545 100644 --- a/ext/hash/config.m4 +++ b/ext/hash/config.m4 @@ -26,7 +26,7 @@ else ]) EXT_HASH_SHA3_SOURCES="$SHA3_OPT_SRC $SHA3_DIR/KeccakHash.c $SHA3_DIR/KeccakSponge.c hash_sha3.c" dnl Add -Wno-implicit-fallthrough flag as it happens on 32 bit builds - PHP_HASH_CFLAGS="-Wno-implicit-fallthrough -I@ext_srcdir@/$SHA3_DIR -DKeccakP200_excluded -DKeccakP400_excluded -DKeccakP800_excluded -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" + PHP_HASH_CFLAGS="-Wno-implicit-fallthrough -Wno-sign-conversion -I@ext_srcdir@/$SHA3_DIR -DKeccakP200_excluded -DKeccakP400_excluded -DKeccakP800_excluded -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" PHP_ADD_BUILD_DIR(ext/hash/$SHA3_DIR, 1) fi From 63d65406e862da9f4f5ab93604b3bba39cc5a35f Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:49 +0100 Subject: [PATCH 04/28] Add type casts in zend_operators.h --- Zend/zend_operators.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h index e9f48bc496f96..755d3c49fd2cf 100644 --- a/Zend/zend_operators.h +++ b/Zend/zend_operators.h @@ -169,7 +169,7 @@ zend_memnstr(const char *haystack, const char *needle, size_t needle_len, const ZEND_ASSERT(end >= p); if (needle_len == 1) { - return (const char *)memchr(p, *needle, (end-p)); + return (const char *)memchr(p, *needle, (size_t)(end-p)); } else if (UNEXPECTED(needle_len == 0)) { return p; } @@ -185,7 +185,7 @@ zend_memnstr(const char *haystack, const char *needle, size_t needle_len, const end -= needle_len; while (p <= end) { - if ((p = (const char *)memchr(p, *needle, (end-p+1)))) { + if ((p = (const char *)memchr(p, *needle, (size_t)(end-p+1)))) { if (ne == p[needle_len-1] && !memcmp(needle+1, p+1, needle_len-2)) { return p; } @@ -234,7 +234,7 @@ zend_memnrstr(const char *haystack, const char *needle, size_t needle_len, const } if (needle_len == 1) { - return (const char *)zend_memrchr(haystack, *needle, (p - haystack)); + return (const char *)zend_memrchr(haystack, *needle, (size_t)(p - haystack)); } off_p = end - haystack; @@ -249,7 +249,7 @@ zend_memnrstr(const char *haystack, const char *needle, size_t needle_len, const p -= needle_len; do { - p = (const char *)zend_memrchr(haystack, *needle, (p - haystack) + 1); + p = (const char *)zend_memrchr(haystack, *needle, (size_t)(p - haystack) + 1); if (!p) { return NULL; } @@ -895,7 +895,7 @@ static zend_always_inline char *zend_print_long_to_buf(char *buf, zend_long num) *--result = '-'; return result; } else { - return zend_print_ulong_to_buf(buf, num); + return zend_print_ulong_to_buf(buf, (zend_ulong)num); } } From 224225229827d416a03dbc901ab336809afcdb91 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:49 +0100 Subject: [PATCH 05/28] Mark char* as unsigned --- Zend/zend_string.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/zend_string.h b/Zend/zend_string.h index 2be7e7d267224..d61bebd90c8bf 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -459,7 +459,7 @@ static zend_always_inline bool zend_string_starts_with_ci(const zend_string *str * -- Ralf S. Engelschall */ -static zend_always_inline zend_ulong zend_inline_hash_func(const char *str, size_t len) +static zend_always_inline zend_ulong zend_inline_hash_func(const unsigned char *str, size_t len) { zend_ulong hash = Z_UL(5381); From 861d05a8124c4ba609b496504d8a7413da628b35 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:50 +0100 Subject: [PATCH 06/28] Add unsigned suffix for bitmask flags --- Zend/zend_compile.h | 336 +++++++++++++++++++++--------------------- Zend/zend_hash.h | 26 ++-- Zend/zend_string.h | 18 +-- Zend/zend_type_info.h | 46 +++--- Zend/zend_types.h | 134 ++++++++--------- 5 files changed, 280 insertions(+), 280 deletions(-) diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 6a5626492ec73..f4291d3972558 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -210,174 +210,174 @@ typedef struct _zend_oparray_context { /* ============ | | | */ /* | | | */ /* Visibility flags (public < protected < private) | | | */ -#define ZEND_ACC_PUBLIC (1 << 0) /* | X | X | X */ -#define ZEND_ACC_PROTECTED (1 << 1) /* | X | X | X */ -#define ZEND_ACC_PRIVATE (1 << 2) /* | X | X | X */ +#define ZEND_ACC_PUBLIC (1u << 0u) /* | X | X | X */ +#define ZEND_ACC_PROTECTED (1u << 1u) /* | X | X | X */ +#define ZEND_ACC_PRIVATE (1u << 2u) /* | X | X | X */ /* | | | */ /* Property or method overrides private one | | | */ -#define ZEND_ACC_CHANGED (1 << 3) /* | X | X | */ +#define ZEND_ACC_CHANGED (1u << 3u) /* | X | X | */ /* | | | */ /* Static method or property | | | */ -#define ZEND_ACC_STATIC (1 << 4) /* | X | X | */ +#define ZEND_ACC_STATIC (1u << 4u) /* | X | X | */ /* | | | */ /* Promoted property / parameter | | | */ -#define ZEND_ACC_PROMOTED (1 << 5) /* | | X | X */ +#define ZEND_ACC_PROMOTED (1u << 5u) /* | | X | X */ /* | | | */ /* Final class or method | | | */ -#define ZEND_ACC_FINAL (1 << 5) /* X | X | | */ +#define ZEND_ACC_FINAL (1u << 5u) /* X | X | | */ /* | | | */ /* Abstract method | | | */ -#define ZEND_ACC_ABSTRACT (1 << 6) /* X | X | | */ -#define ZEND_ACC_EXPLICIT_ABSTRACT_CLASS (1 << 6) /* X | | | */ +#define ZEND_ACC_ABSTRACT (1u << 6u) /* X | X | | */ +#define ZEND_ACC_EXPLICIT_ABSTRACT_CLASS (1u << 6u) /* X | | | */ /* | | | */ /* Readonly property | | | */ -#define ZEND_ACC_READONLY (1 << 7) /* | | X | */ +#define ZEND_ACC_READONLY (1u << 7u) /* | | X | */ /* | | | */ /* Immutable op_array and class_entries | | | */ /* (implemented only for lazy loading of op_arrays) | | | */ -#define ZEND_ACC_IMMUTABLE (1 << 7) /* X | X | | */ +#define ZEND_ACC_IMMUTABLE (1u << 7u) /* X | X | | */ /* | | | */ /* Function has typed arguments / class has typed props | | | */ -#define ZEND_ACC_HAS_TYPE_HINTS (1 << 8) /* X | X | | */ +#define ZEND_ACC_HAS_TYPE_HINTS (1u << 8u) /* X | X | | */ /* | | | */ /* Top-level class or function declaration | | | */ -#define ZEND_ACC_TOP_LEVEL (1 << 9) /* X | X | | */ +#define ZEND_ACC_TOP_LEVEL (1u << 9u) /* X | X | | */ /* | | | */ /* op_array or class is preloaded | | | */ -#define ZEND_ACC_PRELOADED (1 << 10) /* X | X | | */ +#define ZEND_ACC_PRELOADED (1u << 10u) /* X | X | | */ /* | | | */ /* Flag to differentiate cases from constants. | | | */ /* Must not conflict with ZEND_ACC_ visibility flags | | | */ /* or IS_CONSTANT_VISITED_MARK | | | */ -#define ZEND_CLASS_CONST_IS_CASE (1 << 6) /* | | | X */ +#define ZEND_CLASS_CONST_IS_CASE (1u << 6u) /* | | | X */ /* | | | */ /* Class Flags (unused: 30,31) | | | */ /* =========== | | | */ /* | | | */ /* Special class types | | | */ -#define ZEND_ACC_INTERFACE (1 << 0) /* X | | | */ -#define ZEND_ACC_TRAIT (1 << 1) /* X | | | */ -#define ZEND_ACC_ANON_CLASS (1 << 2) /* X | | | */ -#define ZEND_ACC_ENUM (1 << 28) /* X | | | */ +#define ZEND_ACC_INTERFACE (1u << 0u) /* X | | | */ +#define ZEND_ACC_TRAIT (1u << 1u) /* X | | | */ +#define ZEND_ACC_ANON_CLASS (1u << 2u) /* X | | | */ +#define ZEND_ACC_ENUM (1u << 28u) /* X | | | */ /* | | | */ /* Class linked with parent, interfaces and traits | | | */ -#define ZEND_ACC_LINKED (1 << 3) /* X | | | */ +#define ZEND_ACC_LINKED (1u << 3u) /* X | | | */ /* | | | */ /* Class is abstract, since it is set by any | | | */ /* abstract method | | | */ -#define ZEND_ACC_IMPLICIT_ABSTRACT_CLASS (1 << 4) /* X | | | */ +#define ZEND_ACC_IMPLICIT_ABSTRACT_CLASS (1u << 4u) /* X | | | */ /* | | | */ /* Class has magic methods __get/__set/__unset/ | | | */ /* __isset that use guards | | | */ -#define ZEND_ACC_USE_GUARDS (1 << 11) /* X | | | */ +#define ZEND_ACC_USE_GUARDS (1u << 11u) /* X | | | */ /* | | | */ /* Class constants updated | | | */ -#define ZEND_ACC_CONSTANTS_UPDATED (1 << 12) /* X | | | */ +#define ZEND_ACC_CONSTANTS_UPDATED (1u << 12u) /* X | | | */ /* | | | */ /* Objects of this class may not have dynamic properties | | | */ -#define ZEND_ACC_NO_DYNAMIC_PROPERTIES (1 << 13) /* X | | | */ +#define ZEND_ACC_NO_DYNAMIC_PROPERTIES (1u << 13u) /* X | | | */ /* | | | */ /* User class has methods with static variables | | | */ -#define ZEND_HAS_STATIC_IN_METHODS (1 << 14) /* X | | | */ +#define ZEND_HAS_STATIC_IN_METHODS (1u << 14u) /* X | | | */ /* | | | */ /* Objects of this class may have dynamic properties | | | */ /* without triggering a deprecation warning | | | */ -#define ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES (1 << 15) /* X | | | */ +#define ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES (1u << 15u) /* X | | | */ /* | | | */ /* Readonly class | | | */ -#define ZEND_ACC_READONLY_CLASS (1 << 16) /* X | | | */ +#define ZEND_ACC_READONLY_CLASS (1u << 16u) /* X | | | */ /* | | | */ /* Parent class is resolved (CE). | | | */ -#define ZEND_ACC_RESOLVED_PARENT (1 << 17) /* X | | | */ +#define ZEND_ACC_RESOLVED_PARENT (1u << 17u) /* X | | | */ /* | | | */ /* Interfaces are resolved (CEs). | | | */ -#define ZEND_ACC_RESOLVED_INTERFACES (1 << 18) /* X | | | */ +#define ZEND_ACC_RESOLVED_INTERFACES (1u << 18u) /* X | | | */ /* | | | */ /* Class has unresolved variance obligations. | | | */ -#define ZEND_ACC_UNRESOLVED_VARIANCE (1 << 19) /* X | | | */ +#define ZEND_ACC_UNRESOLVED_VARIANCE (1u << 19u) /* X | | | */ /* | | | */ /* Class is linked apart from variance obligations. | | | */ -#define ZEND_ACC_NEARLY_LINKED (1 << 20) /* X | | | */ +#define ZEND_ACC_NEARLY_LINKED (1u << 20u) /* X | | | */ /* Class has readonly props | | | */ -#define ZEND_ACC_HAS_READONLY_PROPS (1 << 21) /* X | | | */ +#define ZEND_ACC_HAS_READONLY_PROPS (1u << 21u) /* X | | | */ /* | | | */ /* stored in opcache (may be partially) | | | */ -#define ZEND_ACC_CACHED (1 << 22) /* X | | | */ +#define ZEND_ACC_CACHED (1u << 22u) /* X | | | */ /* | | | */ /* temporary flag used during delayed variance checks | | | */ -#define ZEND_ACC_CACHEABLE (1 << 23) /* X | | | */ +#define ZEND_ACC_CACHEABLE (1u << 23u) /* X | | | */ /* | | | */ -#define ZEND_ACC_HAS_AST_CONSTANTS (1 << 24) /* X | | | */ -#define ZEND_ACC_HAS_AST_PROPERTIES (1 << 25) /* X | | | */ -#define ZEND_ACC_HAS_AST_STATICS (1 << 26) /* X | | | */ +#define ZEND_ACC_HAS_AST_CONSTANTS (1u << 24u) /* X | | | */ +#define ZEND_ACC_HAS_AST_PROPERTIES (1u << 25u) /* X | | | */ +#define ZEND_ACC_HAS_AST_STATICS (1u << 26u) /* X | | | */ /* | | | */ /* loaded from file cache to process memory | | | */ -#define ZEND_ACC_FILE_CACHED (1 << 27) /* X | | | */ +#define ZEND_ACC_FILE_CACHED (1u << 27u) /* X | | | */ /* | | | */ /* Class cannot be serialized or unserialized | | | */ -#define ZEND_ACC_NOT_SERIALIZABLE (1 << 29) /* X | | | */ +#define ZEND_ACC_NOT_SERIALIZABLE (1u << 29u) /* X | | | */ /* | | | */ /* Function Flags (unused: 29-30) | | | */ /* ============== | | | */ /* | | | */ /* deprecation flag | | | */ -#define ZEND_ACC_DEPRECATED (1 << 11) /* | X | | */ +#define ZEND_ACC_DEPRECATED (1u << 11u) /* | X | | */ /* | | | */ /* Function returning by reference | | | */ -#define ZEND_ACC_RETURN_REFERENCE (1 << 12) /* | X | | */ +#define ZEND_ACC_RETURN_REFERENCE (1u << 12u) /* | X | | */ /* | | | */ /* Function has a return type | | | */ -#define ZEND_ACC_HAS_RETURN_TYPE (1 << 13) /* | X | | */ +#define ZEND_ACC_HAS_RETURN_TYPE (1u << 13u) /* | X | | */ /* | | | */ /* Function with variable number of arguments | | | */ -#define ZEND_ACC_VARIADIC (1 << 14) /* | X | | */ +#define ZEND_ACC_VARIADIC (1u << 14u) /* | X | | */ /* | | | */ /* op_array has finally blocks (user only) | | | */ -#define ZEND_ACC_HAS_FINALLY_BLOCK (1 << 15) /* | X | | */ +#define ZEND_ACC_HAS_FINALLY_BLOCK (1u << 15u) /* | X | | */ /* | | | */ /* "main" op_array with | | | */ /* ZEND_DECLARE_CLASS_DELAYED opcodes | | | */ -#define ZEND_ACC_EARLY_BINDING (1 << 16) /* | X | | */ +#define ZEND_ACC_EARLY_BINDING (1u << 16u) /* | X | | */ /* | | | */ /* closure uses $this | | | */ -#define ZEND_ACC_USES_THIS (1 << 17) /* | X | | */ +#define ZEND_ACC_USES_THIS (1u << 17u) /* | X | | */ /* | | | */ /* call through user function trampoline. e.g. | | | */ /* __call, __callstatic | | | */ -#define ZEND_ACC_CALL_VIA_TRAMPOLINE (1 << 18) /* | X | | */ +#define ZEND_ACC_CALL_VIA_TRAMPOLINE (1u << 18u) /* | X | | */ /* | | | */ /* disable inline caching | | | */ -#define ZEND_ACC_NEVER_CACHE (1 << 19) /* | X | | */ +#define ZEND_ACC_NEVER_CACHE (1u << 19u) /* | X | | */ /* | | | */ /* op_array is a clone of trait method | | | */ -#define ZEND_ACC_TRAIT_CLONE (1 << 20) /* | X | | */ +#define ZEND_ACC_TRAIT_CLONE (1u << 20u) /* | X | | */ /* | | | */ /* functions is a constructor | | | */ -#define ZEND_ACC_CTOR (1 << 21) /* | X | | */ +#define ZEND_ACC_CTOR (1u << 21u) /* | X | | */ /* | | | */ /* Closure related | | | */ -#define ZEND_ACC_CLOSURE (1 << 22) /* | X | | */ -#define ZEND_ACC_FAKE_CLOSURE (1 << 23) /* | X | | */ /* Same as ZEND_CALL_FAKE_CLOSURE */ +#define ZEND_ACC_CLOSURE (1u << 22u) /* | X | | */ +#define ZEND_ACC_FAKE_CLOSURE (1u << 23u) /* | X | | */ /* Same as ZEND_CALL_FAKE_CLOSURE */ /* | | | */ -#define ZEND_ACC_GENERATOR (1 << 24) /* | X | | */ +#define ZEND_ACC_GENERATOR (1u << 24u) /* | X | | */ /* | | | */ /* function was processed by pass two (user only) | | | */ -#define ZEND_ACC_DONE_PASS_TWO (1 << 25) /* | X | | */ +#define ZEND_ACC_DONE_PASS_TWO (1u << 25u) /* | X | | */ /* | | | */ /* internal function is allocated at arena (int only) | | | */ -#define ZEND_ACC_ARENA_ALLOCATED (1 << 25) /* | X | | */ +#define ZEND_ACC_ARENA_ALLOCATED (1u << 25u) /* | X | | */ /* | | | */ /* run_time_cache allocated on heap (user only) | | | */ -#define ZEND_ACC_HEAP_RT_CACHE (1 << 26) /* | X | | */ +#define ZEND_ACC_HEAP_RT_CACHE (1u << 26u) /* | X | | */ /* | | | */ /* method flag used by Closure::__invoke() (int only) | | | */ -#define ZEND_ACC_USER_ARG_INFO (1 << 26) /* | X | | */ +#define ZEND_ACC_USER_ARG_INFO (1u << 26u) /* | X | | */ /* | | | */ /* supports opcache compile-time evaluation (funcs) | | | */ -#define ZEND_ACC_COMPILE_TIME_EVAL (1 << 27) /* | X | | */ +#define ZEND_ACC_COMPILE_TIME_EVAL (1u << 27u) /* | X | | */ /* | | | */ /* has #[\Override] attribute | | | */ -#define ZEND_ACC_OVERRIDE (1 << 28) /* | X | | */ +#define ZEND_ACC_OVERRIDE (1u << 28u) /* | X | | */ /* | | | */ /* op_array uses strict mode types | | | */ #define ZEND_ACC_STRICT_TYPES (1U << 31) /* | X | | */ @@ -575,26 +575,26 @@ struct _zend_execute_data { #define ZEND_CALL_HAS_THIS IS_OBJECT_EX /* Top 16 bits of Z_TYPE_INFO(EX(This)) are used as call_info flags */ -#define ZEND_CALL_FUNCTION (0 << 16) -#define ZEND_CALL_CODE (1 << 16) -#define ZEND_CALL_NESTED (0 << 17) -#define ZEND_CALL_TOP (1 << 17) -#define ZEND_CALL_ALLOCATED (1 << 18) -#define ZEND_CALL_FREE_EXTRA_ARGS (1 << 19) -#define ZEND_CALL_HAS_SYMBOL_TABLE (1 << 20) -#define ZEND_CALL_RELEASE_THIS (1 << 21) -#define ZEND_CALL_CLOSURE (1 << 22) -#define ZEND_CALL_FAKE_CLOSURE (1 << 23) /* Same as ZEND_ACC_FAKE_CLOSURE */ -#define ZEND_CALL_GENERATOR (1 << 24) -#define ZEND_CALL_DYNAMIC (1 << 25) -#define ZEND_CALL_MAY_HAVE_UNDEF (1 << 26) -#define ZEND_CALL_HAS_EXTRA_NAMED_PARAMS (1 << 27) -#define ZEND_CALL_OBSERVED (1 << 28) /* "fcall_begin" observer handler may set this flag */ +#define ZEND_CALL_FUNCTION (0u << 16u) +#define ZEND_CALL_CODE (1u << 16u) +#define ZEND_CALL_NESTED (0u << 17u) +#define ZEND_CALL_TOP (1u << 17u) +#define ZEND_CALL_ALLOCATED (1u << 18u) +#define ZEND_CALL_FREE_EXTRA_ARGS (1u << 19u) +#define ZEND_CALL_HAS_SYMBOL_TABLE (1u << 20u) +#define ZEND_CALL_RELEASE_THIS (1u << 21u) +#define ZEND_CALL_CLOSURE (1u << 22u) +#define ZEND_CALL_FAKE_CLOSURE (1u << 23u) /* Same as ZEND_ACC_FAKE_CLOSURE */ +#define ZEND_CALL_GENERATOR (1u << 24u) +#define ZEND_CALL_DYNAMIC (1u << 25u) +#define ZEND_CALL_MAY_HAVE_UNDEF (1u << 26u) +#define ZEND_CALL_HAS_EXTRA_NAMED_PARAMS (1u << 27u) +#define ZEND_CALL_OBSERVED (1u << 28u) /* "fcall_begin" observer handler may set this flag */ /* to prevent optimization in RETURN handler and */ /* keep all local variables for "fcall_end" handler */ -#define ZEND_CALL_JIT_RESERVED (1 << 29) /* reserved for tracing JIT */ -#define ZEND_CALL_NEEDS_REATTACH (1 << 30) -#define ZEND_CALL_SEND_ARG_BY_REF (1u << 31) +#define ZEND_CALL_JIT_RESERVED (1u << 29u) /* reserved for tracing JIT */ +#define ZEND_CALL_NEEDS_REATTACH (1u << 30u) +#define ZEND_CALL_SEND_ARG_BY_REF (1u << 31u) #define ZEND_CALL_NESTED_FUNCTION (ZEND_CALL_FUNCTION | ZEND_CALL_NESTED) #define ZEND_CALL_NESTED_CODE (ZEND_CALL_CODE | ZEND_CALL_NESTED) @@ -779,14 +779,14 @@ ZEND_STATIC_ASSERT(ZEND_MM_ALIGNED_SIZE(sizeof(zval)) == sizeof(zval), ((void**)RUN_TIME_CACHE(op_array))[handle] #define IS_UNUSED 0 /* Unused operand */ -#define IS_CONST (1<<0) -#define IS_TMP_VAR (1<<1) -#define IS_VAR (1<<2) -#define IS_CV (1<<3) /* Compiled variable */ +#define IS_CONST (1u << 0u) +#define IS_TMP_VAR (1u << 1u) +#define IS_VAR (1u << 2u) +#define IS_CV (1u << 3u) /* Compiled variable */ /* Used for result.type of smart branch instructions */ -#define IS_SMART_BRANCH_JMPZ (1<<4) -#define IS_SMART_BRANCH_JMPNZ (1<<5) +#define IS_SMART_BRANCH_JMPZ (1u << 4u) +#define IS_SMART_BRANCH_JMPNZ (1u << 5u) #define ZEND_EXTRA_VALUE 1 @@ -962,13 +962,13 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); /* END: OPCODES */ /* class fetches */ -#define ZEND_FETCH_CLASS_DEFAULT 0 -#define ZEND_FETCH_CLASS_SELF 1 -#define ZEND_FETCH_CLASS_PARENT 2 -#define ZEND_FETCH_CLASS_STATIC 3 -#define ZEND_FETCH_CLASS_AUTO 4 -#define ZEND_FETCH_CLASS_INTERFACE 5 -#define ZEND_FETCH_CLASS_TRAIT 6 +#define ZEND_FETCH_CLASS_DEFAULT 0u +#define ZEND_FETCH_CLASS_SELF 1u +#define ZEND_FETCH_CLASS_PARENT 2u +#define ZEND_FETCH_CLASS_STATIC 3u +#define ZEND_FETCH_CLASS_AUTO 4u +#define ZEND_FETCH_CLASS_INTERFACE 5u +#define ZEND_FETCH_CLASS_TRAIT 6u #define ZEND_FETCH_CLASS_MASK 0x0f #define ZEND_FETCH_CLASS_NO_AUTOLOAD 0x80 #define ZEND_FETCH_CLASS_SILENT 0x0100 @@ -977,56 +977,56 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED 0x0800 /* These should not clash with ZEND_ACC_(PUBLIC|PROTECTED|PRIVATE) */ -#define ZEND_PARAM_REF (1<<3) -#define ZEND_PARAM_VARIADIC (1<<4) +#define ZEND_PARAM_REF (1u << 3u) +#define ZEND_PARAM_VARIADIC (1u << 4u) -#define ZEND_NAME_FQ 0 -#define ZEND_NAME_NOT_FQ 1 -#define ZEND_NAME_RELATIVE 2 +#define ZEND_NAME_FQ 0u +#define ZEND_NAME_NOT_FQ 1u +#define ZEND_NAME_RELATIVE 2u /* ZEND_FETCH_ flags in class name AST of new const expression must not clash with ZEND_NAME_ flags */ #define ZEND_CONST_EXPR_NEW_FETCH_TYPE_SHIFT 2 -#define ZEND_TYPE_NULLABLE (1<<8) +#define ZEND_TYPE_NULLABLE (1u<<8u) -#define ZEND_ARRAY_SYNTAX_LIST 1 /* list() */ -#define ZEND_ARRAY_SYNTAX_LONG 2 /* array() */ -#define ZEND_ARRAY_SYNTAX_SHORT 3 /* [] */ +#define ZEND_ARRAY_SYNTAX_LIST 1u /* list() */ +#define ZEND_ARRAY_SYNTAX_LONG 2u /* array() */ +#define ZEND_ARRAY_SYNTAX_SHORT 3u /* [] */ /* var status for backpatching */ -#define BP_VAR_R 0 -#define BP_VAR_W 1 -#define BP_VAR_RW 2 -#define BP_VAR_IS 3 -#define BP_VAR_FUNC_ARG 4 -#define BP_VAR_UNSET 5 +#define BP_VAR_R 0u +#define BP_VAR_W 1u +#define BP_VAR_RW 2u +#define BP_VAR_IS 3u +#define BP_VAR_FUNC_ARG 4u +#define BP_VAR_UNSET 5u -#define ZEND_INTERNAL_FUNCTION 1 -#define ZEND_USER_FUNCTION 2 -#define ZEND_EVAL_CODE 4 +#define ZEND_INTERNAL_FUNCTION 1u +#define ZEND_USER_FUNCTION 2u +#define ZEND_EVAL_CODE 4u #define ZEND_USER_CODE(type) ((type) != ZEND_INTERNAL_FUNCTION) -#define ZEND_INTERNAL_CLASS 1 -#define ZEND_USER_CLASS 2 +#define ZEND_INTERNAL_CLASS 1u +#define ZEND_USER_CLASS 2u -#define ZEND_EVAL (1<<0) -#define ZEND_INCLUDE (1<<1) -#define ZEND_INCLUDE_ONCE (1<<2) -#define ZEND_REQUIRE (1<<3) -#define ZEND_REQUIRE_ONCE (1<<4) +#define ZEND_EVAL (1u << 0u) +#define ZEND_INCLUDE (1u << 1u) +#define ZEND_INCLUDE_ONCE (1u << 2u) +#define ZEND_REQUIRE (1u << 3u) +#define ZEND_REQUIRE_ONCE (1u << 4u) /* global/local fetches */ -#define ZEND_FETCH_GLOBAL (1<<1) -#define ZEND_FETCH_LOCAL (1<<2) -#define ZEND_FETCH_GLOBAL_LOCK (1<<3) +#define ZEND_FETCH_GLOBAL (1u << 1u) +#define ZEND_FETCH_LOCAL (1u << 2u) +#define ZEND_FETCH_GLOBAL_LOCK (1u << 3u) #define ZEND_FETCH_TYPE_MASK 0xe /* Only one of these can ever be in use */ -#define ZEND_FETCH_REF 1 -#define ZEND_FETCH_DIM_WRITE 2 -#define ZEND_FETCH_OBJ_FLAGS 3 +#define ZEND_FETCH_REF 1u +#define ZEND_FETCH_DIM_WRITE 2u +#define ZEND_FETCH_OBJ_FLAGS 3u /* Used to mark what kind of operation a writing FETCH_DIM is used in, * to produce a more precise error on incorrect string offset use. */ @@ -1035,12 +1035,12 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_FETCH_DIM_OBJ 3 #define ZEND_FETCH_DIM_INCDEC 4 -#define ZEND_ISEMPTY (1<<0) +#define ZEND_ISEMPTY (1u << 0u) -#define ZEND_LAST_CATCH (1<<0) +#define ZEND_LAST_CATCH (1u << 0u) -#define ZEND_FREE_ON_RETURN (1<<0) -#define ZEND_FREE_SWITCH (1<<1) +#define ZEND_FREE_ON_RETURN (1u << 0u) +#define ZEND_FREE_SWITCH (1u << 1u) #define ZEND_SEND_BY_VAL 0u #define ZEND_SEND_BY_REF 1u @@ -1048,15 +1048,15 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_THROW_IS_EXPR 1u -#define ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS 1 +#define ZEND_FCALL_MAY_HAVE_EXTRA_NAMED_PARAMS 1u /* The send mode, the is_variadic, the is_promoted, and the is_tentative flags are stored as part of zend_type */ #define _ZEND_SEND_MODE_SHIFT _ZEND_TYPE_EXTRA_FLAGS_SHIFT -#define _ZEND_IS_VARIADIC_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 2)) -#define _ZEND_IS_PROMOTED_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 3)) -#define _ZEND_IS_TENTATIVE_BIT (1 << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 4)) +#define _ZEND_IS_VARIADIC_BIT (1u << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 2u)) +#define _ZEND_IS_PROMOTED_BIT (1u << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 3u)) +#define _ZEND_IS_TENTATIVE_BIT (1u << (_ZEND_TYPE_EXTRA_FLAGS_SHIFT + 4u)) #define ZEND_ARG_SEND_MODE(arg_info) \ - ((ZEND_TYPE_FULL_MASK((arg_info)->type) >> _ZEND_SEND_MODE_SHIFT) & 3) + ((ZEND_TYPE_FULL_MASK((arg_info)->type) >> _ZEND_SEND_MODE_SHIFT) & 3u) #define ZEND_ARG_IS_VARIADIC(arg_info) \ ((ZEND_TYPE_FULL_MASK((arg_info)->type) & _ZEND_IS_VARIADIC_BIT) != 0) #define ZEND_ARG_IS_PROMOTED(arg_info) \ @@ -1064,14 +1064,14 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_ARG_TYPE_IS_TENTATIVE(arg_info) \ ((ZEND_TYPE_FULL_MASK((arg_info)->type) & _ZEND_IS_TENTATIVE_BIT) != 0) -#define ZEND_DIM_IS (1 << 0) /* isset fetch needed for null coalesce. Set in zend_compile.c for ZEND_AST_DIM nested within ZEND_AST_COALESCE. */ -#define ZEND_DIM_ALTERNATIVE_SYNTAX (1 << 1) /* deprecated curly brace usage */ +#define ZEND_DIM_IS (1u << 0u) /* isset fetch needed for null coalesce. Set in zend_compile.c for ZEND_AST_DIM nested within ZEND_AST_COALESCE. */ +#define ZEND_DIM_ALTERNATIVE_SYNTAX (1u << 1u) /* deprecated curly brace usage */ /* Attributes for ${} encaps var in strings (ZEND_AST_DIM or ZEND_AST_VAR node) */ /* ZEND_AST_VAR nodes can have any of the ZEND_ENCAPS_VAR_* flags */ /* ZEND_AST_DIM flags can have ZEND_DIM_ALTERNATIVE_SYNTAX or ZEND_ENCAPS_VAR_DOLLAR_CURLY during the parse phase (ZEND_DIM_ALTERNATIVE_SYNTAX is a thrown fatal error). */ -#define ZEND_ENCAPS_VAR_DOLLAR_CURLY (1 << 0) -#define ZEND_ENCAPS_VAR_DOLLAR_CURLY_VAR_VAR (1 << 1) +#define ZEND_ENCAPS_VAR_DOLLAR_CURLY (1u << 0u) +#define ZEND_ENCAPS_VAR_DOLLAR_CURLY_VAR_VAR (1u << 1u) /* Make sure these don't clash with ZEND_FETCH_CLASS_* flags. */ #define IS_CONSTANT_CLASS 0x400 /* __CLASS__ in trait */ @@ -1124,28 +1124,28 @@ static zend_always_inline bool zend_check_arg_send_type(const zend_function *zf, #define QUICK_ARG_MAY_BE_SENT_BY_REF(zf, arg_num) \ ZEND_CHECK_ARG_FLAG(zf, arg_num, ZEND_SEND_PREFER_REF) -#define ZEND_RETURN_VAL 0 -#define ZEND_RETURN_REF 1 +#define ZEND_RETURN_VAL 0u +#define ZEND_RETURN_REF 1u -#define ZEND_BIND_VAL 0 -#define ZEND_BIND_REF 1 -#define ZEND_BIND_IMPLICIT 2 -#define ZEND_BIND_EXPLICIT 4 +#define ZEND_BIND_VAL 0u +#define ZEND_BIND_REF 1u +#define ZEND_BIND_IMPLICIT 2u +#define ZEND_BIND_EXPLICIT 4u -#define ZEND_RETURNS_FUNCTION (1<<0) -#define ZEND_RETURNS_VALUE (1<<1) +#define ZEND_RETURNS_FUNCTION (1u << 0u) +#define ZEND_RETURNS_VALUE (1u << 1u) -#define ZEND_ARRAY_ELEMENT_REF (1<<0) -#define ZEND_ARRAY_NOT_PACKED (1<<1) -#define ZEND_ARRAY_SIZE_SHIFT 2 +#define ZEND_ARRAY_ELEMENT_REF (1u << 0u) +#define ZEND_ARRAY_NOT_PACKED (1u << 1u) +#define ZEND_ARRAY_SIZE_SHIFT 2u /* Attribute for ternary inside parentheses */ -#define ZEND_PARENTHESIZED_CONDITIONAL 1 +#define ZEND_PARENTHESIZED_CONDITIONAL 1u /* For "use" AST nodes and the seen symbol table */ -#define ZEND_SYMBOL_CLASS (1<<0) -#define ZEND_SYMBOL_FUNCTION (1<<1) -#define ZEND_SYMBOL_CONST (1<<2) +#define ZEND_SYMBOL_CLASS (1u << 0u) +#define ZEND_SYMBOL_FUNCTION (1u << 1u) +#define ZEND_SYMBOL_CONST (1u << 2u) /* All increment opcodes are even (decrement are odd) */ #define ZEND_IS_INCREMENT(opcode) (((opcode) & 1) == 0) @@ -1178,65 +1178,65 @@ END_EXTERN_C() * to change the default compiler behavior */ /* generate extended debug information */ -#define ZEND_COMPILE_EXTENDED_STMT (1<<0) -#define ZEND_COMPILE_EXTENDED_FCALL (1<<1) +#define ZEND_COMPILE_EXTENDED_STMT (1u << 0u) +#define ZEND_COMPILE_EXTENDED_FCALL (1u << 1u) #define ZEND_COMPILE_EXTENDED_INFO (ZEND_COMPILE_EXTENDED_STMT|ZEND_COMPILE_EXTENDED_FCALL) /* call op_array handler of extensions */ -#define ZEND_COMPILE_HANDLE_OP_ARRAY (1<<2) +#define ZEND_COMPILE_HANDLE_OP_ARRAY (1u << 2u) /* generate ZEND_INIT_FCALL_BY_NAME for internal functions instead of ZEND_INIT_FCALL */ -#define ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS (1<<3) +#define ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS (1u << 3u) /* don't perform early binding for classes inherited form internal ones; * in namespaces assume that internal class that doesn't exist at compile-time * may appear in run-time */ -#define ZEND_COMPILE_IGNORE_INTERNAL_CLASSES (1<<4) +#define ZEND_COMPILE_IGNORE_INTERNAL_CLASSES (1u << 4u) /* generate ZEND_DECLARE_CLASS_DELAYED opcode to delay early binding */ -#define ZEND_COMPILE_DELAYED_BINDING (1<<5) +#define ZEND_COMPILE_DELAYED_BINDING (1u << 5u) /* disable constant substitution at compile-time */ -#define ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION (1<<6) +#define ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION (1u << 6u) /* disable substitution of persistent constants at compile-time */ -#define ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION (1<<8) +#define ZEND_COMPILE_NO_PERSISTENT_CONSTANT_SUBSTITUTION (1u << 8u) /* generate ZEND_INIT_FCALL_BY_NAME for userland functions instead of ZEND_INIT_FCALL */ -#define ZEND_COMPILE_IGNORE_USER_FUNCTIONS (1<<9) +#define ZEND_COMPILE_IGNORE_USER_FUNCTIONS (1u << 9u) /* force ZEND_ACC_USE_GUARDS for all classes */ -#define ZEND_COMPILE_GUARDS (1<<10) +#define ZEND_COMPILE_GUARDS (1u << 10u) /* disable builtin special case function calls */ -#define ZEND_COMPILE_NO_BUILTINS (1<<11) +#define ZEND_COMPILE_NO_BUILTINS (1u << 11u) /* result of compilation may be stored in file cache */ -#define ZEND_COMPILE_WITH_FILE_CACHE (1<<12) +#define ZEND_COMPILE_WITH_FILE_CACHE (1u << 12u) /* ignore functions and classes declared in other files */ -#define ZEND_COMPILE_IGNORE_OTHER_FILES (1<<13) +#define ZEND_COMPILE_IGNORE_OTHER_FILES (1u << 13u) /* this flag is set when compiler invoked by opcache_compile_file() */ -#define ZEND_COMPILE_WITHOUT_EXECUTION (1<<14) +#define ZEND_COMPILE_WITHOUT_EXECUTION (1u << 14u) /* this flag is set when compiler invoked during preloading */ -#define ZEND_COMPILE_PRELOAD (1<<15) +#define ZEND_COMPILE_PRELOAD (1u << 15u) /* disable jumptable optimization for switch statements */ -#define ZEND_COMPILE_NO_JUMPTABLES (1<<16) +#define ZEND_COMPILE_NO_JUMPTABLES (1u << 16u) /* this flag is set when compiler invoked during preloading in separate process */ -#define ZEND_COMPILE_PRELOAD_IN_CHILD (1<<17) +#define ZEND_COMPILE_PRELOAD_IN_CHILD (1u << 17u) /* ignore observer notifications, e.g. to manually notify afterwards in a post-processing step after compilation */ -#define ZEND_COMPILE_IGNORE_OBSERVER (1<<18) +#define ZEND_COMPILE_IGNORE_OBSERVER (1u << 18u) /* The default value for CG(compiler_options) */ #define ZEND_COMPILE_DEFAULT ZEND_COMPILE_HANDLE_OP_ARRAY /* The default value for CG(compiler_options) during eval() */ -#define ZEND_COMPILE_DEFAULT_FOR_EVAL 0 +#define ZEND_COMPILE_DEFAULT_FOR_EVAL 0u ZEND_API bool zend_is_op_long_compatible(const zval *op); ZEND_API bool zend_binary_op_produces_error(uint32_t opcode, const zval *op1, const zval *op2); diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h index 89885557b044f..92cdf17fb84d2 100644 --- a/Zend/zend_hash.h +++ b/Zend/zend_hash.h @@ -30,19 +30,19 @@ #define HASH_KEY_IS_LONG 2 #define HASH_KEY_NON_EXISTENT 3 -#define HASH_UPDATE (1<<0) -#define HASH_ADD (1<<1) -#define HASH_UPDATE_INDIRECT (1<<2) -#define HASH_ADD_NEW (1<<3) -#define HASH_ADD_NEXT (1<<4) -#define HASH_LOOKUP (1<<5) - -#define HASH_FLAG_CONSISTENCY ((1<<0) | (1<<1)) -#define HASH_FLAG_PACKED (1<<2) -#define HASH_FLAG_UNINITIALIZED (1<<3) -#define HASH_FLAG_STATIC_KEYS (1<<4) /* long and interned strings */ -#define HASH_FLAG_HAS_EMPTY_IND (1<<5) -#define HASH_FLAG_ALLOW_COW_VIOLATION (1<<6) +#define HASH_UPDATE (1u<<0u) +#define HASH_ADD (1u<<1u) +#define HASH_UPDATE_INDIRECT (1u<<2u) +#define HASH_ADD_NEW (1u<<3u) +#define HASH_ADD_NEXT (1u<<4u) +#define HASH_LOOKUP (1u<<5u) + +#define HASH_FLAG_CONSISTENCY ((1u<<0u) | (1u<<1u)) +#define HASH_FLAG_PACKED (1u<<2u) +#define HASH_FLAG_UNINITIALIZED (1u<<3u) +#define HASH_FLAG_STATIC_KEYS (1u<<4u) /* long and interned strings */ +#define HASH_FLAG_HAS_EMPTY_IND (1u<<5u) +#define HASH_FLAG_ALLOW_COW_VIOLATION (1u<<6u) /* Only the low byte are real flags */ #define HASH_FLAG_MASK 0xff diff --git a/Zend/zend_string.h b/Zend/zend_string.h index d61bebd90c8bf..3a9d875cafc84 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -117,7 +117,7 @@ END_EXTERN_C() #define ZSTR_MAX_LEN (SIZE_MAX - ZSTR_MAX_OVERHEAD) #define ZSTR_ALLOCA_ALLOC(str, _len, use_heap) do { \ - (str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE_EX(_ZSTR_STRUCT_SIZE(_len), 8), (use_heap)); \ + (str) = (zend_string *)do_alloca(ZEND_MM_ALIGNED_SIZE_EX(_ZSTR_STRUCT_SIZE(_len), 8u), (use_heap)); \ GC_SET_REFCOUNT(str, 1); \ GC_TYPE_INFO(str) = GC_STRING; \ ZSTR_H(str) = 0; \ @@ -473,16 +473,16 @@ static zend_always_inline zend_ulong zend_inline_hash_func(const unsigned char * memcpy(&chunk, str, sizeof(chunk)); hash = - hash * 33 * 33 * 33 * 33 + - ((chunk >> (8 * 0)) & 0xff) * 33 * 33 * 33 + - ((chunk >> (8 * 1)) & 0xff) * 33 * 33 + - ((chunk >> (8 * 2)) & 0xff) * 33 + + hash * 33u * 33u * 33u * 33u + + ((chunk >> (8 * 0)) & 0xff) * 33u * 33u * 33u + + ((chunk >> (8 * 1)) & 0xff) * 33u * 33u + + ((chunk >> (8 * 2)) & 0xff) * 33u + ((chunk >> (8 * 3)) & 0xff); hash = - hash * 33 * 33 * 33 * 33 + - ((chunk >> (8 * 4)) & 0xff) * 33 * 33 * 33 + - ((chunk >> (8 * 5)) & 0xff) * 33 * 33 + - ((chunk >> (8 * 6)) & 0xff) * 33 + + hash * 33u * 33u * 33u * 33u + + ((chunk >> (8 * 4)) & 0xff) * 33u * 33u * 33u + + ((chunk >> (8 * 5)) & 0xff) * 33u * 33u + + ((chunk >> (8 * 6)) & 0xff) * 33u + ((chunk >> (8 * 7)) & 0xff); # else hash = diff --git a/Zend/zend_type_info.h b/Zend/zend_type_info.h index eeab7bf0431da..cafff314a1d9d 100644 --- a/Zend/zend_type_info.h +++ b/Zend/zend_type_info.h @@ -21,26 +21,26 @@ #include "zend_types.h" -#define MAY_BE_UNDEF (1 << IS_UNDEF) -#define MAY_BE_NULL (1 << IS_NULL) -#define MAY_BE_FALSE (1 << IS_FALSE) -#define MAY_BE_TRUE (1 << IS_TRUE) +#define MAY_BE_UNDEF (1u << IS_UNDEF) +#define MAY_BE_NULL (1u << IS_NULL) +#define MAY_BE_FALSE (1u << IS_FALSE) +#define MAY_BE_TRUE (1u << IS_TRUE) #define MAY_BE_BOOL (MAY_BE_FALSE|MAY_BE_TRUE) -#define MAY_BE_LONG (1 << IS_LONG) -#define MAY_BE_DOUBLE (1 << IS_DOUBLE) -#define MAY_BE_STRING (1 << IS_STRING) -#define MAY_BE_ARRAY (1 << IS_ARRAY) -#define MAY_BE_OBJECT (1 << IS_OBJECT) -#define MAY_BE_RESOURCE (1 << IS_RESOURCE) +#define MAY_BE_LONG (1u << IS_LONG) +#define MAY_BE_DOUBLE (1u << IS_DOUBLE) +#define MAY_BE_STRING (1u << IS_STRING) +#define MAY_BE_ARRAY (1u << IS_ARRAY) +#define MAY_BE_OBJECT (1u << IS_OBJECT) +#define MAY_BE_RESOURCE (1u << IS_RESOURCE) #define MAY_BE_ANY (MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE|MAY_BE_STRING|MAY_BE_ARRAY|MAY_BE_OBJECT|MAY_BE_RESOURCE) -#define MAY_BE_REF (1 << IS_REFERENCE) /* may be reference */ +#define MAY_BE_REF (1u << IS_REFERENCE) /* may be reference */ /* These are used in zend_type, but not for type inference. * They are allowed to overlap with types used during inference. */ -#define MAY_BE_CALLABLE (1 << IS_CALLABLE) -#define MAY_BE_VOID (1 << IS_VOID) -#define MAY_BE_NEVER (1 << IS_NEVER) -#define MAY_BE_STATIC (1 << IS_STATIC) +#define MAY_BE_CALLABLE (1u << IS_CALLABLE) +#define MAY_BE_VOID (1u << IS_VOID) +#define MAY_BE_NEVER (1u << IS_NEVER) +#define MAY_BE_STATIC (1u << IS_STATIC) #define MAY_BE_ARRAY_SHIFT (IS_REFERENCE) @@ -56,10 +56,10 @@ #define MAY_BE_ARRAY_OF_ANY (MAY_BE_ANY << MAY_BE_ARRAY_SHIFT) #define MAY_BE_ARRAY_OF_REF (MAY_BE_REF << MAY_BE_ARRAY_SHIFT) -#define MAY_BE_ARRAY_PACKED (1<<21) -#define MAY_BE_ARRAY_NUMERIC_HASH (1<<22) /* hash with numeric keys */ -#define MAY_BE_ARRAY_STRING_HASH (1<<23) /* hash with string keys */ -#define MAY_BE_ARRAY_EMPTY (1<<29) +#define MAY_BE_ARRAY_PACKED (1u << 21u) +#define MAY_BE_ARRAY_NUMERIC_HASH (1u << 22u) /* hash with numeric keys */ +#define MAY_BE_ARRAY_STRING_HASH (1u << 23u) /* hash with string keys */ +#define MAY_BE_ARRAY_EMPTY (1u << 29u) #define MAY_BE_ARRAY_KEY_LONG (MAY_BE_ARRAY_PACKED | MAY_BE_ARRAY_NUMERIC_HASH) #define MAY_BE_ARRAY_KEY_STRING MAY_BE_ARRAY_STRING_HASH @@ -71,11 +71,11 @@ #define MAY_BE_HASH_ONLY(t) (MAY_BE_HASH(t) && !((t) & (MAY_BE_ARRAY_PACKED|MAY_BE_ARRAY_EMPTY))) #define MAY_BE_EMPTY_ONLY(t) (((t) & MAY_BE_ARRAY_KEY_ANY) == MAY_BE_ARRAY_EMPTY) -#define MAY_BE_CLASS (1<<24) -#define MAY_BE_INDIRECT (1<<25) +#define MAY_BE_CLASS (1u << 24u) +#define MAY_BE_INDIRECT (1u << 25u) -#define MAY_BE_RC1 (1<<30) /* may be non-reference with refcount == 1 */ -#define MAY_BE_RCN (1u<<31) /* may be non-reference with refcount > 1 */ +#define MAY_BE_RC1 (1u << 30u) /* may be non-reference with refcount == 1 */ +#define MAY_BE_RCN (1u << 31u) /* may be non-reference with refcount > 1 */ #define MAY_BE_ANY_ARRAY \ diff --git a/Zend/zend_types.h b/Zend/zend_types.h index c4a07f58874ab..2f882df320a0d 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -142,24 +142,24 @@ typedef struct { zend_type types[1]; } zend_type_list; -#define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 25 -#define _ZEND_TYPE_MASK ((1u << 25) - 1) +#define _ZEND_TYPE_EXTRA_FLAGS_SHIFT 25u +#define _ZEND_TYPE_MASK ((1u << 25u) - 1) /* Only one of these bits may be set. */ -#define _ZEND_TYPE_NAME_BIT (1u << 24) +#define _ZEND_TYPE_NAME_BIT (1u << 24u) // Used to signify that type.ptr is not a `zend_string*` but a `const char*`, -#define _ZEND_TYPE_LITERAL_NAME_BIT (1u << 23) -#define _ZEND_TYPE_LIST_BIT (1u << 22) +#define _ZEND_TYPE_LITERAL_NAME_BIT (1u << 23u) +#define _ZEND_TYPE_LIST_BIT (1u << 22u) #define _ZEND_TYPE_KIND_MASK (_ZEND_TYPE_LIST_BIT|_ZEND_TYPE_NAME_BIT|_ZEND_TYPE_LITERAL_NAME_BIT) /* For BC behaviour with iterable type */ -#define _ZEND_TYPE_ITERABLE_BIT (1u << 21) +#define _ZEND_TYPE_ITERABLE_BIT (1u << 21u) /* Whether the type list is arena allocated */ -#define _ZEND_TYPE_ARENA_BIT (1u << 20) +#define _ZEND_TYPE_ARENA_BIT (1u << 20u) /* Whether the type list is an intersection type */ -#define _ZEND_TYPE_INTERSECTION_BIT (1u << 19) +#define _ZEND_TYPE_INTERSECTION_BIT (1u << 19u) /* Whether the type is a union type */ -#define _ZEND_TYPE_UNION_BIT (1u << 18) +#define _ZEND_TYPE_UNION_BIT (1u << 18u) /* Type mask excluding the flags above. */ -#define _ZEND_TYPE_MAY_BE_MASK ((1u << 18) - 1) +#define _ZEND_TYPE_MAY_BE_MASK ((1u << 18u) - 1u) /* Must have same value as MAY_BE_NULL */ #define _ZEND_TYPE_NULLABLE_BIT 0x2u @@ -580,9 +580,9 @@ typedef union { uintptr_t list; } zend_property_info_source_list; -#define ZEND_PROPERTY_INFO_SOURCE_FROM_LIST(list) (0x1 | (uintptr_t) (list)) -#define ZEND_PROPERTY_INFO_SOURCE_TO_LIST(list) ((zend_property_info_list *) ((list) & ~0x1)) -#define ZEND_PROPERTY_INFO_SOURCE_IS_LIST(list) ((list) & 0x1) +#define ZEND_PROPERTY_INFO_SOURCE_FROM_LIST(list) (0x1u | (uintptr_t) (list)) +#define ZEND_PROPERTY_INFO_SOURCE_TO_LIST(list) ((zend_property_info_list *) ((list) & ~0x1u)) +#define ZEND_PROPERTY_INFO_SOURCE_IS_LIST(list) ((list) & 0x1u) struct _zend_reference { zend_refcounted_h gc; @@ -597,46 +597,46 @@ struct _zend_ast_ref { /* Regular data types: Must be in sync with zend_variables.c. */ #define IS_UNDEF 0 -#define IS_NULL 1 -#define IS_FALSE 2 -#define IS_TRUE 3 -#define IS_LONG 4 -#define IS_DOUBLE 5 -#define IS_STRING 6 -#define IS_ARRAY 7 -#define IS_OBJECT 8 -#define IS_RESOURCE 9 -#define IS_REFERENCE 10 -#define IS_CONSTANT_AST 11 /* Constant expressions */ +#define IS_NULL 1u +#define IS_FALSE 2u +#define IS_TRUE 3u +#define IS_LONG 4u +#define IS_DOUBLE 5u +#define IS_STRING 6u +#define IS_ARRAY 7u +#define IS_OBJECT 8u +#define IS_RESOURCE 9u +#define IS_REFERENCE 10u +#define IS_CONSTANT_AST 11u /* Constant expressions */ /* Fake types used only for type hinting. * These are allowed to overlap with the types below. */ -#define IS_CALLABLE 12 -#define IS_ITERABLE 13 -#define IS_VOID 14 -#define IS_STATIC 15 -#define IS_MIXED 16 -#define IS_NEVER 17 +#define IS_CALLABLE 12u +#define IS_ITERABLE 13u +#define IS_VOID 14u +#define IS_STATIC 15u +#define IS_MIXED 16u +#define IS_NEVER 17u /* internal types */ -#define IS_INDIRECT 12 -#define IS_PTR 13 -#define IS_ALIAS_PTR 14 -#define _IS_ERROR 15 +#define IS_INDIRECT 12u +#define IS_PTR 13u +#define IS_ALIAS_PTR 14u +#define _IS_ERROR 15u /* used for casts */ -#define _IS_BOOL 18 -#define _IS_NUMBER 19 +#define _IS_BOOL 18u +#define _IS_NUMBER 19u /* guard flags */ -#define ZEND_GUARD_PROPERTY_GET (1<<0) -#define ZEND_GUARD_PROPERTY_SET (1<<1) -#define ZEND_GUARD_PROPERTY_UNSET (1<<2) -#define ZEND_GUARD_PROPERTY_ISSET (1<<3) -#define ZEND_GUARD_PROPERTY_MASK 15 -#define ZEND_GUARD_RECURSION_DEBUG (1<<4) -#define ZEND_GUARD_RECURSION_EXPORT (1<<5) -#define ZEND_GUARD_RECURSION_JSON (1<<6) +#define ZEND_GUARD_PROPERTY_GET (1u << 0u) +#define ZEND_GUARD_PROPERTY_SET (1u << 1u) +#define ZEND_GUARD_PROPERTY_UNSET (1u << 2u) +#define ZEND_GUARD_PROPERTY_ISSET (1u << 3u) +#define ZEND_GUARD_PROPERTY_MASK 15u +#define ZEND_GUARD_RECURSION_DEBUG (1u << 4u) +#define ZEND_GUARD_RECURSION_EXPORT (1u << 5u) +#define ZEND_GUARD_RECURSION_JSON (1u << 6u) #define ZEND_GUARD_RECURSION_TYPE(t) ZEND_GUARD_RECURSION_ ## t @@ -696,11 +696,11 @@ static zend_always_inline uint8_t zval_get_type(const zval* pz) { #define Z_COUNTED(zval) (zval).value.counted #define Z_COUNTED_P(zval_p) Z_COUNTED(*(zval_p)) -#define Z_TYPE_MASK 0xff -#define Z_TYPE_FLAGS_MASK 0xff00 +#define Z_TYPE_MASK 0xffu +#define Z_TYPE_FLAGS_MASK 0xff00u -#define Z_TYPE_FLAGS_SHIFT 8 -#define Z_TYPE_INFO_EXTRA_SHIFT 16 +#define Z_TYPE_FLAGS_SHIFT 8u +#define Z_TYPE_INFO_EXTRA_SHIFT 16u #define GC_REFCOUNT(p) zend_gc_refcount(&(p)->gc) #define GC_SET_REFCOUNT(p, rc) zend_gc_set_refcount(&(p)->gc, rc) @@ -731,11 +731,11 @@ static zend_always_inline uint8_t zval_get_type(const zval* pz) { } \ } while (0) -#define GC_TYPE_MASK 0x0000000f -#define GC_FLAGS_MASK 0x000003f0 -#define GC_INFO_MASK 0xfffffc00 -#define GC_FLAGS_SHIFT 0 -#define GC_INFO_SHIFT 10 +#define GC_TYPE_MASK 0x0000000fu +#define GC_FLAGS_MASK 0x000003f0u +#define GC_INFO_MASK 0xfffffc00u +#define GC_FLAGS_SHIFT 0u +#define GC_INFO_SHIFT 10u static zend_always_inline uint8_t zval_gc_type(uint32_t gc_type_info) { return (gc_type_info & GC_TYPE_MASK); @@ -773,11 +773,11 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) { #define Z_GC_TYPE_INFO_P(zval_p) Z_GC_TYPE_INFO(*(zval_p)) /* zval_gc_flags(zval.value->gc.u.type_info) (common flags) */ -#define GC_NOT_COLLECTABLE (1<<4) -#define GC_PROTECTED (1<<5) /* used for recursion detection */ -#define GC_IMMUTABLE (1<<6) /* can't be changed in place */ -#define GC_PERSISTENT (1<<7) /* allocated using malloc */ -#define GC_PERSISTENT_LOCAL (1<<8) /* persistent, but thread-local */ +#define GC_NOT_COLLECTABLE (1u<<4u) +#define GC_PROTECTED (1u<<5u) /* used for recursion detection */ +#define GC_IMMUTABLE (1u<<6u) /* can't be changed in place */ +#define GC_PERSISTENT (1u<<7u) /* allocated using malloc */ +#define GC_PERSISTENT_LOCAL (1u<<8u) /* persistent, but thread-local */ #define GC_NULL (IS_NULL | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT)) #define GC_STRING (IS_STRING | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT)) @@ -788,13 +788,13 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) { #define GC_CONSTANT_AST (IS_CONSTANT_AST | (GC_NOT_COLLECTABLE << GC_FLAGS_SHIFT)) /* zval.u1.v.type_flags */ -#define IS_TYPE_REFCOUNTED (1<<0) -#define IS_TYPE_COLLECTABLE (1<<1) +#define IS_TYPE_REFCOUNTED (1u << 0u) +#define IS_TYPE_COLLECTABLE (1u << 1u) /* Used for static variables to check if they have been initialized. We can't use IS_UNDEF because * we can't store IS_UNDEF zvals in the static_variables HashTable. This needs to live in type_info * so that the ZEND_ASSIGN overrides it but is moved to extra to avoid breaking the Z_REFCOUNTED() * optimization that only checks for Z_TYPE_FLAGS() without `& (IS_TYPE_COLLECTABLE|IS_TYPE_REFCOUNTED)`. */ -#define IS_STATIC_VAR_UNINITIALIZED (1<<0) +#define IS_STATIC_VAR_UNINITIALIZED (1u << 0u) #if 1 /* This optimized version assumes that we have a single "type_flag" */ @@ -819,8 +819,8 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) { #define IS_STR_CLASS_NAME_MAP_PTR GC_PROTECTED /* refcount is a map_ptr offset of class_entry */ #define IS_STR_INTERNED GC_IMMUTABLE /* interned string */ #define IS_STR_PERSISTENT GC_PERSISTENT /* allocated using malloc */ -#define IS_STR_PERMANENT (1<<8) /* relives request boundary */ -#define IS_STR_VALID_UTF8 (1<<9) /* valid UTF-8 according to PCRE */ +#define IS_STR_PERMANENT (1u << 8u) /* relives request boundary */ +#define IS_STR_VALID_UTF8 (1u << 9u) /* valid UTF-8 according to PCRE */ /* array flags */ #define IS_ARRAY_IMMUTABLE GC_IMMUTABLE @@ -828,8 +828,8 @@ static zend_always_inline uint32_t zval_gc_info(uint32_t gc_type_info) { /* object flags (zval.value->gc.u.flags) */ #define IS_OBJ_WEAKLY_REFERENCED GC_PERSISTENT -#define IS_OBJ_DESTRUCTOR_CALLED (1<<8) -#define IS_OBJ_FREE_CALLED (1<<9) +#define IS_OBJ_DESTRUCTOR_CALLED (1u << 8u) +#define IS_OBJ_FREE_CALLED (1u << 9u) #define OBJ_FLAGS(obj) GC_FLAGS(obj) @@ -1558,8 +1558,8 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { * (both use IS_UNDEF type) in the Z_EXTRA space. As such we also need to copy * the Z_EXTRA space when copying property default values etc. We define separate * macros for this purpose, so this workaround is easier to remove in the future. */ -#define IS_PROP_UNINIT (1<<0) -#define IS_PROP_REINITABLE (1<<1) /* It has impact only on readonly properties */ +#define IS_PROP_UNINIT (1u << 0u) +#define IS_PROP_REINITABLE (1u << 1u) /* It has impact only on readonly properties */ #define Z_PROP_FLAG_P(z) Z_EXTRA_P(z) #define ZVAL_COPY_VALUE_PROP(z, v) \ do { *(z) = *(v); } while (0) From bc61f971b6cba4bfd4ebe0dc675cbeb9cb360fb1 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:50 +0100 Subject: [PATCH 07/28] Add type cast in smart_str header --- Zend/zend_smart_str.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Zend/zend_smart_str.h b/Zend/zend_smart_str.h index e271835e41db9..878dfd68d2f68 100644 --- a/Zend/zend_smart_str.h +++ b/Zend/zend_smart_str.h @@ -144,7 +144,7 @@ static zend_always_inline void smart_str_append_smart_str_ex(smart_str *dest, co static zend_always_inline void smart_str_append_long_ex(smart_str *dest, zend_long num, bool persistent) { char buf[32]; char *result = zend_print_long_to_buf(buf + sizeof(buf) - 1, num); - smart_str_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent); + smart_str_appendl_ex(dest, result, (size_t)(buf + sizeof(buf) - 1 - result), persistent); } static zend_always_inline void smart_str_append_long(smart_str *dest, zend_long num) @@ -155,7 +155,7 @@ static zend_always_inline void smart_str_append_long(smart_str *dest, zend_long static zend_always_inline void smart_str_append_unsigned_ex(smart_str *dest, zend_ulong num, bool persistent) { char buf[32]; char *result = zend_print_ulong_to_buf(buf + sizeof(buf) - 1, num); - smart_str_appendl_ex(dest, result, buf + sizeof(buf) - 1 - result, persistent); + smart_str_appendl_ex(dest, result, (size_t)(buf + sizeof(buf) - 1 - result), persistent); } static zend_always_inline void smart_str_append_unsigned(smart_str *dest, zend_ulong num) From 7210226ee6a2559ba18377bbb72df4991590e9a0 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:50 +0100 Subject: [PATCH 08/28] Use size_t instead of int for stack ptr --- Zend/zend_ptr_stack.c | 16 ++++++++-------- Zend/zend_ptr_stack.h | 4 ++-- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Zend/zend_ptr_stack.c b/Zend/zend_ptr_stack.c index 80c77e11d73e6..76bba7e72322d 100644 --- a/Zend/zend_ptr_stack.c +++ b/Zend/zend_ptr_stack.c @@ -79,16 +79,16 @@ ZEND_API void zend_ptr_stack_destroy(zend_ptr_stack *stack) ZEND_API void zend_ptr_stack_apply(zend_ptr_stack *stack, void (*func)(void *)) { - int i = stack->top; + size_t i = stack->top; - while (--i >= 0) { - func(stack->elements[i]); + while (i > 0) { + func(stack->elements[--i]); } } ZEND_API void zend_ptr_stack_reverse_apply(zend_ptr_stack *stack, void (*func)(void *)) { - int i = 0; + size_t i = 0; while (i < stack->top) { func(stack->elements[i++]); @@ -100,10 +100,10 @@ ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), { zend_ptr_stack_apply(stack, func); if (free_elements) { - int i = stack->top; + size_t i = stack->top; - while (--i >= 0) { - pefree(stack->elements[i], stack->persistent); + while (i > 0) { + pefree(stack->elements[--i], stack->persistent); } } stack->top = 0; @@ -111,7 +111,7 @@ ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), } -ZEND_API int zend_ptr_stack_num_elements(zend_ptr_stack *stack) +ZEND_API size_t zend_ptr_stack_num_elements(zend_ptr_stack *stack) { return stack->top; } diff --git a/Zend/zend_ptr_stack.h b/Zend/zend_ptr_stack.h index 3ef1478fe4c3d..fe214bde78b8f 100644 --- a/Zend/zend_ptr_stack.h +++ b/Zend/zend_ptr_stack.h @@ -23,7 +23,7 @@ #include "zend_alloc.h" typedef struct _zend_ptr_stack { - int top, max; + size_t top, max; void **elements; void **top_element; bool persistent; @@ -41,7 +41,7 @@ ZEND_API void zend_ptr_stack_destroy(zend_ptr_stack *stack); ZEND_API void zend_ptr_stack_apply(zend_ptr_stack *stack, void (*func)(void *)); ZEND_API void zend_ptr_stack_reverse_apply(zend_ptr_stack *stack, void (*func)(void *)); ZEND_API void zend_ptr_stack_clean(zend_ptr_stack *stack, void (*func)(void *), bool free_elements); -ZEND_API int zend_ptr_stack_num_elements(zend_ptr_stack *stack); +ZEND_API size_t zend_ptr_stack_num_elements(zend_ptr_stack *stack); END_EXTERN_C() #define ZEND_PTR_STACK_RESIZE_IF_NEEDED(stack, count) \ From 226ccf4b42e59c12f93d6de3859462b374834c7f Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:51 +0100 Subject: [PATCH 09/28] Use uint32_t for CE property count --- Zend/zend.h | 5 +++-- Zend/zend_objects_API.h | 1 + 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/Zend/zend.h b/Zend/zend.h index bc252f4706b0c..5d906f5a8a501 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -155,8 +155,9 @@ struct _zend_class_entry { int refcount; uint32_t ce_flags; - int default_properties_count; - int default_static_members_count; + // TODO Use size_t instead? + uint32_t default_properties_count; + uint32_t default_static_members_count; zval *default_properties_table; zval *default_static_members_table; ZEND_MAP_PTR_DEF(zval *, static_members_table); diff --git a/Zend/zend_objects_API.h b/Zend/zend_objects_API.h index 95fa5acf62fb7..4bb8afd99abfa 100644 --- a/Zend/zend_objects_API.h +++ b/Zend/zend_objects_API.h @@ -82,6 +82,7 @@ static zend_always_inline void zend_object_release(zend_object *obj) static zend_always_inline size_t zend_object_properties_size(zend_class_entry *ce) { + if (!ce->default_properties_count) { return 0; } return sizeof(zval) * (ce->default_properties_count - ((ce->ce_flags & ZEND_ACC_USE_GUARDS) ? 0 : 1)); From 8cedf1fdc0a1781746cb47973405900f83614916 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:51 +0100 Subject: [PATCH 10/28] Use uint32_t instead of int for nb of CV vars --- Zend/zend_compile.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index f4291d3972558..c03c04ecdd207 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -471,7 +471,7 @@ struct _zend_op_array { /* END of common elements */ int cache_size; /* number of run_time_cache_slots * sizeof(void*) */ - int last_var; /* number of CV variables */ + uint32_t last_var; /* number of CV variables */ uint32_t last; /* number of opcodes */ zend_op *opcodes; From 277452d4aff18e6a09c64e43a7d353703633eea5 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:51 +0100 Subject: [PATCH 11/28] hval is a zend_ulong, add type cast --- Zend/zend_execute.c | 14 ++-- Zend/zend_vm_def.h | 14 ++-- Zend/zend_vm_execute.h | 150 ++++++++++++++++++++--------------------- 3 files changed, 89 insertions(+), 89 deletions(-) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index facd7239c74d7..c15ec9841137b 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -2482,7 +2482,7 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht try_again: if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { - hval = Z_LVAL_P(dim); + hval = (zend_ulong) Z_LVAL_P(dim); num_index: if (type != BP_VAR_W) { ZEND_HASH_INDEX_FIND(ht, hval, retval, num_undef); @@ -2546,7 +2546,7 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht offset_key = val.str; goto str_index; } else if (t == IS_LONG) { - hval = val.lval; + hval = (zend_ulong) val.lval; goto num_index; } else { retval = (type == BP_VAR_W || type == BP_VAR_RW) ? @@ -2908,7 +2908,7 @@ static zend_never_inline zval* ZEND_FASTCALL zend_find_array_dim_slow(HashTable zend_ulong hval; if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); num_idx: return zend_hash_index_find(ht, hval); } else if (Z_TYPE_P(offset) == IS_NULL) { @@ -2922,7 +2922,7 @@ static zend_never_inline zval* ZEND_FASTCALL zend_find_array_dim_slow(HashTable goto num_idx; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_idx; } else if (/*OP2_TYPE == IS_CV &&*/ Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -3025,14 +3025,14 @@ static zend_never_inline bool ZEND_FASTCALL zend_array_key_exists_fast(HashTable str_key: return zend_hash_exists(ht, str); } else if (EXPECTED(Z_TYPE_P(key) == IS_LONG)) { - hval = Z_LVAL_P(key); + hval = (zend_ulong) Z_LVAL_P(key); num_key: return zend_hash_index_exists(ht, hval); } else if (EXPECTED(Z_ISREF_P(key))) { key = Z_REFVAL_P(key); goto try_again; } else if (Z_TYPE_P(key) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(key)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(key)); goto num_key; } else if (Z_TYPE_P(key) == IS_FALSE) { hval = 0; @@ -3042,7 +3042,7 @@ static zend_never_inline bool ZEND_FASTCALL zend_array_key_exists_fast(HashTable goto num_key; } else if (Z_TYPE_P(key) == IS_RESOURCE) { zend_use_resource_as_offset(key); - hval = Z_RES_HANDLE_P(key); + hval = (zend_ulong) Z_RES_HANDLE_P(key); goto num_key; } else if (Z_TYPE_P(key) <= IS_NULL) { if (UNEXPECTED(Z_TYPE_P(key) == IS_UNDEF)) { diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 8327fe95f7aea..50d9236f21cd6 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -6110,7 +6110,7 @@ ZEND_VM_C_LABEL(add_again): ZEND_VM_C_LABEL(str_index): zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); ZEND_VM_C_LABEL(num_index): zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -6120,7 +6120,7 @@ ZEND_VM_C_LABEL(num_index): str = ZSTR_EMPTY_ALLOC(); ZEND_VM_C_GOTO(str_index); } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); ZEND_VM_C_GOTO(num_index); } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -6130,7 +6130,7 @@ ZEND_VM_C_LABEL(num_index): ZEND_VM_C_GOTO(num_index); } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); ZEND_VM_C_GOTO(num_index); } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -6622,14 +6622,14 @@ ZEND_VM_C_LABEL(str_index_dim): ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); ZEND_VM_C_LABEL(num_index_dim): zend_hash_index_del(ht, hval); } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); ZEND_VM_C_GOTO(offset_again); } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); ZEND_VM_C_GOTO(num_index_dim); } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -6642,7 +6642,7 @@ ZEND_VM_C_LABEL(num_index_dim): ZEND_VM_C_GOTO(num_index_dim); } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); ZEND_VM_C_GOTO(num_index_dim); } else if (OP2_TYPE == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -7404,7 +7404,7 @@ ZEND_VM_C_LABEL(isset_again): } value = zend_hash_find_ex(ht, str, OP2_TYPE == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); ZEND_VM_C_LABEL(num_index_prop): value = zend_hash_index_find(ht, hval); } else if ((OP2_TYPE & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index e6010c96933e4..23a114991f60b 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -7492,7 +7492,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -7502,7 +7502,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -7512,7 +7512,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -7582,7 +7582,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM } value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -9823,7 +9823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_T str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -9833,7 +9833,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_T str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -9843,7 +9843,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_T goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -9913,7 +9913,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON } value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -10753,7 +10753,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_U str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -10763,7 +10763,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_U str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -10773,7 +10773,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_U goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -12208,7 +12208,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -12218,7 +12218,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -12228,7 +12228,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_C goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -12298,7 +12298,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CON } value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -16419,7 +16419,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP } value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -17836,7 +17836,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP } value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -19195,7 +19195,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP } value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -20235,7 +20235,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CON str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -20245,7 +20245,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CON str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -20255,7 +20255,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CON goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -20679,7 +20679,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -20689,7 +20689,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -20699,7 +20699,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -21140,7 +21140,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNU str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -21150,7 +21150,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNU str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -21160,7 +21160,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNU goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -21544,7 +21544,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_ str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -21554,7 +21554,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_ str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -21564,7 +21564,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_ goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -25373,7 +25373,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CON str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -25383,7 +25383,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CON str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -25393,7 +25393,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CON goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -25465,14 +25465,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDL ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -25485,7 +25485,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDL goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index_dim; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -27823,7 +27823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -27833,7 +27833,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -27843,7 +27843,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -27915,14 +27915,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HAND ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -27935,7 +27935,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HAND goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index_dim; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -29901,7 +29901,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNU str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -29911,7 +29911,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNU str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -29921,7 +29921,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNU goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -32211,7 +32211,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_ str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -32221,7 +32221,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_ str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -32231,7 +32231,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_ goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -32303,14 +32303,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER( ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -32323,7 +32323,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER( goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index_dim; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -43927,7 +43927,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONS str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -43937,7 +43937,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONS str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -43947,7 +43947,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONS goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -44019,14 +44019,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLE ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -44039,7 +44039,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLE goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index_dim; } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -44152,7 +44152,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ } value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -47567,7 +47567,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -47577,7 +47577,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -47587,7 +47587,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPV goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -47659,14 +47659,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDL ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -47679,7 +47679,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDL goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index_dim; } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -47794,7 +47794,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ } value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { @@ -49536,7 +49536,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUS str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_UNUSED & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -49546,7 +49546,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUS str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -49556,7 +49556,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUS goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_UNUSED == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -53053,7 +53053,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H str_index: zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { @@ -53063,7 +53063,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H str = ZSTR_EMPTY_ALLOC(); goto str_index; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index; } else if (Z_TYPE_P(offset) == IS_FALSE) { hval = 0; @@ -53073,7 +53073,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_H goto num_index; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -53145,14 +53145,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(Z ZEND_ASSERT(ht != &EG(symbol_table)); zend_hash_del(ht, key); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + hval = (zend_ulong) zend_dval_to_lval_safe(Z_DVAL_P(offset)); goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_NULL) { key = ZSTR_EMPTY_ALLOC(); @@ -53165,7 +53165,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(Z goto num_index_dim; } else if (Z_TYPE_P(offset) == IS_RESOURCE) { zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); + hval = (zend_ulong) Z_RES_HANDLE_P(offset); goto num_index_dim; } else if (IS_CV == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); @@ -53278,7 +53278,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_ } value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); + hval = (zend_ulong) Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { From 7193e0b476ea8c893fae4c42e6ad18ebdcff0a22 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:52 +0100 Subject: [PATCH 12/28] Add size_t cast in macro expansion --- sapi/cli/php_http_parser.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sapi/cli/php_http_parser.c b/sapi/cli/php_http_parser.c index c7c2ad0caaeaa..f05fc3fd16f7c 100644 --- a/sapi/cli/php_http_parser.c +++ b/sapi/cli/php_http_parser.c @@ -31,7 +31,7 @@ #define CALLBACK2(FOR) \ do { \ if (settings->on_##FOR) { \ - if (0 != settings->on_##FOR(parser)) return (p - data); \ + if (0 != settings->on_##FOR(parser)) return (size_t)(p - data); \ } \ } while (0) @@ -47,9 +47,9 @@ do { \ if (settings->on_##FOR) { \ if (0 != settings->on_##FOR(parser, \ FOR##_mark, \ - p - FOR##_mark)) \ + (size_t)(p - FOR##_mark))) \ { \ - return (p - data); \ + return (size_t)(p - data); \ } \ } \ } \ From 368428aec3bc3fa328cc23677b4ca843a23c8492 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:52 +0100 Subject: [PATCH 13/28] Fix sign conversion warnings in JSON extension --- ext/json/json_encoder.c | 4 ++-- ext/json/json_scanner.re | 38 +++++++++++++++++++------------------- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/ext/json/json_encoder.c b/ext/json/json_encoder.c index 4709c0e2be4a7..97e5753981f3c 100644 --- a/ext/json/json_encoder.c +++ b/ext/json/json_encoder.c @@ -112,7 +112,7 @@ static inline void php_json_encode_double(smart_str *buf, double d, int options) static zend_result php_json_encode_array(smart_str *buf, zval *val, int options, php_json_encoder *encoder) /* {{{ */ { - int i, r, need_comma = 0; + int r, need_comma = 0; HashTable *myht, *prop_ht; if (Z_TYPE_P(val) == IS_ARRAY) { @@ -219,7 +219,7 @@ static zend_result php_json_encode_array(smart_str *buf, zval *val, int options, ++encoder->depth; - i = myht ? zend_hash_num_elements(myht) : 0; + zend_ulong i = myht ? zend_hash_num_elements(myht) : 0; if (i > 0) { zend_string *key; diff --git a/ext/json/json_scanner.re b/ext/json/json_scanner.re index 1db43dd081a56..0debb3b03cb22 100644 --- a/ext/json/json_scanner.re +++ b/ext/json/json_scanner.re @@ -53,16 +53,16 @@ #define PHP_JSON_INT_MAX_LENGTH (MAX_LENGTH_OF_LONG - 1) -static void php_json_scanner_copy_string(php_json_scanner *s, int esc_size) +static void php_json_scanner_copy_string(php_json_scanner *s, size_t esc_size) { - size_t len = s->cursor - s->str_start - esc_size - 1; + size_t len = (size_t)(s->cursor - s->str_start - esc_size - 1); if (len) { memcpy(s->pstr, s->str_start, len); s->pstr += len; } } -static int php_json_hex_to_int(char code) +static int php_json_hex_to_int(unsigned char code) { if (code >= '0' && code <= '9') { return code - '0'; @@ -184,7 +184,7 @@ std: ZVAL_LONG(&s->value, ZEND_STRTOL((char *) s->token, NULL, 10)); return PHP_JSON_T_INT; } else if (s->options & PHP_JSON_BIGINT_AS_STRING) { - ZVAL_STRINGL(&s->value, (char *) s->token, s->cursor - s->token); + ZVAL_STRINGL(&s->value, (char *) s->token, (size_t)(s->cursor - s->token)); return PHP_JSON_T_STRING; } else { ZVAL_DOUBLE(&s->value, zend_strtod((char *) s->token, NULL)); @@ -258,7 +258,7 @@ std: } ["] { zend_string *str; - size_t len = s->cursor - s->str_start - s->str_esc - 1 + s->utf8_invalid_count; + size_t len = (size_t)(s->cursor - s->str_start - s->str_esc - 1 + s->utf8_invalid_count); if (len == 0) { PHP_JSON_CONDITION_SET(JS); ZVAL_EMPTY_STRING(&s->value); @@ -299,24 +299,24 @@ std: UTF16_1 { int utf16 = php_json_ucs2_to_int(s, 2); PHP_JSON_SCANNER_COPY_UTF(); - *(s->pstr++) = (char) utf16; + *(s->pstr++) = (unsigned char) utf16; s->str_start = s->cursor; PHP_JSON_CONDITION_GOTO_STR_P2(); } UTF16_2 { int utf16 = php_json_ucs2_to_int(s, 3); PHP_JSON_SCANNER_COPY_UTF(); - *(s->pstr++) = (char) (0xc0 | (utf16 >> 6)); - *(s->pstr++) = (char) (0x80 | (utf16 & 0x3f)); + *(s->pstr++) = (unsigned char) (0xc0 | (utf16 >> 6)); + *(s->pstr++) = (unsigned char) (0x80 | (utf16 & 0x3f)); s->str_start = s->cursor; PHP_JSON_CONDITION_GOTO_STR_P2(); } UTF16_3 { int utf16 = php_json_ucs2_to_int(s, 4); PHP_JSON_SCANNER_COPY_UTF(); - *(s->pstr++) = (char) (0xe0 | (utf16 >> 12)); - *(s->pstr++) = (char) (0x80 | ((utf16 >> 6) & 0x3f)); - *(s->pstr++) = (char) (0x80 | (utf16 & 0x3f)); + *(s->pstr++) = (unsigned char) (0xe0 | (utf16 >> 12)); + *(s->pstr++) = (unsigned char) (0x80 | ((utf16 >> 6) & 0x3f)); + *(s->pstr++) = (unsigned char) (0x80 | (utf16 & 0x3f)); s->str_start = s->cursor; PHP_JSON_CONDITION_GOTO_STR_P2(); } @@ -326,15 +326,15 @@ std: utf16_lo = php_json_ucs2_to_int_ex(s, 4, 7); utf32 = ((utf16_lo & 0x3FF) << 10) + (utf16_hi & 0x3FF) + 0x10000; PHP_JSON_SCANNER_COPY_UTF_SP(); - *(s->pstr++) = (char) (0xf0 | (utf32 >> 18)); - *(s->pstr++) = (char) (0x80 | ((utf32 >> 12) & 0x3f)); - *(s->pstr++) = (char) (0x80 | ((utf32 >> 6) & 0x3f)); - *(s->pstr++) = (char) (0x80 | (utf32 & 0x3f)); + *(s->pstr++) = (unsigned char) (0xf0 | (utf32 >> 18)); + *(s->pstr++) = (unsigned char) (0x80 | ((utf32 >> 12) & 0x3f)); + *(s->pstr++) = (unsigned char) (0x80 | ((utf32 >> 6) & 0x3f)); + *(s->pstr++) = (unsigned char) (0x80 | (utf32 & 0x3f)); s->str_start = s->cursor; PHP_JSON_CONDITION_GOTO_STR_P2(); } ESCPREF { - char esc; + unsigned char esc; PHP_JSON_SCANNER_COPY_ESC(); switch (*s->cursor) { case 'b': @@ -374,9 +374,9 @@ std: if (s->utf8_invalid) { PHP_JSON_SCANNER_COPY_ESC(); if (s->options & PHP_JSON_INVALID_UTF8_SUBSTITUTE) { - *(s->pstr++) = (char) (0xe0 | (0xfffd >> 12)); - *(s->pstr++) = (char) (0x80 | ((0xfffd >> 6) & 0x3f)); - *(s->pstr++) = (char) (0x80 | (0xfffd & 0x3f)); + *(s->pstr++) = (unsigned char) (0xe0 | (0xfffd >> 12)); + *(s->pstr++) = (unsigned char) (0x80 | ((0xfffd >> 6) & 0x3f)); + *(s->pstr++) = (unsigned char) (0x80 | (0xfffd & 0x3f)); } s->str_start = s->cursor; } From baf3f43ae04d9dbdec4e4345ba7e5e18659e3afb Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:52 +0100 Subject: [PATCH 14/28] Fix sign-conversion warnings in Reflection --- ext/reflection/php_reflection.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 88f2253e98a55..2c950c2629601 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -306,7 +306,7 @@ static void _zend_extension_string(smart_str *str, zend_extension *extension, ch /* {{{ _class_string */ static void _class_string(smart_str *str, zend_class_entry *ce, zval *obj, char *indent) { - int count, count_static_props = 0, count_static_funcs = 0, count_shadow_props = 0; + uint32_t count, count_static_props = 0, count_static_funcs = 0, count_shadow_props = 0; zend_string *sub_indent = strpprintf(0, "%s ", indent); /* TBD: Repair indenting of doc comment (or is this to be done in the parser?) */ @@ -1280,7 +1280,7 @@ static void _zend_extension_string(smart_str *str, zend_extension *extension, ch /* }}} */ /* {{{ _function_check_flag */ -static void _function_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) +static void _function_check_flag(INTERNAL_FUNCTION_PARAMETERS, unsigned int mask) { reflection_object *intern; zend_function *mptr; @@ -3295,7 +3295,7 @@ static void instantiate_reflection_method(INTERNAL_FUNCTION_PARAMETERS, bool is_ zend_argument_error(reflection_exception_ptr, 1, "must be a valid method name"); RETURN_THROWS(); } - tmp_len = tmp - name; + tmp_len = (size_t)(tmp - name); class_name = zend_string_init(name, tmp_len, 0); method_name = tmp + 2; @@ -3929,7 +3929,7 @@ ZEND_METHOD(ReflectionClassConstant, hasType) RETVAL_BOOL(ZEND_TYPE_IS_SET(ref->type)); } -static void _class_constant_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) /* {{{ */ +static void _class_constant_check_flag(INTERNAL_FUNCTION_PARAMETERS, unsigned int mask) /* {{{ */ { reflection_object *intern; zend_class_constant *ref; @@ -4678,7 +4678,7 @@ ZEND_METHOD(ReflectionClass, getProperty) } str_name = ZSTR_VAL(name); if ((tmp = strstr(ZSTR_VAL(name), "::")) != NULL) { - classname_len = tmp - ZSTR_VAL(name); + classname_len = (size_t)(tmp - ZSTR_VAL(name)); classname = zend_string_alloc(classname_len, 0); zend_str_tolower_copy(ZSTR_VAL(classname), ZSTR_VAL(name), classname_len); ZSTR_VAL(classname)[classname_len] = '\0'; @@ -4919,7 +4919,7 @@ ZEND_METHOD(ReflectionClass, getReflectionConstant) /* }}} */ /* {{{ _class_check_flag */ -static void _class_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) +static void _class_check_flag(INTERNAL_FUNCTION_PARAMETERS, unsigned int mask) { reflection_object *intern; zend_class_entry *ce; @@ -5083,7 +5083,7 @@ ZEND_METHOD(ReflectionClass, newInstance) /* Run the constructor if there is one */ if (constructor) { zval *params; - int num_args; + uint32_t num_args; HashTable *named_params; if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) { @@ -5136,7 +5136,7 @@ ZEND_METHOD(ReflectionClass, newInstanceArgs) { reflection_object *intern; zend_class_entry *ce, *old_scope; - int argc = 0; + uint32_t argc = 0; HashTable *args = NULL; zend_function *constructor; @@ -5648,7 +5648,7 @@ ZEND_METHOD(ReflectionProperty, getName) } /* }}} */ -static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask) /* {{{ */ +static void _property_check_flag(INTERNAL_FUNCTION_PARAMETERS, unsigned int mask) /* {{{ */ { reflection_object *intern; property_reference *ref; @@ -6542,7 +6542,7 @@ ZEND_METHOD(ReflectionReference, fromArrayElement) if (string_key) { item = zend_hash_find(ht, string_key); } else { - item = zend_hash_index_find(ht, int_key); + item = zend_hash_index_find(ht, (zend_ulong)int_key); } if (!item) { From e26712eab5d8eddb8991658739c49b02beb300ee Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:53 +0100 Subject: [PATCH 15/28] Fix some sign-conversion warnings in basic_functions.c --- ext/standard/basic_functions.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c index 6e923d20ecbd6..1e36e30ea5ede 100644 --- a/ext/standard/basic_functions.c +++ b/ext/standard/basic_functions.c @@ -926,7 +926,8 @@ PHP_FUNCTION(getopt) char *options = NULL, **argv = NULL; char opt[2] = { '\0' }; char *optname; - int argc = 0, o; + uint32_t argc = 0; + int o; size_t options_len = 0, len; char *php_optarg = NULL; int php_optind = 1; @@ -954,7 +955,7 @@ PHP_FUNCTION(getopt) ((args = zend_hash_find_ex_ind(Z_ARRVAL_P(&PG(http_globals)[TRACK_VARS_SERVER]), ZSTR_KNOWN(ZEND_STR_ARGV), 1)) != NULL || (args = zend_hash_find_ex_ind(&EG(symbol_table), ZSTR_KNOWN(ZEND_STR_ARGV), 1)) != NULL) ) { - int pos = 0; + size_t pos = 0; zval *entry; if (Z_TYPE_P(args) != IS_ARRAY) { @@ -987,7 +988,7 @@ PHP_FUNCTION(getopt) len = parse_opts(options, &opts); if (p_longopts) { - int count; + uint32_t count; zval *entry; count = zend_hash_num_elements(Z_ARRVAL_P(p_longopts)); From 795df7cc68b6f1d79ace6a3462488cd9986703aa Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:53 +0100 Subject: [PATCH 16/28] Fix some sign-conversions warnings in standard ext --- ext/standard/array.c | 18 +++++++++--------- ext/standard/exec.c | 12 +++++++----- ext/standard/file.c | 3 ++- ext/standard/formatted_print.c | 18 +++++++++--------- ext/standard/pack.c | 4 ++-- ext/standard/streamsfuncs.c | 5 ++--- ext/standard/string.c | 5 +++-- ext/standard/var.c | 8 ++++---- 8 files changed, 38 insertions(+), 35 deletions(-) diff --git a/ext/standard/array.c b/ext/standard/array.c index f1e65698fc36e..cc69260d1dbf3 100644 --- a/ext/standard/array.c +++ b/ext/standard/array.c @@ -3778,7 +3778,7 @@ PHP_FUNCTION(array_splice) zend_long offset, length = 0; bool length_is_null = 1; - int num_in; /* Number of elements in the input array */ + uint32_t num_in; /* Number of elements in the input array */ ZEND_PARSE_PARAMETERS_START(2, 4) Z_PARAM_ARRAY_EX(array, 0, 1) @@ -3805,7 +3805,7 @@ PHP_FUNCTION(array_splice) zend_long size = length; /* Clamp the offset.. */ - if (offset > num_in) { + if (offset > (zend_long)num_in) { offset = num_in; } else if (offset < 0 && (offset = (num_in + offset)) < 0) { offset = 0; @@ -3814,7 +3814,7 @@ PHP_FUNCTION(array_splice) /* ..and the length */ if (length < 0) { size = num_in - offset + length; - } else if (((zend_ulong) offset + (zend_ulong) length) > (uint32_t) num_in) { + } else if (((zend_ulong) offset + (zend_ulong) length) > num_in) { size = num_in - offset; } @@ -4931,7 +4931,7 @@ PHP_FUNCTION(array_unique) if (sort_type == PHP_SORT_STRING) { HashTable seen; - zend_long num_key; + zend_ulong num_key; zend_string *str_key; zval *val; @@ -5808,7 +5808,7 @@ PHP_FUNCTION(array_diff) HashTable exclude; zval *value; zend_string *str, *tmp_str, *key; - zend_long idx; + zend_ulong idx; zval dummy; ZEND_PARSE_PARAMETERS_START(1, -1) @@ -6741,11 +6741,11 @@ PHP_FUNCTION(array_all) PHP_FUNCTION(array_map) { zval *arrays = NULL; - int n_arrays = 0; + uint32_t n_arrays = 0; zval result; zend_fcall_info fci = empty_fcall_info; zend_fcall_info_cache fci_cache = empty_fcall_info_cache; - int i; + uint32_t i; uint32_t k, maxlen = 0; ZEND_PARSE_PARAMETERS_START(2, -1) @@ -6960,7 +6960,7 @@ PHP_FUNCTION(array_key_exists) /* {{{ Split array into chunks */ PHP_FUNCTION(array_chunk) { - int num_in; + uint32_t num_in; zend_long size, current = 0; zend_string *str_key; zend_ulong num_key; @@ -7035,7 +7035,7 @@ PHP_FUNCTION(array_combine) HashTable *values, *keys; uint32_t pos_values = 0; zval *entry_keys, *entry_values; - int num_keys, num_values; + uint32_t num_keys, num_values; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_ARRAY_HT(keys) diff --git a/ext/standard/exec.c b/ext/standard/exec.c index 5b3ba60e5fdea..9b6d71bfa5196 100644 --- a/ext/standard/exec.c +++ b/ext/standard/exec.c @@ -56,13 +56,15 @@ static size_t cmd_max_len; PHP_MINIT_FUNCTION(exec) { #ifdef _SC_ARG_MAX - cmd_max_len = sysconf(_SC_ARG_MAX); - if ((size_t)-1 == cmd_max_len) { -#ifdef _POSIX_ARG_MAX + long sysconf_val = sysconf(_SC_ARG_MAX); + if (-1 == cmd_max_len) { +# ifdef _POSIX_ARG_MAX cmd_max_len = _POSIX_ARG_MAX; -#else +# else cmd_max_len = 4096; -#endif +# endif + } else { + cmd_max_len = (size_t) sysconf_val; } #elif defined(ARG_MAX) cmd_max_len = ARG_MAX; diff --git a/ext/standard/file.c b/ext/standard/file.c index 651c13a4f8df6..9cb79a722965d 100644 --- a/ext/standard/file.c +++ b/ext/standard/file.c @@ -948,7 +948,8 @@ PHPAPI PHP_FUNCTION(fgetc) /* {{{ Implements a mostly ANSI compatible fscanf() */ PHP_FUNCTION(fscanf) { - int result, argc = 0; + int result; + uint32_t argc = 0; size_t format_len; zval *args = NULL; zval *file_handle; diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c index ba0f73d9a9c22..5e91cb4283307 100644 --- a/ext/standard/formatted_print.c +++ b/ext/standard/formatted_print.c @@ -419,7 +419,7 @@ int php_sprintf_get_argnum(char **format, size_t *format_len) { * - 0 or more: ArgumentCountError is thrown */ static zend_string * -php_formatted_print(char *format, size_t format_len, zval *args, int argc, int nb_additional_parameters) +php_formatted_print(char *format, size_t format_len, zval *args, uint32_t argc, int nb_additional_parameters) { size_t size = 240, outpos = 0; int alignment, currarg, adjusting, argnum, width, precision; @@ -733,10 +733,10 @@ php_formatted_print(char *format, size_t format_len, zval *args, int argc, int n /* }}} */ /* php_formatted_print_get_array() {{{ */ -static zval *php_formatted_print_get_array(zend_array *array, int *argc) +static zval *php_formatted_print_get_array(zend_array *array, uint32_t *argc) { zval *args, *zv; - int n; + uint32_t n; n = zend_hash_num_elements(array); args = (zval *)safe_emalloc(n, sizeof(zval), 0); @@ -758,7 +758,7 @@ PHP_FUNCTION(sprintf) char *format; size_t format_len; zval *args; - int argc; + uint32_t argc; ZEND_PARSE_PARAMETERS_START(1, -1) Z_PARAM_STRING(format, format_len) @@ -781,7 +781,7 @@ PHP_FUNCTION(vsprintf) size_t format_len; zval *args; zend_array *array; - int argc; + uint32_t argc; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_STRING(format, format_len) @@ -807,7 +807,7 @@ PHP_FUNCTION(printf) char *format; size_t format_len; zval *args; - int argc; + uint32_t argc; ZEND_PARSE_PARAMETERS_START(1, -1) Z_PARAM_STRING(format, format_len) @@ -833,7 +833,7 @@ PHP_FUNCTION(vprintf) size_t format_len; zval *args; zend_array *array; - int argc; + uint32_t argc; ZEND_PARSE_PARAMETERS_START(2, 2) Z_PARAM_STRING(format, format_len) @@ -860,7 +860,7 @@ PHP_FUNCTION(fprintf) char *format; size_t format_len; zval *arg1, *args; - int argc; + uint32_t argc; zend_string *result; ZEND_PARSE_PARAMETERS_START(2, -1) @@ -891,7 +891,7 @@ PHP_FUNCTION(vfprintf) size_t format_len; zval *arg1, *args; zend_array *array; - int argc; + uint32_t argc; zend_string *result; ZEND_PARSE_PARAMETERS_START(3, 3) diff --git a/ext/standard/pack.c b/ext/standard/pack.c index 28d0f3af11c2c..ff453ac98f3f4 100644 --- a/ext/standard/pack.c +++ b/ext/standard/pack.c @@ -230,9 +230,9 @@ static double php_pack_parse_double(int is_little_endian, void * src) PHP_FUNCTION(pack) { zval *argv = NULL; - int num_args = 0; + uint32_t num_args = 0; size_t i; - int currentarg; + uint32_t currentarg; char *format; size_t formatlen; char *formatcodes; diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c index c4165836ecbeb..316665922976f 100644 --- a/ext/standard/streamsfuncs.c +++ b/ext/standard/streamsfuncs.c @@ -1415,7 +1415,6 @@ PHP_FUNCTION(stream_set_timeout) zend_long seconds, microseconds = 0; struct timeval t; php_stream *stream; - int argc = ZEND_NUM_ARGS(); ZEND_PARSE_PARAMETERS_START(2, 3) Z_PARAM_RESOURCE(socket) @@ -1429,7 +1428,7 @@ PHP_FUNCTION(stream_set_timeout) #ifdef PHP_WIN32 t.tv_sec = (long)seconds; - if (argc == 3) { + if (microseconds != 0) { t.tv_usec = (long)(microseconds % 1000000); t.tv_sec +=(long)(microseconds / 1000000); } else { @@ -1438,7 +1437,7 @@ PHP_FUNCTION(stream_set_timeout) #else t.tv_sec = seconds; - if (argc == 3) { + if (microseconds != 0) { t.tv_usec = microseconds % 1000000; t.tv_sec += microseconds / 1000000; } else { diff --git a/ext/standard/string.c b/ext/standard/string.c index f71c2db5972ef..0aeb0c710d921 100644 --- a/ext/standard/string.c +++ b/ext/standard/string.c @@ -4969,7 +4969,7 @@ PHP_FUNCTION(setlocale) { zend_long cat; zval *args = NULL; - int num_args; + uint32_t num_args; ZEND_PARSE_PARAMETERS_START(2, -1) Z_PARAM_LONG(cat) @@ -5829,7 +5829,8 @@ PHP_FUNCTION(sscanf) zval *args = NULL; char *str, *format; size_t str_len, format_len; - int result, num_args = 0; + int result; + uint32_t num_args = 0; ZEND_PARSE_PARAMETERS_START(2, -1) Z_PARAM_STRING(str, str_len) diff --git a/ext/standard/var.c b/ext/standard/var.c index 85546320b4cae..c02dff09b5a49 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -218,8 +218,8 @@ PHPAPI void php_var_dump(zval *struc, int level) /* {{{ */ PHP_FUNCTION(var_dump) { zval *args; - int argc; - int i; + uint32_t argc; + uint32_t i; ZEND_PARSE_PARAMETERS_START(1, -1) Z_PARAM_VARIADIC('+', args, argc) @@ -410,8 +410,8 @@ PHPAPI void php_debug_zval_dump(zval *struc, int level) /* {{{ */ PHP_FUNCTION(debug_zval_dump) { zval *args; - int argc; - int i; + uint32_t argc; + uint32_t i; ZEND_PARSE_PARAMETERS_START(1, -1) Z_PARAM_VARIADIC('+', args, argc) From 2a9c23f1349e820363da585fe34d8139bea7da67 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:53 +0100 Subject: [PATCH 17/28] Fix sign-conversion warning in php_ini --- main/php_ini.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main/php_ini.c b/main/php_ini.c index 82420fd0bc600..43c25c36c9f2c 100644 --- a/main/php_ini.c +++ b/main/php_ini.c @@ -432,7 +432,7 @@ int php_init_config(void) php_ini_search_path = sapi_module.php_ini_path_override; free_ini_search_path = 0; } else if (!sapi_module.php_ini_ignore) { - int search_path_size; + size_t search_path_size; char *default_location; char *env_location; #ifdef PHP_WIN32 @@ -478,7 +478,7 @@ int php_init_config(void) * Prepare search path */ - search_path_size = MAXPATHLEN * 4 + (int)strlen(env_location) + 3 + 1; + search_path_size = MAXPATHLEN * 4 + strlen(env_location) + 3 + 1; php_ini_search_path = (char *) emalloc(search_path_size); free_ini_search_path = 1; php_ini_search_path[0] = 0; From d8dffaf9e75b0ae7b01c12300d5fa75f2ff17abb Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:54 +0100 Subject: [PATCH 18/28] Fix warnings in engine --- Zend/zend_compile.h | 2 +- Zend/zend_execute.c | 12 +-- Zend/zend_vm_def.h | 27 ++++--- Zend/zend_vm_execute.h | 165 ++++++++++++++++++++--------------------- 4 files changed, 102 insertions(+), 104 deletions(-) diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index c03c04ecdd207..e530389d35520 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -470,7 +470,7 @@ struct _zend_op_array { uint32_t T; /* number of temporary variables */ /* END of common elements */ - int cache_size; /* number of run_time_cache_slots * sizeof(void*) */ + size_t cache_size; /* number of run_time_cache_slots * sizeof(void*) */ uint32_t last_var; /* number of CV variables */ uint32_t last; /* number of opcodes */ diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index c15ec9841137b..0827464d5a3b7 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -2182,7 +2182,7 @@ static void zend_extension_fcall_end_handler(const zend_extension *extension, ze } -static zend_always_inline HashTable *zend_get_target_symbol_table(int fetch_type EXECUTE_DATA_DC) +static zend_always_inline HashTable *zend_get_target_symbol_table(uint32_t fetch_type EXECUTE_DATA_DC) { HashTable *ht; @@ -2490,7 +2490,7 @@ static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht num_undef: switch (type) { case BP_VAR_R: - zend_undefined_offset(hval); + zend_undefined_offset((zend_long) hval); ZEND_FALLTHROUGH; case BP_VAR_UNSET: case BP_VAR_IS: @@ -3877,7 +3877,7 @@ ZEND_API void zend_clean_and_cache_symbol_table(zend_array *symbol_table) /* {{{ static zend_always_inline void i_free_compiled_variables(zend_execute_data *execute_data) /* {{{ */ { zval *cv = EX_VAR_NUM(0); - int count = EX(func)->op_array.last_var; + uint32_t count = EX(func)->op_array.last_var; while (EXPECTED(count != 0)) { i_zval_ptr_dtor(cv); cv++; @@ -4160,7 +4160,7 @@ ZEND_API void zend_init_execute_data(zend_execute_data *execute_data, zend_op_ar zend_execute_data *zend_vm_stack_copy_call_frame(zend_execute_data *call, uint32_t passed_args, uint32_t additional_args) /* {{{ */ { zend_execute_data *new_call; - int used_stack = (EG(vm_stack_top) - (zval*)call) + additional_args; + uint32_t used_stack = (EG(vm_stack_top) - (zval*)call) + additional_args; /* copy call frame into new stack segment */ new_call = zend_vm_stack_extend(used_stack * sizeof(zval)); @@ -4521,7 +4521,7 @@ static void cleanup_live_vars(zend_execute_data *execute_data, uint32_t op_num, if (last->opcode == ZEND_ROPE_INIT) { zend_string_release_ex(*rope, 0); } else { - int j = last->extended_value; + uint32_t j = last->extended_value; do { zend_string_release_ex(rope[j], 0); } while (j--); @@ -4874,7 +4874,7 @@ static zend_never_inline zend_execute_data *zend_init_dynamic_call_array(zend_ar #define ZEND_FAKE_OP_ARRAY ((zend_op_array*)(intptr_t)-1) -static zend_never_inline zend_op_array* ZEND_FASTCALL zend_include_or_eval(zval *inc_filename_zv, int type) /* {{{ */ +static zend_never_inline zend_op_array* ZEND_FASTCALL zend_include_or_eval(zval *inc_filename_zv, uint32_t type) /* {{{ */ { zend_op_array *new_op_array = NULL; zend_string *tmp_inc_filename; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 50d9236f21cd6..7a789c9ac7ba0 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2109,7 +2109,7 @@ ZEND_VM_C_LABEL(fetch_obj_r_fast_copy): } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) { ZEND_VM_C_GOTO(fetch_obj_r_copy); @@ -2274,7 +2274,7 @@ ZEND_VM_C_LABEL(fetch_obj_is_fast_copy): } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (!ZEND_VM_SPEC || (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) != 0) { ZEND_VM_C_GOTO(fetch_obj_is_copy); @@ -7490,9 +7490,9 @@ ZEND_VM_COLD_CONST_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, CONST|TMPVAR|UNUSED } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((OP2_TYPE == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (OP2_TYPE != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -8048,7 +8048,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY) } uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; - int i, current_try_catch_offset = -1; + uint32_t i, current_try_catch_offset = -1; if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) && throw_op->extended_value & ZEND_FREE_ON_RETURN) { @@ -8641,7 +8641,7 @@ ZEND_VM_COLD_CONST_HANDLER(121, ZEND_STRLEN, CONST|TMPVAR|CV, ANY) ZVAL_COPY(&tmp, value); if (zend_parse_arg_str_weak(&tmp, &str, 1)) { - ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); + ZVAL_LONG(EX_VAR(opline->result.var), (zend_long)ZSTR_LEN(str)); zval_ptr_dtor(&tmp); break; } @@ -9079,8 +9079,7 @@ ZEND_VM_HANDLER(186, ZEND_ISSET_ISEMPTY_THIS, UNUSED, UNUSED) USE_OPLINE ZVAL_BOOL(EX_VAR(opline->result.var), - (opline->extended_value & ZEND_ISEMPTY) ^ - (Z_TYPE(EX(This)) == IS_OBJECT)); + (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)(Z_TYPE(EX(This)) == IS_OBJECT)); ZEND_VM_NEXT_OPCODE(); } @@ -9147,7 +9146,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(187, ZEND_SWITCH_LONG, CONST|TMPVARCV, CONST, JM } jumptable = Z_ARRVAL_P(GET_OP2_ZVAL_PTR(BP_VAR_R)); - jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + jump_zv = zend_hash_index_find(jumptable, (zend_ulong)Z_LVAL_P(op)); if (jump_zv != NULL) { ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv)); ZEND_VM_CONTINUE(); @@ -9202,7 +9201,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(195, ZEND_MATCH, CONST|TMPVARCV, CONST, JMP_ADDR ZEND_VM_C_LABEL(match_try_again): if (Z_TYPE_P(op) == IS_LONG) { - jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + jump_zv = zend_hash_index_find(jumptable, (zend_ulong)Z_LVAL_P(op)); } else if (Z_TYPE_P(op) == IS_STRING) { jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), OP1_TYPE == IS_CONST); } else if (Z_TYPE_P(op) == IS_REFERENCE) { @@ -9261,7 +9260,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } SAVE_OPLINE(); @@ -9272,7 +9271,7 @@ ZEND_VM_COLD_CONSTCONST_HANDLER(189, ZEND_IN_ARRAY, CONST|TMP|VAR|CV, CONST, NUM FREE_OP1(); ZEND_VM_SMART_BRANCH(result, 0); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); FREE_OP1(); ZEND_VM_SMART_BRANCH(result, 0); } @@ -10066,7 +10065,7 @@ ZEND_VM_C_LABEL(fetch_dim_r_index_array): ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, ZEND_VM_C_LABEL(fetch_dim_r_index_undef)); + ZEND_HASH_INDEX_FIND(ht, (zend_ulong)offset, value, ZEND_VM_C_LABEL(fetch_dim_r_index_undef)); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); if (OP1_TYPE & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 23a114991f60b..93680fd7ed69b 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -3229,7 +3229,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_HANDLE_EXCEPTION_SPEC_HANDLER( } uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; - int i, current_try_catch_offset = -1; + uint32_t i, current_try_catch_offset = -1; if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) && throw_op->extended_value & ZEND_FREE_ON_RETURN) { @@ -5752,7 +5752,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CONST ZVAL_COPY(&tmp, value); if (zend_parse_arg_str_weak(&tmp, &str, 1)) { - ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); + ZVAL_LONG(EX_VAR(opline->result.var), (zend_long)ZSTR_LEN(str)); zval_ptr_dtor(&tmp); break; } @@ -6577,7 +6577,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_ } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -6704,7 +6704,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -7668,9 +7668,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PRO } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -7906,7 +7906,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_ } jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); - jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + jump_zv = zend_hash_index_find(jumptable, (zend_ulong)Z_LVAL_P(op)); if (jump_zv != NULL) { ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv)); ZEND_VM_CONTINUE(); @@ -7961,7 +7961,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_CONST_ match_try_again: if (Z_TYPE_P(op) == IS_LONG) { - jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + jump_zv = zend_hash_index_find(jumptable, (zend_ulong)Z_LVAL_P(op)); } else if (Z_TYPE_P(op) == IS_STRING) { jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), IS_CONST == IS_CONST); } else if (Z_TYPE_P(op) == IS_REFERENCE) { @@ -8009,7 +8009,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } SAVE_OPLINE(); @@ -8020,7 +8020,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CON ZEND_VM_SMART_BRANCH(result, 0); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } @@ -8802,7 +8802,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZEND_HASH_INDEX_FIND(ht, (zend_ulong)offset, value, fetch_dim_r_index_undef); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); @@ -9097,7 +9097,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_ } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -9224,7 +9224,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -9999,9 +9999,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PRO } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -11483,7 +11483,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_ } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -11610,7 +11610,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CONST & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -12384,9 +12384,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PRO } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CV != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -13135,7 +13135,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_SWITCH_LONG_SPEC_TMPVARCV_CONS } jumptable = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); - jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + jump_zv = zend_hash_index_find(jumptable, (zend_ulong)Z_LVAL_P(op)); if (jump_zv != NULL) { ZEND_VM_SET_RELATIVE_OPCODE(opline, Z_LVAL_P(jump_zv)); ZEND_VM_CONTINUE(); @@ -13190,7 +13190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_MATCH_SPEC_TMPVARCV_CONST_HAND match_try_again: if (Z_TYPE_P(op) == IS_LONG) { - jump_zv = zend_hash_index_find(jumptable, Z_LVAL_P(op)); + jump_zv = zend_hash_index_find(jumptable, (zend_ulong)Z_LVAL_P(op)); } else if (Z_TYPE_P(op) == IS_STRING) { jump_zv = zend_hash_find_ex(jumptable, Z_STR_P(op), (IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST); } else if (Z_TYPE_P(op) == IS_REFERENCE) { @@ -15148,7 +15148,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEN ZVAL_COPY(&tmp, value); if (zend_parse_arg_str_weak(&tmp, &str, 1)) { - ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); + ZVAL_LONG(EX_VAR(opline->result.var), (zend_long)ZSTR_LEN(str)); zval_ptr_dtor(&tmp); break; } @@ -15865,7 +15865,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_ } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -15992,7 +15992,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -16505,9 +16505,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -16617,7 +16617,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZEND_HASH_INDEX_FIND(ht, (zend_ulong)offset, value, fetch_dim_r_index_undef); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); @@ -16672,7 +16672,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZEND_HASH_INDEX_FIND(ht, (zend_ulong)offset, value, fetch_dim_r_index_undef); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); @@ -17310,7 +17310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -17437,7 +17437,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVA } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -17922,9 +17922,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -18669,7 +18669,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HAN } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -18796,7 +18796,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HA } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -19281,9 +19281,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TM } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CV != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -20438,7 +20438,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } SAVE_OPLINE(); @@ -20449,7 +20449,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLE zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_SMART_BRANCH(result, 0); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_SMART_BRANCH(result, 0); } @@ -25711,7 +25711,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } SAVE_OPLINE(); @@ -25722,7 +25722,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_SMART_BRANCH(result, 0); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_SMART_BRANCH(result, 0); } @@ -33096,7 +33096,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -33266,7 +33266,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -34586,9 +34586,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -35155,7 +35155,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -35320,7 +35320,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVA } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -36469,9 +36469,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -37178,8 +37178,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_THIS_SPEC_UNUSED USE_OPLINE ZVAL_BOOL(EX_VAR(opline->result.var), - (opline->extended_value & ZEND_ISEMPTY) ^ - (Z_TYPE(EX(This)) == IS_OBJECT)); + (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)(Z_TYPE(EX(This)) == IS_OBJECT)); ZEND_VM_NEXT_OPCODE(); } @@ -37661,7 +37660,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -37826,7 +37825,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HA } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_UNUSED & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -38973,9 +38972,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UN } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CV != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -40515,7 +40514,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_STRLEN_SPEC_CV_HANDLER(ZEND_OP ZVAL_COPY(&tmp, value); if (zend_parse_arg_str_weak(&tmp, &str, 1)) { - ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); + ZVAL_LONG(EX_VAR(opline->result.var), (zend_long)ZSTR_LEN(str)); zval_ptr_dtor(&tmp); break; } @@ -41931,7 +41930,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -42101,7 +42100,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HAN } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -44238,9 +44237,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -44551,7 +44550,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER if (opline->extended_value) { if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } SAVE_OPLINE(); @@ -44562,7 +44561,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER ZEND_VM_SMART_BRANCH(result, 0); } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + result = zend_hash_index_find(ht, (zend_ulong)Z_LVAL_P(op1)); ZEND_VM_SMART_BRANCH(result, 0); } @@ -44654,7 +44653,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZEND_HASH_INDEX_FIND(ht, (zend_ulong)offset, value, fetch_dim_r_index_undef); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); if (IS_CV & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); @@ -44709,7 +44708,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_DIM_R_INDEX_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZEND_HASH_INDEX_FIND(ht, (zend_ulong)offset, value, fetch_dim_r_index_undef); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); if (IS_CV & (IS_TMP_VAR|IS_VAR)) { SAVE_OPLINE(); @@ -45775,7 +45774,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -45940,7 +45939,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HA } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -47880,9 +47879,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); @@ -51165,7 +51164,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_r_copy; @@ -51330,7 +51329,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLE } retval = zend_hash_find_known_hash(zobj->properties, name); if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); if (0 || (IS_CV & (IS_TMP_VAR|IS_VAR)) != 0) { goto fetch_obj_is_copy; @@ -53364,9 +53363,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV } } - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + result = (opline->extended_value & ZEND_ISEMPTY) ^ (uint32_t)Z_OBJ_HT_P(container)->has_property( + Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), + ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); if (IS_CV != IS_CONST) { zend_tmp_string_release(tmp_name); From 61e3a6cafb4575ff3e7a8e94b7a6af6a85144d1a Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:54 +0100 Subject: [PATCH 19/28] Fix sign conversions in APIs --- Zend/zend_API.c | 24 ++++++++++++------------ Zend/zend_API.h | 26 +++++++++++++------------- Zend/zend_inheritance.c | 4 ++-- Zend/zend_object_handlers.c | 6 +++--- Zend/zend_object_handlers.h | 2 +- 5 files changed, 31 insertions(+), 31 deletions(-) diff --git a/Zend/zend_API.c b/Zend/zend_API.c index ae7a06f011761..606c02d4e9e61 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -1718,7 +1718,7 @@ ZEND_API void object_properties_load(zend_object *object, HashTable *properties) { zval *prop, tmp; zend_string *key; - zend_long h; + zend_ulong h; zend_property_info *property_info; ZEND_HASH_FOREACH_KEY_VAL(properties, h, key, prop) { @@ -4408,7 +4408,7 @@ static zend_always_inline bool is_persistent_class(zend_class_entry *ce) { && ce->info.internal.module->type == MODULE_PERSISTENT; } -ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type) /* {{{ */ +ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, uint32_t access_type, zend_string *doc_comment, zend_type type) /* {{{ */ { zend_property_info *property_info, *property_info_ptr; @@ -4654,13 +4654,13 @@ ZEND_API zend_result zend_try_assign_typed_ref_zval_ex(zend_reference *ref, zval } /* }}} */ -ZEND_API void zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment) /* {{{ */ +ZEND_API void zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, uint32_t access_type, zend_string *doc_comment) /* {{{ */ { zend_declare_typed_property(ce, name, property, access_type, doc_comment, (zend_type) ZEND_TYPE_INIT_NONE(0)); } /* }}} */ -ZEND_API void zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type) /* {{{ */ +ZEND_API void zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, uint32_t access_type) /* {{{ */ { zend_string *key = zend_string_init(name, name_length, is_persistent_class(ce)); zend_declare_property_ex(ce, key, property, access_type, NULL); @@ -4668,7 +4668,7 @@ ZEND_API void zend_declare_property(zend_class_entry *ce, const char *name, size } /* }}} */ -ZEND_API void zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, int access_type) /* {{{ */ +ZEND_API void zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, uint32_t access_type) /* {{{ */ { zval property; @@ -4677,7 +4677,7 @@ ZEND_API void zend_declare_property_null(zend_class_entry *ce, const char *name, } /* }}} */ -ZEND_API void zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type) /* {{{ */ +ZEND_API void zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, uint32_t access_type) /* {{{ */ { zval property; @@ -4686,7 +4686,7 @@ ZEND_API void zend_declare_property_bool(zend_class_entry *ce, const char *name, } /* }}} */ -ZEND_API void zend_declare_property_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type) /* {{{ */ +ZEND_API void zend_declare_property_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, uint32_t access_type) /* {{{ */ { zval property; @@ -4695,7 +4695,7 @@ ZEND_API void zend_declare_property_long(zend_class_entry *ce, const char *name, } /* }}} */ -ZEND_API void zend_declare_property_double(zend_class_entry *ce, const char *name, size_t name_length, double value, int access_type) /* {{{ */ +ZEND_API void zend_declare_property_double(zend_class_entry *ce, const char *name, size_t name_length, double value, uint32_t access_type) /* {{{ */ { zval property; @@ -4704,7 +4704,7 @@ ZEND_API void zend_declare_property_double(zend_class_entry *ce, const char *nam } /* }}} */ -ZEND_API void zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, int access_type) /* {{{ */ +ZEND_API void zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, uint32_t access_type) /* {{{ */ { zval property; @@ -4713,7 +4713,7 @@ ZEND_API void zend_declare_property_string(zend_class_entry *ce, const char *nam } /* }}} */ -ZEND_API void zend_declare_property_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_len, int access_type) /* {{{ */ +ZEND_API void zend_declare_property_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_len, uint32_t access_type) /* {{{ */ { zval property; @@ -4722,7 +4722,7 @@ ZEND_API void zend_declare_property_stringl(zend_class_entry *ce, const char *na } /* }}} */ -ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry *ce, zend_string *name, zval *value, int flags, zend_string *doc_comment, zend_type type) /* {{{ */ +ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry *ce, zend_string *name, zval *value, uint32_t flags, zend_string *doc_comment, zend_type type) /* {{{ */ { zend_class_constant *c; @@ -4772,7 +4772,7 @@ ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry return c; } -ZEND_API zend_class_constant *zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int flags, zend_string *doc_comment) +ZEND_API zend_class_constant *zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, uint32_t flags, zend_string *doc_comment) { return zend_declare_typed_class_constant(ce, name, value, flags, doc_comment, (zend_type) ZEND_TYPE_INIT_NONE(0)); } diff --git a/Zend/zend_API.h b/Zend/zend_API.h index 90556fcde4245..7d3cdd87a2ea5 100644 --- a/Zend/zend_API.h +++ b/Zend/zend_API.h @@ -422,19 +422,19 @@ ZEND_API bool zend_make_callable(zval *callable, zend_string **callable_name); ZEND_API const char *zend_get_module_version(const char *module_name); ZEND_API zend_result zend_get_module_started(const char *module_name); -ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment, zend_type type); - -ZEND_API void zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment); -ZEND_API void zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, int access_type); -ZEND_API void zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, int access_type); -ZEND_API void zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type); -ZEND_API void zend_declare_property_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, int access_type); -ZEND_API void zend_declare_property_double(zend_class_entry *ce, const char *name, size_t name_length, double value, int access_type); -ZEND_API void zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, int access_type); -ZEND_API void zend_declare_property_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_len, int access_type); - -ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment, zend_type type); -ZEND_API zend_class_constant *zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, int access_type, zend_string *doc_comment); +ZEND_API zend_property_info *zend_declare_typed_property(zend_class_entry *ce, zend_string *name, zval *property, uint32_t access_type, zend_string *doc_comment, zend_type type); + +ZEND_API void zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, uint32_t access_type, zend_string *doc_comment); +ZEND_API void zend_declare_property(zend_class_entry *ce, const char *name, size_t name_length, zval *property, uint32_t access_type); +ZEND_API void zend_declare_property_null(zend_class_entry *ce, const char *name, size_t name_length, uint32_t access_type); +ZEND_API void zend_declare_property_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, uint32_t access_type); +ZEND_API void zend_declare_property_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value, uint32_t access_type); +ZEND_API void zend_declare_property_double(zend_class_entry *ce, const char *name, size_t name_length, double value, uint32_t access_type); +ZEND_API void zend_declare_property_string(zend_class_entry *ce, const char *name, size_t name_length, const char *value, uint32_t access_type); +ZEND_API void zend_declare_property_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_len, uint32_t access_type); + +ZEND_API zend_class_constant *zend_declare_typed_class_constant(zend_class_entry *ce, zend_string *name, zval *value, uint32_t access_type, zend_string *doc_comment, zend_type type); +ZEND_API zend_class_constant *zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *name, zval *value, uint32_t access_type, zend_string *doc_comment); ZEND_API void zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value); ZEND_API void zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length); ZEND_API void zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, zend_long value); diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index b0a43fc8f5216..c2d8ae8a6d3a7 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -1304,8 +1304,8 @@ static void do_inherit_property(zend_property_info *parent_info, zend_string *ke if (UNEXPECTED((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK))) { zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ZSTR_VAL(ce->name), ZSTR_VAL(key), zend_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker"); } else if ((child_info->flags & ZEND_ACC_STATIC) == 0) { - int parent_num = OBJ_PROP_TO_NUM(parent_info->offset); - int child_num = OBJ_PROP_TO_NUM(child_info->offset); + size_t parent_num = OBJ_PROP_TO_NUM(parent_info->offset); + size_t child_num = OBJ_PROP_TO_NUM(child_info->offset); /* Don't keep default properties in GC (they may be freed by opcache) */ zval_ptr_dtor_nogc(&(ce->default_properties_table[parent_num])); diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index 158b937238573..3ab020aad9f18 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -132,7 +132,7 @@ ZEND_API HashTable *zend_std_get_properties(zend_object *zobj) /* {{{ */ } /* }}} */ -ZEND_API HashTable *zend_std_get_gc(zend_object *zobj, zval **table, int *n) /* {{{ */ +ZEND_API HashTable *zend_std_get_gc(zend_object *zobj, zval **table, uint32_t *n) /* {{{ */ { if (zobj->handlers->get_properties != zend_std_get_properties) { *table = NULL; @@ -580,7 +580,7 @@ ZEND_API uint32_t *zend_get_property_guard(zend_object *zobj, zend_string *membe ZEND_ASSERT(guards != NULL); zv = zend_hash_find(guards, member); if (zv != NULL) { - return (uint32_t*)(((uintptr_t)Z_PTR_P(zv)) & ~1); + return (uint32_t*)(((uintptr_t)Z_PTR_P(zv)) & ~1u); } } else { ZEND_ASSERT(Z_TYPE_P(zv) == IS_UNDEF); @@ -674,7 +674,7 @@ ZEND_API zval *zend_std_read_property(zend_object *zobj, zend_string *name, int retval = zend_hash_find(zobj->properties, name); if (EXPECTED(retval)) { if (cache_slot) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + uintptr_t idx = (uintptr_t)((char*)retval - (char*)zobj->properties->arData); CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); } goto exit; diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h index 35498f34617c0..12b3e45bfead2 100644 --- a/Zend/zend_object_handlers.h +++ b/Zend/zend_object_handlers.h @@ -211,7 +211,7 @@ ZEND_API ZEND_COLD bool zend_std_unset_static_property(zend_class_entry *ce, zen ZEND_API zend_function *zend_std_get_constructor(zend_object *object); ZEND_API struct _zend_property_info *zend_get_property_info(const zend_class_entry *ce, zend_string *member, int silent); ZEND_API HashTable *zend_std_get_properties(zend_object *object); -ZEND_API HashTable *zend_std_get_gc(zend_object *object, zval **table, int *n); +ZEND_API HashTable *zend_std_get_gc(zend_object *object, zval **table, uint32_t *n); ZEND_API HashTable *zend_std_get_debug_info(zend_object *object, int *is_temp); ZEND_API zend_result zend_std_cast_object_tostring(zend_object *object, zval *writeobj, int type); ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *object, zend_string *member, int type, void **cache_slot); From f95b1e94cc5377c1bb9c9cd44941f8b6ffb15521 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:55 +0100 Subject: [PATCH 20/28] Fix some sign conversions in the compiler --- Zend/zend_compile.c | 4 ++-- Zend/zend_globals.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index a97c46ca914bd..5a412d27cdcc2 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -517,9 +517,9 @@ static zend_always_inline uint32_t get_temporary_variable(void) /* {{{ */ } /* }}} */ -static int lookup_cv(zend_string *name) /* {{{ */{ +static uint32_t lookup_cv(zend_string *name) /* {{{ */{ zend_op_array *op_array = CG(active_op_array); - int i = 0; + uint32_t i = 0; zend_ulong hash_value = zend_string_hash_val(name); while (i < op_array->last_var) { diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index e126d61b34abf..0b26419b71ec3 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -87,7 +87,7 @@ struct _zend_compiler_globals { zend_string *compiled_filename; - int zend_lineno; + uint32_t zend_lineno; zend_op_array *active_op_array; From 320adf7f91fefc4471f19cdf4537e2c97ad8e539 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:55 +0100 Subject: [PATCH 21/28] Builtin functions --- Zend/zend_builtin_functions.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index 0e97764d55a8a..93b443e07ff6d 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -84,7 +84,7 @@ ZEND_FUNCTION(gc_mem_caches) { ZEND_PARSE_PARAMETERS_NONE(); - RETURN_LONG(zend_mm_gc(zend_mm_get_heap())); + RETURN_LONG((zend_long)zend_mm_gc(zend_mm_get_heap())); } /* }}} */ @@ -306,7 +306,7 @@ ZEND_FUNCTION(strlen) Z_PARAM_STR(s) ZEND_PARSE_PARAMETERS_END(); - RETVAL_LONG(ZSTR_LEN(s)); + RETVAL_LONG((zend_long) ZSTR_LEN(s)); } /* }}} */ @@ -376,7 +376,7 @@ ZEND_FUNCTION(strncasecmp) RETURN_THROWS(); } - RETURN_LONG(zend_binary_strncasecmp(ZSTR_VAL(s1), ZSTR_LEN(s1), ZSTR_VAL(s2), ZSTR_LEN(s2), len)); + RETURN_LONG(zend_binary_strncasecmp(ZSTR_VAL(s1), ZSTR_LEN(s1), ZSTR_VAL(s2), ZSTR_LEN(s2), (size_t)len)); } /* }}} */ @@ -428,7 +428,7 @@ ZEND_FUNCTION(error_reporting) } /* }}} */ -static bool validate_constant_array_argument(HashTable *ht, int argument_number) /* {{{ */ +static bool validate_constant_array_argument(HashTable *ht, uint32_t argument_number) /* {{{ */ { bool ret = 1; zval *val; @@ -1002,7 +1002,7 @@ flf_clean:; Z_FLF_PARAM_FREE_STR(2, property_tmp) } -static inline void _class_exists_impl(zval *return_value, zend_string *name, bool autoload, int flags, int skip_flags) /* {{{ */ +static inline void _class_exists_impl(zval *return_value, zend_string *name, bool autoload, unsigned int flags, unsigned int skip_flags) /* {{{ */ { zend_string *lcname; zend_class_entry *ce; @@ -1037,7 +1037,7 @@ static inline void _class_exists_impl(zval *return_value, zend_string *name, boo } /* {{{ */ -static inline void class_exists_impl(INTERNAL_FUNCTION_PARAMETERS, int flags, int skip_flags) /* {{{ */ +static inline void class_exists_impl(INTERNAL_FUNCTION_PARAMETERS, unsigned int flags, unsigned int skip_flags) /* {{{ */ { zend_string *name; bool autoload = true; @@ -1779,7 +1779,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int zend_execute_data *call; zend_object *object; bool fake_frame = 0; - int lineno, frameno = 0; + uint32_t lineno, frameno = 0; zend_function *func; zend_string *filename; zend_string *include_filename = NULL; From d884b7cb01295b6238bc4a6d53a4de1b603eec43 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:55 +0100 Subject: [PATCH 22/28] Zend string fixes --- Zend/zend_string.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Zend/zend_string.c b/Zend/zend_string.c index 7a00171d2c84d..2e6f38df1019c 100644 --- a/Zend/zend_string.c +++ b/Zend/zend_string.c @@ -59,7 +59,7 @@ ZEND_API zend_ulong ZEND_FASTCALL zend_string_hash_func(zend_string *str) ZEND_API zend_ulong ZEND_FASTCALL zend_hash_func(const char *str, size_t len) { - return zend_inline_hash_func(str, len); + return zend_inline_hash_func((const unsigned char*)str, len); } static void _str_dtor(zval *zv) @@ -272,7 +272,7 @@ static zend_string* ZEND_FASTCALL zend_new_interned_string_request(zend_string * static zend_string* ZEND_FASTCALL zend_string_init_interned_permanent(const char *str, size_t size, bool permanent) { zend_string *ret; - zend_ulong h = zend_inline_hash_func(str, size); + zend_ulong h = zend_inline_hash_func((const unsigned char*)str, size); ret = zend_interned_string_ht_lookup_ex(h, str, size, &interned_strings_permanent); if (ret) { @@ -287,7 +287,7 @@ static zend_string* ZEND_FASTCALL zend_string_init_interned_permanent(const char static zend_string* ZEND_FASTCALL zend_string_init_existing_interned_permanent(const char *str, size_t size, bool permanent) { - zend_ulong h = zend_inline_hash_func(str, size); + zend_ulong h = zend_inline_hash_func((const unsigned char*)str, size); zend_string *ret = zend_interned_string_ht_lookup_ex(h, str, size, &interned_strings_permanent); if (ret) { return ret; @@ -302,7 +302,7 @@ static zend_string* ZEND_FASTCALL zend_string_init_existing_interned_permanent(c static zend_string* ZEND_FASTCALL zend_string_init_interned_request(const char *str, size_t size, bool permanent) { zend_string *ret; - zend_ulong h = zend_inline_hash_func(str, size); + zend_ulong h = zend_inline_hash_func((const unsigned char*)str, size); /* Check for permanent strings, the table is readonly at this point. */ ret = zend_interned_string_ht_lookup_ex(h, str, size, &interned_strings_permanent); @@ -331,7 +331,7 @@ static zend_string* ZEND_FASTCALL zend_string_init_interned_request(const char * static zend_string* ZEND_FASTCALL zend_string_init_existing_interned_request(const char *str, size_t size, bool permanent) { - zend_ulong h = zend_inline_hash_func(str, size); + zend_ulong h = zend_inline_hash_func((const unsigned char*)str, size); zend_string *ret = zend_interned_string_ht_lookup_ex(h, str, size, &interned_strings_permanent); if (ret) { return ret; From 5083aa317bf909180a552aa794e0840e8d0df539 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:56 +0100 Subject: [PATCH 23/28] Zend Hash fixes --- Zend/zend_hash.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c index 3cb31a6296e9f..2d68b1a5f1c30 100644 --- a/Zend/zend_hash.c +++ b/Zend/zend_hash.c @@ -1619,7 +1619,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_hash_str_del_ind(HashTable *ht, const ch IS_CONSISTENT(ht); HT_ASSERT_RC1(ht); - h = zend_inline_hash_func(str, len); + h = zend_inline_hash_func((const unsigned char*)str, len); nIndex = h | ht->nTableMask; idx = HT_HASH(ht, nIndex); @@ -1664,7 +1664,7 @@ ZEND_API zend_result ZEND_FASTCALL zend_hash_str_del(HashTable *ht, const char * IS_CONSISTENT(ht); HT_ASSERT_RC1(ht); - h = zend_inline_hash_func(str, len); + h = zend_inline_hash_func((const unsigned char*)str, len); nIndex = h | ht->nTableMask; idx = HT_HASH(ht, nIndex); @@ -2685,7 +2685,7 @@ ZEND_API zval* ZEND_FASTCALL zend_hash_str_find(const HashTable *ht, const char IS_CONSISTENT(ht); - h = zend_inline_hash_func(str, len); + h = zend_inline_hash_func((const unsigned char*)str, len); p = zend_hash_str_find_bucket(ht, str, len, h); return p ? &p->val : NULL; } From fae1ed480821c79d27a184f9624ab5ccae827223 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:56 +0100 Subject: [PATCH 24/28] ext/standard/html.c: signess fixes --- ext/standard/html.c | 34 ++++++++++++++++++---------------- 1 file changed, 18 insertions(+), 16 deletions(-) diff --git a/ext/standard/html.c b/ext/standard/html.c index 92cee224e068b..64d2a3991e01b 100644 --- a/ext/standard/html.c +++ b/ext/standard/html.c @@ -667,11 +667,11 @@ static inline int numeric_entity_is_allowed(unsigned uni_cp, int document_type) * On input, *buf should point to the first character after # and on output, it's the last * byte read, no matter if there was success or insuccess. */ -static inline int process_numeric_entity(const char **buf, unsigned *code_point) +static inline zend_result process_numeric_entity(const unsigned char **buf, unsigned *code_point) { zend_long code_l; int hexadecimal = (**buf == 'x' || **buf == 'X'); /* TODO: XML apparently disallows "X" */ - char *endptr; + unsigned char *endptr; if (hexadecimal) (*buf)++; @@ -683,7 +683,7 @@ static inline int process_numeric_entity(const char **buf, unsigned *code_point) return FAILURE; } - code_l = ZEND_STRTOL(*buf, &endptr, hexadecimal ? 16 : 10); + code_l = ZEND_STRTOL((const char*)*buf, (char**)&endptr, hexadecimal ? 16 : 10); /* we're guaranteed there were valid digits, so *endptr > buf */ *buf = endptr; @@ -703,7 +703,7 @@ static inline int process_numeric_entity(const char **buf, unsigned *code_point) /* }}} */ /* {{{ process_named_entity */ -static inline int process_named_entity_html(const char **buf, const char **start, size_t *length) +static inline zend_result process_named_entity_html(const unsigned char **buf, const unsigned char **start, size_t *length) { *start = *buf; @@ -718,21 +718,23 @@ static inline int process_named_entity_html(const char **buf, const char **start (*buf)++; } - if (**buf != ';') + if (**buf != ';') { return FAILURE; + } /* cast to size_t OK as the quantity is always non-negative */ *length = *buf - *start; - if (*length == 0) + if (*length == 0) { return FAILURE; + } return SUCCESS; } /* }}} */ /* {{{ resolve_named_entity_html */ -static int resolve_named_entity_html(const char *start, size_t length, const entity_ht *ht, unsigned *uni_cp1, unsigned *uni_cp2) +static zend_result resolve_named_entity_html(const unsigned char *start, size_t length, const entity_ht *ht, unsigned *uni_cp1, unsigned *uni_cp2) { const entity_cp_map *s; zend_ulong hash = zend_inline_hash_func(start, length); @@ -827,7 +829,7 @@ static void traverse_for_entities( int doctype = flags & ENT_HTML_DOC_TYPE_MASK; lim = old + oldlen; /* terminator address */ - assert(*lim == '\0'); + ZEND_ASSERT(*lim == '\0'); for (p = old, q = ZSTR_VAL(ret); p < lim;) { unsigned code, code2 = 0; @@ -849,7 +851,7 @@ static void traverse_for_entities( /* numerical entity */ if (p[1] == '#') { next = &p[2]; - if (process_numeric_entity(&next, &code) == FAILURE) + if (process_numeric_entity((const unsigned char**)&next, &code) == FAILURE) goto invalid_code; /* If we're in htmlspecialchars_decode, we're only decoding entities @@ -866,13 +868,13 @@ static void traverse_for_entities( (doctype == ENT_HTML_DOC_HTML5 && code == 0x0D)) goto invalid_code; } else { - const char *start; + const unsigned char *start; size_t ent_len; next = &p[1]; - start = next; + start = (const unsigned char*)next; - if (process_named_entity_html(&next, &start, &ent_len) == FAILURE) + if (process_named_entity_html((const unsigned char**)&next, &start, &ent_len) == FAILURE) goto invalid_code; if (resolve_named_entity_html(start, ent_len, inv_map, &code, &code2) == FAILURE) { @@ -1259,18 +1261,18 @@ PHPAPI zend_string *php_escape_html_entities_ex(const unsigned char *old, size_t if (old[cursor] == '#') { /* numeric entity */ unsigned code_point; int valid; - char *pos = (char*)&old[cursor+1]; - valid = process_numeric_entity((const char **)&pos, &code_point); + const unsigned char *pos = &old[cursor+1]; + valid = process_numeric_entity(&pos, &code_point); if (valid == FAILURE) goto encode_amp; if (flags & ENT_HTML_SUBSTITUTE_DISALLOWED_CHARS) { if (!numeric_entity_is_allowed(code_point, doctype)) goto encode_amp; } - ent_len = pos - (char*)&old[cursor]; + ent_len = pos - &old[cursor]; } else { /* named entity */ /* check for vality of named entity */ - const char *start = (const char *) &old[cursor], + const unsigned char *start = &old[cursor], *next = start; unsigned dummy1, dummy2; From 8b759c7bb599e75ef4d591e01539c48b34c39901 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:56 +0100 Subject: [PATCH 25/28] ext/standard/browscap.c: signess fixes --- ext/standard/browscap.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ext/standard/browscap.c b/ext/standard/browscap.c index c9591e270a3f4..aec06105cbd71 100644 --- a/ext/standard/browscap.c +++ b/ext/standard/browscap.c @@ -279,20 +279,20 @@ static HashTable *browscap_entry_to_array(browser_data *bdata, browscap_entry *e ZVAL_STR(&tmp, browscap_convert_pattern(entry->pattern, 0)); zend_string *key = ZSTR_INIT_LITERAL("browser_name_regex", 0); - ZSTR_H(key) = zend_inline_hash_func("browser_name_regex", sizeof("browser_name_regex")-1); + ZSTR_H(key) = zend_inline_hash_func((unsigned char*)"browser_name_regex", sizeof("browser_name_regex")-1); zend_hash_add_new(ht, key, &tmp); zend_string_release_ex(key, false); ZVAL_STR_COPY(&tmp, entry->pattern); key = ZSTR_INIT_LITERAL("browser_name_pattern", 0); - ZSTR_H(key) = zend_inline_hash_func("browser_name_pattern", sizeof("browser_name_pattern")-1); + ZSTR_H(key) = zend_inline_hash_func((unsigned char*)"browser_name_pattern", sizeof("browser_name_pattern")-1); zend_hash_add_new(ht, key, &tmp); zend_string_release_ex(key, false); if (entry->parent) { ZVAL_STR_COPY(&tmp, entry->parent); key = ZSTR_INIT_LITERAL("parent", 0); - ZSTR_H(key) = zend_inline_hash_func("parent", sizeof("parent")-1); + ZSTR_H(key) = zend_inline_hash_func((unsigned char*)"parent", sizeof("parent")-1); zend_hash_add_new(ht, key, &tmp); zend_string_release_ex(key, false); } From cafa8599e272f33d9cc5abfc5210a08780e0dc3e Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:57 +0100 Subject: [PATCH 26/28] object handler fixes --- Zend/zend_object_handlers.c | 2 +- Zend/zend_object_handlers.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index 3ab020aad9f18..241efee4feed4 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -132,7 +132,7 @@ ZEND_API HashTable *zend_std_get_properties(zend_object *zobj) /* {{{ */ } /* }}} */ -ZEND_API HashTable *zend_std_get_gc(zend_object *zobj, zval **table, uint32_t *n) /* {{{ */ +ZEND_API HashTable *zend_std_get_gc(zend_object *zobj, zval **table, int *n) /* {{{ */ { if (zobj->handlers->get_properties != zend_std_get_properties) { *table = NULL; diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h index 12b3e45bfead2..35498f34617c0 100644 --- a/Zend/zend_object_handlers.h +++ b/Zend/zend_object_handlers.h @@ -211,7 +211,7 @@ ZEND_API ZEND_COLD bool zend_std_unset_static_property(zend_class_entry *ce, zen ZEND_API zend_function *zend_std_get_constructor(zend_object *object); ZEND_API struct _zend_property_info *zend_get_property_info(const zend_class_entry *ce, zend_string *member, int silent); ZEND_API HashTable *zend_std_get_properties(zend_object *object); -ZEND_API HashTable *zend_std_get_gc(zend_object *object, zval **table, uint32_t *n); +ZEND_API HashTable *zend_std_get_gc(zend_object *object, zval **table, int *n); ZEND_API HashTable *zend_std_get_debug_info(zend_object *object, int *is_temp); ZEND_API zend_result zend_std_cast_object_tostring(zend_object *object, zval *writeobj, int type); ZEND_API zval *zend_std_get_property_ptr_ptr(zend_object *object, zend_string *member, int type, void **cache_slot); From e74653e2fce987da5d63cbf79a8a4111f92efbd7 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:57 +0100 Subject: [PATCH 27/28] Diasble compiler warning for some extensions/sapis --- ext/spl/config.m4 | 4 +++- ext/standard/config.m4 | 2 +- sapi/cgi/config9.m4 | 2 +- sapi/cli/config.m4 | 3 ++- sapi/phpdbg/config.m4 | 2 +- 5 files changed, 8 insertions(+), 5 deletions(-) diff --git a/ext/spl/config.m4 b/ext/spl/config.m4 index 589e8681d70ec..28be9d907e12a 100644 --- a/ext/spl/config.m4 +++ b/ext/spl/config.m4 @@ -1,4 +1,6 @@ -PHP_NEW_EXTENSION(spl, php_spl.c spl_functions.c spl_iterators.c spl_array.c spl_directory.c spl_exceptions.c spl_observer.c spl_dllist.c spl_heap.c spl_fixedarray.c, no,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1) +PHP_NEW_EXTENSION(spl, + php_spl.c spl_functions.c spl_iterators.c spl_array.c spl_directory.c spl_exceptions.c spl_observer.c spl_dllist.c spl_heap.c spl_fixedarray.c, + no,, "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1") PHP_INSTALL_HEADERS([ext/spl], [php_spl.h spl_array.h spl_directory.h spl_engine.h spl_exceptions.h spl_functions.h spl_iterators.h spl_observer.h spl_dllist.h spl_heap.h spl_fixedarray.h]) PHP_ADD_EXTENSION_DEP(spl, pcre, true) PHP_ADD_EXTENSION_DEP(spl, standard, true) diff --git a/ext/standard/config.m4 b/ext/standard/config.m4 index 3d5592b4d3e4f..f5e34130c79b9 100644 --- a/ext/standard/config.m4 +++ b/ext/standard/config.m4 @@ -431,7 +431,7 @@ PHP_NEW_EXTENSION(standard, array.c base64.c basic_functions.c browscap.c crc32. var_unserializer.c ftok.c sha1.c user_filters.c uuencode.c \ filters.c proc_open.c streamsfuncs.c http.c password.c \ net.c hrtime.c crc32_x86.c libavifinfo/avifinfo.c,,, - -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1) + "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1") PHP_ADD_BUILD_DIR($ext_builddir/libavifinfo) diff --git a/sapi/cgi/config9.m4 b/sapi/cgi/config9.m4 index 43ff00ecb7954..d6e4c061229b8 100644 --- a/sapi/cgi/config9.m4 +++ b/sapi/cgi/config9.m4 @@ -37,7 +37,7 @@ if test "$PHP_CGI" != "no"; then esac dnl Select SAPI. - PHP_SELECT_SAPI(cgi, program, cgi_main.c, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1, '$(SAPI_CGI_PATH)') + PHP_SELECT_SAPI(cgi, program, cgi_main.c, "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1", '$(SAPI_CGI_PATH)') case $host_alias in *aix*) diff --git a/sapi/cli/config.m4 b/sapi/cli/config.m4 index 3e58a9aeb74fb..0184ab82a8287 100644 --- a/sapi/cli/config.m4 +++ b/sapi/cli/config.m4 @@ -28,7 +28,8 @@ if test "$PHP_CLI" != "no"; then SAPI_CLI_PATH=sapi/cli/php dnl Select SAPI. - PHP_SELECT_SAPI(cli, program, php_cli.c php_http_parser.c php_cli_server.c ps_title.c php_cli_process_title.c, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1, '$(SAPI_CLI_PATH)') + PHP_SELECT_SAPI(cli, program, php_cli.c php_http_parser.c php_cli_server.c ps_title.c php_cli_process_title.c, + "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1", '$(SAPI_CLI_PATH)') case $host_alias in *aix*) diff --git a/sapi/phpdbg/config.m4 b/sapi/phpdbg/config.m4 index 4a7b1810e9075..34c2c0e51e41e 100644 --- a/sapi/phpdbg/config.m4 +++ b/sapi/phpdbg/config.m4 @@ -29,7 +29,7 @@ if test "$PHP_PHPDBG" != "no"; then AC_DEFINE(PHPDBG_DEBUG, 0, [ ]) fi - PHP_PHPDBG_CFLAGS="-DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" + PHP_PHPDBG_CFLAGS="-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" PHP_PHPDBG_FILES="phpdbg.c phpdbg_parser.c phpdbg_lexer.c phpdbg_prompt.c phpdbg_help.c phpdbg_break.c phpdbg_print.c phpdbg_bp.c phpdbg_list.c phpdbg_utils.c phpdbg_info.c phpdbg_cmd.c phpdbg_set.c phpdbg_frame.c phpdbg_watch.c phpdbg_btree.c phpdbg_sigsafe.c phpdbg_io.c phpdbg_out.c" AC_MSG_CHECKING([for phpdbg and readline integration]) From 28f2986d281b91298f39f0f83b189718a4d94c8b Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Mon, 3 Jun 2024 05:27:57 +0100 Subject: [PATCH 28/28] Revert "Diasble compiler warning for some extensions/sapis" This reverts commit 876bbcb34bcc99acbae543aff97ef9de4c768c0f. --- ext/spl/config.m4 | 4 +--- ext/standard/config.m4 | 2 +- sapi/cgi/config9.m4 | 2 +- sapi/cli/config.m4 | 3 +-- sapi/phpdbg/config.m4 | 2 +- 5 files changed, 5 insertions(+), 8 deletions(-) diff --git a/ext/spl/config.m4 b/ext/spl/config.m4 index 28be9d907e12a..589e8681d70ec 100644 --- a/ext/spl/config.m4 +++ b/ext/spl/config.m4 @@ -1,6 +1,4 @@ -PHP_NEW_EXTENSION(spl, - php_spl.c spl_functions.c spl_iterators.c spl_array.c spl_directory.c spl_exceptions.c spl_observer.c spl_dllist.c spl_heap.c spl_fixedarray.c, - no,, "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1") +PHP_NEW_EXTENSION(spl, php_spl.c spl_functions.c spl_iterators.c spl_array.c spl_directory.c spl_exceptions.c spl_observer.c spl_dllist.c spl_heap.c spl_fixedarray.c, no,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1) PHP_INSTALL_HEADERS([ext/spl], [php_spl.h spl_array.h spl_directory.h spl_engine.h spl_exceptions.h spl_functions.h spl_iterators.h spl_observer.h spl_dllist.h spl_heap.h spl_fixedarray.h]) PHP_ADD_EXTENSION_DEP(spl, pcre, true) PHP_ADD_EXTENSION_DEP(spl, standard, true) diff --git a/ext/standard/config.m4 b/ext/standard/config.m4 index f5e34130c79b9..3d5592b4d3e4f 100644 --- a/ext/standard/config.m4 +++ b/ext/standard/config.m4 @@ -431,7 +431,7 @@ PHP_NEW_EXTENSION(standard, array.c base64.c basic_functions.c browscap.c crc32. var_unserializer.c ftok.c sha1.c user_filters.c uuencode.c \ filters.c proc_open.c streamsfuncs.c http.c password.c \ net.c hrtime.c crc32_x86.c libavifinfo/avifinfo.c,,, - "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1") + -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1) PHP_ADD_BUILD_DIR($ext_builddir/libavifinfo) diff --git a/sapi/cgi/config9.m4 b/sapi/cgi/config9.m4 index d6e4c061229b8..43ff00ecb7954 100644 --- a/sapi/cgi/config9.m4 +++ b/sapi/cgi/config9.m4 @@ -37,7 +37,7 @@ if test "$PHP_CGI" != "no"; then esac dnl Select SAPI. - PHP_SELECT_SAPI(cgi, program, cgi_main.c, "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1", '$(SAPI_CGI_PATH)') + PHP_SELECT_SAPI(cgi, program, cgi_main.c, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1, '$(SAPI_CGI_PATH)') case $host_alias in *aix*) diff --git a/sapi/cli/config.m4 b/sapi/cli/config.m4 index 0184ab82a8287..3e58a9aeb74fb 100644 --- a/sapi/cli/config.m4 +++ b/sapi/cli/config.m4 @@ -28,8 +28,7 @@ if test "$PHP_CLI" != "no"; then SAPI_CLI_PATH=sapi/cli/php dnl Select SAPI. - PHP_SELECT_SAPI(cli, program, php_cli.c php_http_parser.c php_cli_server.c ps_title.c php_cli_process_title.c, - "-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1", '$(SAPI_CLI_PATH)') + PHP_SELECT_SAPI(cli, program, php_cli.c php_http_parser.c php_cli_server.c ps_title.c php_cli_process_title.c, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1, '$(SAPI_CLI_PATH)') case $host_alias in *aix*) diff --git a/sapi/phpdbg/config.m4 b/sapi/phpdbg/config.m4 index 34c2c0e51e41e..4a7b1810e9075 100644 --- a/sapi/phpdbg/config.m4 +++ b/sapi/phpdbg/config.m4 @@ -29,7 +29,7 @@ if test "$PHP_PHPDBG" != "no"; then AC_DEFINE(PHPDBG_DEBUG, 0, [ ]) fi - PHP_PHPDBG_CFLAGS="-Wno-sign-conversion -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" + PHP_PHPDBG_CFLAGS="-DZEND_ENABLE_STATIC_TSRMLS_CACHE=1" PHP_PHPDBG_FILES="phpdbg.c phpdbg_parser.c phpdbg_lexer.c phpdbg_prompt.c phpdbg_help.c phpdbg_break.c phpdbg_print.c phpdbg_bp.c phpdbg_list.c phpdbg_utils.c phpdbg_info.c phpdbg_cmd.c phpdbg_set.c phpdbg_frame.c phpdbg_watch.c phpdbg_btree.c phpdbg_sigsafe.c phpdbg_io.c phpdbg_out.c" AC_MSG_CHECKING([for phpdbg and readline integration])