Made run_time_cache to keep "offset" to dynamic properties Buckets (instead of index).

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index b80e7f0af66618402fc1f92cc1269347895cc65d..e569e108b33fc0a0d5d2ce626710c3eaa97190df 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -1883,7 +1883,7 @@ static zend_always_inline void zend_fetch_property_address(zval *result, zval *c
        }
        if (prop_op_type == IS_CONST &&
            EXPECTED(Z_OBJCE_P(container) == CACHED_PTR_EX(cache_slot))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
                zend_object *zobj = Z_OBJ_P(container);
                zval *retval;
 

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 0c9c2d0cddb5515aa64ab447993096f8d9c672d3..d755ab057b05a3df1a3b959f7a770bfb0a3e7ae6 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -286,7 +286,7 @@ static zend_always_inline zend_bool is_derived_class(zend_class_entry *child_cla
 }
 /* }}} */
 
-static zend_always_inline uint32_t zend_get_property_offset(zend_class_entry *ce, zend_string *member, int silent, void **cache_slot) /* {{{ */
+static zend_always_inline intptr_t zend_get_property_offset(zend_class_entry *ce, zend_string *member, int silent, void **cache_slot) /* {{{ */
 {
        zval *zv;
        zend_property_info *property_info = NULL;
@@ -294,7 +294,7 @@ static zend_always_inline uint32_t zend_get_property_offset(zend_class_entry *ce
        zend_class_entry *scope;
 
        if (cache_slot && EXPECTED(ce == CACHED_PTR_EX(cache_slot))) {
-               return (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+               return (intptr_t)CACHED_PTR_EX(cache_slot + 1);
        }
 
        if (UNEXPECTED(ZSTR_VAL(member)[0] == '\0' && ZSTR_LEN(member) != 0)) {
@@ -352,7 +352,7 @@ static zend_always_inline uint32_t zend_get_property_offset(zend_class_entry *ce
        } else if (UNEXPECTED(property_info == NULL)) {
 exit_dynamic:
                if (cache_slot) {
-                       CACHE_POLYMORPHIC_PTR_EX(cache_slot, ce, (void*)(intptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                       CACHE_POLYMORPHIC_PTR_EX(cache_slot, ce, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                }
                return ZEND_DYNAMIC_PROPERTY_OFFSET;
        } else if (UNEXPECTED(property_info == ZEND_WRONG_PROPERTY_INFO)) {
@@ -544,7 +544,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_
        zend_object *zobj;
        zval tmp_member;
        zval *retval;
-       uint32_t property_offset;
+       intptr_t property_offset;
 
        zobj = Z_OBJ_P(object);
 
@@ -570,10 +570,10 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_
        } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
                if (EXPECTED(zobj->properties != NULL)) {
                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(property_offset)) {
-                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(property_offset);
+                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(property_offset);
 
-                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                       Bucket *p = zobj->properties->arData + idx;
+                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                        (EXPECTED(p->key == Z_STR_P(member)) ||
@@ -585,14 +585,13 @@ zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_
                                                goto exit;
                                        }
                                }
-                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                        }
                        retval = zend_hash_find(zobj->properties, Z_STR_P(member));
                        if (EXPECTED(retval)) {
                                if (cache_slot) {
-                                       uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                       /* Store "hash slot index" + 2 (NULL is a mark of uninitialized cache slot) */
-                                       CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                       intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                       CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                }
                                goto exit;
                        }
@@ -673,7 +672,7 @@ ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, v
        zend_object *zobj;
        zval tmp_member;
        zval *variable_ptr;
-       uint32_t property_offset;
+       intptr_t property_offset;
 
        zobj = Z_OBJ_P(object);
 
@@ -851,7 +850,7 @@ static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type,
        zend_object *zobj;
        zend_string *name;
        zval *retval = NULL;
-       uint32_t property_offset;
+       intptr_t property_offset;
 
        zobj = Z_OBJ_P(object);
        if (EXPECTED(Z_TYPE_P(member) == IS_STRING)) {
@@ -922,7 +921,7 @@ static void zend_std_unset_property(zval *object, zval *member, void **cache_slo
 {
        zend_object *zobj;
        zval tmp_member;
-       uint32_t property_offset;
+       intptr_t property_offset;
 
        zobj = Z_OBJ_P(object);
 
@@ -1497,7 +1496,7 @@ static int zend_std_has_property(zval *object, zval *member, int has_set_exists,
        int result;
        zval *value = NULL;
        zval tmp_member;
-       uint32_t property_offset;
+       intptr_t property_offset;
 
        zobj = Z_OBJ_P(object);
 
@@ -1518,10 +1517,10 @@ static int zend_std_has_property(zval *object, zval *member, int has_set_exists,
        } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
                if (EXPECTED(zobj->properties != NULL)) {
                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(property_offset)) {
-                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(property_offset);
+                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(property_offset);
 
-                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                       Bucket *p = zobj->properties->arData + idx;
+                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                        (EXPECTED(p->key == Z_STR_P(member)) ||
@@ -1533,14 +1532,13 @@ static int zend_std_has_property(zval *object, zval *member, int has_set_exists,
                                                goto found;
                                        }
                                }
-                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                        }
                        value = zend_hash_find(zobj->properties, Z_STR_P(member));
                        if (value) {
                                if (cache_slot) {
-                                       uint32_t idx = ((char*)value - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                       /* Store "hash slot index" + 2 (NULL is a mark of uninitialized cache slot) */
-                                       CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                       intptr_t idx = (char*)value - (char*)zobj->properties->arData;
+                                       CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                }
 found:
                                switch (has_set_exists) {

diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h
index fb1b473b7fa117549584e0bda5874a7e93d60855..d3febd58e45597beb789d4f6738274477be765bd 100644 (file)
--- a/Zend/zend_object_handlers.h
+++ b/Zend/zend_object_handlers.h
@@ -25,17 +25,17 @@
 struct _zend_property_info;
 
 #define ZEND_WRONG_PROPERTY_INFO \
-       ((struct _zend_property_info*)((zend_intptr_t)-1))
+       ((struct _zend_property_info*)((intptr_t)-1))
 
-#define ZEND_DYNAMIC_PROPERTY_OFFSET               ((uint32_t)(-1))
+#define ZEND_DYNAMIC_PROPERTY_OFFSET               ((intptr_t)(-1))
 
-#define IS_VALID_PROPERTY_OFFSET(offset)           ((int32_t)(offset) > 0)
-#define IS_WRONG_PROPERTY_OFFSET(offset)           ((int32_t)(offset) == 0)
-#define IS_DYNAMIC_PROPERTY_OFFSET(offset)         ((int32_t)(offset) < 0)
+#define IS_VALID_PROPERTY_OFFSET(offset)           ((intptr_t)(offset) > 0)
+#define IS_WRONG_PROPERTY_OFFSET(offset)           ((intptr_t)(offset) == 0)
+#define IS_DYNAMIC_PROPERTY_OFFSET(offset)         ((intptr_t)(offset) < 0)
 
 #define IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(offset) (offset == ZEND_DYNAMIC_PROPERTY_OFFSET)
-#define ZEND_DECODE_DYN_PROP_OFFSET(offset)        ((uint32_t)(-(int32_t)(offset) - 2))
-#define ZEND_ENCODE_DYN_PROP_OFFSET(idx)           ((uint32_t)(-(idx + 2)))
+#define ZEND_DECODE_DYN_PROP_OFFSET(offset)        (-(intptr_t)(offset) - 2)
+#define ZEND_ENCODE_DYN_PROP_OFFSET(offset)        (-((intptr_t)(offset) + 2))
 
 
 /* The following rule applies to read_property() and read_dimension() implementations:

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 20520c5952c7c8d6e922e2c7926444829744644b..76589f30afd8876af5b960f5b820854fa0f0816d 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -1792,7 +1792,7 @@ ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -1802,10 +1802,10 @@ ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -1817,12 +1817,12 @@ ZEND_VM_HANDLER(82, ZEND_FETCH_OBJ_R, CONST|TMP|VAR|UNUSED|THIS|CV, CONST|TMPVAR
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -1937,7 +1937,7 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -1947,10 +1947,10 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -1962,12 +1962,12 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, CONST|TMPVAR|UNUSED|THIS|CV, CONST|TMPVAR
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -2126,7 +2126,7 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|THIS|CV, CONST|TMPVAR|CV, SPEC(
 
        if (OP2_TYPE == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -7568,7 +7568,7 @@ ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
        zval *varname;
        zval *value;
        zval *variable_ptr;
-       uint32_t idx;
+       intptr_t idx;
        zend_reference *ref;
 
        ZEND_VM_REPEATABLE_OPCODE
@@ -7576,9 +7576,9 @@ ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
        varname = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
        /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
-       idx = (uint32_t)(uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
-       if (EXPECTED(idx < EG(symbol_table).nNumUsed)) {
-               Bucket *p = EG(symbol_table).arData + idx;
+       idx = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
+       if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
+               Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
 
                if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                (EXPECTED(p->key == Z_STR_P(varname)) ||
@@ -7587,7 +7587,7 @@ ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
                  EXPECTED(ZSTR_LEN(p->key) == Z_STRLEN_P(varname)) &&
                  EXPECTED(memcmp(ZSTR_VAL(p->key), Z_STRVAL_P(varname), Z_STRLEN_P(varname)) == 0)))) {
 
-                       value = &EG(symbol_table).arData[idx].val;
+                       value = (zval*)p; /* value = &p->val; */
                        ZEND_VM_C_GOTO(check_indirect);
                }
        }
@@ -7595,13 +7595,13 @@ ZEND_VM_HOT_HANDLER(168, ZEND_BIND_GLOBAL, CV, CONST)
        value = zend_hash_find(&EG(symbol_table), Z_STR_P(varname));
        if (UNEXPECTED(value == NULL)) {
                value = zend_hash_add_new(&EG(symbol_table), Z_STR_P(varname), &EG(uninitialized_zval));
-               idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
+               idx = (char*)value - (char*)EG(symbol_table).arData;
                /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
-               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
+               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
        } else {
-               idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
+               idx = (char*)value - (char*)EG(symbol_table).arData;
                /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
-               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
+               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
 ZEND_VM_C_LABEL(check_indirect):
                /* GLOBAL variable may be an INDIRECT pointer to CV */
                if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 385956acaea0e7d570c3578b8a80536b374b02ab..bc846336fbc664faa43c45b414187ffea1639b33 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -5011,7 +5011,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_H
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -5021,10 +5021,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_H
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -5036,12 +5036,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_H
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -5108,7 +5108,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -5118,10 +5118,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -5133,12 +5133,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -9105,7 +9105,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HAND
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -9115,10 +9115,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HAND
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -9130,12 +9130,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HAND
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -9202,7 +9202,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HAN
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -9212,10 +9212,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HAN
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -9227,12 +9227,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HAN
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -11171,7 +11171,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -11181,10 +11181,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -11196,12 +11196,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -11269,7 +11269,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -11279,10 +11279,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -11294,12 +11294,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -13697,7 +13697,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HAN
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -13707,10 +13707,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HAN
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -13722,12 +13722,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CONST_HAN
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -15071,7 +15071,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLE
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -15081,10 +15081,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLE
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -15096,12 +15096,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_CV_HANDLE
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -15616,7 +15616,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_TMPVAR_HA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -15626,10 +15626,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_TMPVAR_HA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -15641,12 +15641,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_TMP_TMPVAR_HA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -18446,7 +18446,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HAN
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -18456,10 +18456,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HAN
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -18471,12 +18471,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CONST_HAN
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -18671,7 +18671,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -18829,7 +18829,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -18987,7 +18987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -19145,7 +19145,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -22796,7 +22796,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLE
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -22806,10 +22806,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLE
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -22821,12 +22821,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_CV_HANDLE
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -23021,7 +23021,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -23179,7 +23179,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -23337,7 +23337,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -23495,7 +23495,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -25424,7 +25424,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMPVAR_HA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -25434,10 +25434,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMPVAR_HA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -25449,12 +25449,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_VAR_TMPVAR_HA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -25650,7 +25650,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -25808,7 +25808,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -25966,7 +25966,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -26124,7 +26124,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -27503,7 +27503,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -27513,10 +27513,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -27528,12 +27528,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -27647,7 +27647,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -27657,10 +27657,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -27672,12 +27672,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -27822,7 +27822,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -27980,7 +27980,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -28138,7 +28138,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -28296,7 +28296,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -30159,7 +30159,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -30169,10 +30169,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -30184,12 +30184,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HAN
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -30303,7 +30303,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -30313,10 +30313,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -30328,12 +30328,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -30478,7 +30478,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -30636,7 +30636,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -30794,7 +30794,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -30952,7 +30952,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -31919,7 +31919,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -31929,10 +31929,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -31944,12 +31944,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -32064,7 +32064,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -32074,10 +32074,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -32089,12 +32089,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -32240,7 +32240,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -32398,7 +32398,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -32556,7 +32556,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -32714,7 +32714,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -36492,7 +36492,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HAND
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -36502,10 +36502,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HAND
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -36517,12 +36517,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HAND
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -36636,7 +36636,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HAN
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -36646,10 +36646,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HAN
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -36661,12 +36661,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HAN
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -36824,7 +36824,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -36982,7 +36982,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -37140,7 +37140,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -37298,7 +37298,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA
 
        if (IS_CONST == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -38882,7 +38882,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_C
        zval *varname;
        zval *value;
        zval *variable_ptr;
-       uint32_t idx;
+       intptr_t idx;
        zend_reference *ref;
 
        ZEND_VM_REPEATABLE_OPCODE
@@ -38890,9 +38890,9 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_C
        varname = RT_CONSTANT(opline, opline->op2);
 
        /* We store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
-       idx = (uint32_t)(uintptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
-       if (EXPECTED(idx < EG(symbol_table).nNumUsed)) {
-               Bucket *p = EG(symbol_table).arData + idx;
+       idx = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(varname)) - 1;
+       if (EXPECTED(idx < EG(symbol_table).nNumUsed * sizeof(Bucket))) {
+               Bucket *p = (Bucket*)((char*)EG(symbol_table).arData + idx);
 
                if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                (EXPECTED(p->key == Z_STR_P(varname)) ||
@@ -38901,7 +38901,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_C
                  EXPECTED(ZSTR_LEN(p->key) == Z_STRLEN_P(varname)) &&
                  EXPECTED(memcmp(ZSTR_VAL(p->key), Z_STRVAL_P(varname), Z_STRLEN_P(varname)) == 0)))) {
 
-                       value = &EG(symbol_table).arData[idx].val;
+                       value = (zval*)p; /* value = &p->val; */
                        goto check_indirect;
                }
        }
@@ -38909,13 +38909,13 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_BIND_GLOBAL_SPEC_C
        value = zend_hash_find(&EG(symbol_table), Z_STR_P(varname));
        if (UNEXPECTED(value == NULL)) {
                value = zend_hash_add_new(&EG(symbol_table), Z_STR_P(varname), &EG(uninitialized_zval));
-               idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
+               idx = (char*)value - (char*)EG(symbol_table).arData;
                /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
-               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
+               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
        } else {
-               idx = ((char*)value - (char*)EG(symbol_table).arData) / sizeof(Bucket);
+               idx = (char*)value - (char*)EG(symbol_table).arData;
                /* Store "hash slot index" + 1 (NULL is a mark of uninitialized cache slot) */
-               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(uintptr_t)(idx + 1));
+               CACHE_PTR(Z_CACHE_SLOT_P(varname), (void*)(idx + 1));
 check_indirect:
                /* GLOBAL variable may be an INDIRECT pointer to CV */
                if (UNEXPECTED(Z_TYPE_P(value) == IS_INDIRECT)) {
@@ -42978,7 +42978,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -42988,10 +42988,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -43003,12 +43003,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -43122,7 +43122,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLE
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -43132,10 +43132,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLE
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -43147,12 +43147,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLE
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -43310,7 +43310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -43468,7 +43468,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -43626,7 +43626,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -43784,7 +43784,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_
 
        if (IS_CV == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -46698,7 +46698,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -46708,10 +46708,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -46723,12 +46723,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HAN
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY_UNREF(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -46843,7 +46843,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -46853,10 +46853,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -46868,12 +46868,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -47032,7 +47032,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -47190,7 +47190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -47348,7 +47348,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -47506,7 +47506,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D
 
        if ((IS_TMP_VAR|IS_VAR) == IS_CONST &&
            EXPECTED(Z_OBJCE_P(object) == CACHED_PTR(Z_CACHE_SLOT_P(property)))) {
-               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
+               intptr_t prop_offset = (intptr_t)CACHED_PTR(Z_CACHE_SLOT_P(property) + sizeof(void*));
                zend_object *zobj = Z_OBJ_P(object);
                zval *property_val;
 
@@ -50108,7 +50108,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -50118,10 +50118,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -50133,12 +50133,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -52469,7 +52469,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -52479,10 +52479,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -52494,12 +52494,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }
@@ -53823,7 +53823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVA
                        cache_slot = CACHE_ADDR(Z_CACHE_SLOT_P(offset));
 
                        if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) {
-                               uint32_t prop_offset = (uint32_t)(intptr_t)CACHED_PTR_EX(cache_slot + 1);
+                               intptr_t prop_offset = (intptr_t)CACHED_PTR_EX(cache_slot + 1);
 
                                if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) {
                                        retval = OBJ_PROP(zobj, prop_offset);
@@ -53833,10 +53833,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVA
                                        }
                                } else if (EXPECTED(zobj->properties != NULL)) {
                                        if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) {
-                                               uint32_t idx =  ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
+                                               intptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset);
 
-                                               if (EXPECTED(idx < zobj->properties->nNumUsed)) {
-                                                       Bucket *p = zobj->properties->arData + idx;
+                                               if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
+                                                       Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
 
                                                        if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
                                                        (EXPECTED(p->key == Z_STR_P(offset)) ||
@@ -53848,12 +53848,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVA
                                                                break;
                                                        }
                                                }
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_DYNAMIC_PROPERTY_OFFSET);
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
                                        }
                                        retval = zend_hash_find(zobj->properties, Z_STR_P(offset));
                                        if (EXPECTED(retval)) {
-                                               uint32_t idx = ((char*)retval - (char*)zobj->properties->arData) / sizeof(Bucket);
-                                               CACHE_PTR_EX(cache_slot + 1, (void*)(uintptr_t)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
+                                               intptr_t idx = (char*)retval - (char*)zobj->properties->arData;
+                                               CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
                                                ZVAL_COPY(EX_VAR(opline->result.var), retval);
                                                break;
                                        }