Moved zend_literal->cache_slot right into zval.

It should be accessed using Z_CACHE_SLOT() macro.
zend_literal structure is removed.
API functions that accepted pointer to zend_literal now accept pointer to zval or cache_slot directly.
Calls of such functiond that now accept cache_slot need to be changed to pass -1 instead of NULL.

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index fc0b424200185b0577b596588afa32381373d62d..f16d07b00485bd53190bf9ebd51edd5fca41acb6 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1086,7 +1086,7 @@ static int zend_merge_property(zval *value TSRMLS_DC, int num_args, va_list args
                zval member;
 
                ZVAL_STR(&member, STR_COPY(hash_key->key));
-               obj_ht->write_property(obj, &member, value, 0 TSRMLS_CC);
+               obj_ht->write_property(obj, &member, value, -1 TSRMLS_CC);
                zval_ptr_dtor(&member);
        }
        return ZEND_HASH_APPLY_KEEP;
@@ -1686,7 +1686,7 @@ ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long
 
        ZVAL_LONG(&tmp, n);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1700,7 +1700,7 @@ ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int
 
        ZVAL_BOOL(&tmp, b);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1714,7 +1714,7 @@ ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRML
 
        ZVAL_NULL(&tmp);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1728,7 +1728,7 @@ ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len,
 
        ZVAL_RES(&tmp, r);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1742,7 +1742,7 @@ ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, do
 
        ZVAL_DOUBLE(&tmp, d);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1756,7 +1756,7 @@ ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, co
 
        ZVAL_STRING(&tmp, str);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1770,7 +1770,7 @@ ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, c
 
        ZVAL_STRINGL(&tmp, str, length);
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
        zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
        zval_ptr_dtor(&z_key);
        return SUCCESS;
@@ -1782,7 +1782,7 @@ ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval
        zval z_key;
 
        ZVAL_STRINGL(&z_key, key, key_len);
-       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, value, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, value, -1 TSRMLS_CC);
        zval_ptr_dtor(&z_key);
        return SUCCESS;
 }
@@ -3737,7 +3737,7 @@ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const
                zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, class_name->val);
        }
        ZVAL_STRINGL(&property, name, name_length);
-       Z_OBJ_HT_P(object)->write_property(object, &property, value, 0 TSRMLS_CC);
+       Z_OBJ_HT_P(object)->write_property(object, &property, value, -1 TSRMLS_CC);
        zval_ptr_dtor(&property);
 
        EG(scope) = old_scope;
@@ -3816,7 +3816,7 @@ ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *na
        zend_string *key = STR_INIT(name, name_length, 0);
 
        EG(scope) = scope;
-       property = zend_std_get_static_property(scope, key, 0, NULL TSRMLS_CC);
+       property = zend_std_get_static_property(scope, key, 0, -1 TSRMLS_CC);
        EG(scope) = old_scope;
        STR_FREE(key);
        if (!property) {
@@ -3916,7 +3916,7 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const c
        }
 
        ZVAL_STRINGL(&property, name, name_length);
-       value = Z_OBJ_HT_P(object)->read_property(object, &property, silent?BP_VAR_IS:BP_VAR_R, 0, &rv TSRMLS_CC);
+       value = Z_OBJ_HT_P(object)->read_property(object, &property, silent?BP_VAR_IS:BP_VAR_R, -1, &rv TSRMLS_CC);
        zval_ptr_dtor(&property);
 
        EG(scope) = old_scope;
@@ -3931,7 +3931,7 @@ ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *na
        zend_string *key = STR_INIT(name, name_length, 0);
 
        EG(scope) = scope;
-       property = zend_std_get_static_property(scope, key, silent, NULL TSRMLS_CC);
+       property = zend_std_get_static_property(scope, key, silent, -1 TSRMLS_CC);
        EG(scope) = old_scope;
        STR_FREE(key);
 

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index d3839108c70b1c230d7a1433fde856ce46ec45fe..cffe0b4c78bd704d38d2d53086bd1b072cadfd20 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -1205,7 +1205,7 @@ ZEND_FUNCTION(property_exists)
 
        if (Z_TYPE_P(object) ==  IS_OBJECT &&
                Z_OBJ_HANDLER_P(object, has_property) && 
-               Z_OBJ_HANDLER_P(object, has_property)(object, &property_z, 2, 0 TSRMLS_CC)) {
+               Z_OBJ_HANDLER_P(object, has_property)(object, &property_z, 2, -1 TSRMLS_CC)) {
                RETURN_TRUE;
        }
        RETURN_FALSE;

diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
index 1b1d6ef6edb5ffeebefccf2a075ddf1eb885822a..7b587a9223c9265dd9c1010714a31d89840dfef9 100644 (file)
--- a/Zend/zend_closures.c
+++ b/Zend/zend_closures.c
@@ -152,7 +152,7 @@ ZEND_API zval* zend_get_closure_this_ptr(zval *obj TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static zend_function *zend_closure_get_method(zend_object **object, zend_string *method, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zend_function *zend_closure_get_method(zend_object **object, zend_string *method, const zval *key TSRMLS_DC) /* {{{ */
 {
        zend_string *lc_name;
 
@@ -169,27 +169,27 @@ static zend_function *zend_closure_get_method(zend_object **object, zend_string
 }
 /* }}} */
 
-static zval *zend_closure_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC) /* {{{ */
+static zval *zend_closure_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
        ZEND_CLOSURE_PROPERTY_ERROR();
        return &EG(uninitialized_zval);
 }
 /* }}} */
 
-static void zend_closure_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void zend_closure_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        ZEND_CLOSURE_PROPERTY_ERROR();
 }
 /* }}} */
 
-static zval *zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        ZEND_CLOSURE_PROPERTY_ERROR();
        return NULL;
 }
 /* }}} */
 
-static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        if (has_set_exists != 2) {
                ZEND_CLOSURE_PROPERTY_ERROR();
@@ -198,7 +198,7 @@ static int zend_closure_has_property(zval *object, zval *member, int has_set_exi
 }
 /* }}} */
 
-static void zend_closure_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void zend_closure_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        ZEND_CLOSURE_PROPERTY_ERROR();
 }

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index f0f83f147776b2ea1ad2663775f3689666f5c4de..8ccab3942e2977a1aae978c0d26a8c2bbc2f7c05 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -31,7 +31,7 @@
 #include "zend_language_scanner.h"
 
 #define CONSTANT_EX(op_array, op) \
-       (op_array)->literals[op].constant
+       (op_array)->literals[op]
 
 #define CONSTANT(op) \
        CONSTANT_EX(CG(active_op_array), op)
@@ -61,7 +61,7 @@
        } while (0)
 
 #define GET_CACHE_SLOT(literal) do { \
-               CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot++; \
+               Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot++; \
                if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
                        CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
                        CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
@@ -71,7 +71,7 @@
 #define POLYMORPHIC_CACHE_SLOT_SIZE 2
 
 #define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \
-               CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot; \
+               Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot; \
                CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \
                if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
                        CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
@@ -81,10 +81,10 @@
        } while (0)
 
 #define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \
-               if (CG(active_op_array)->literals[literal].cache_slot != -1 && \
-                   CG(active_op_array)->literals[literal].cache_slot == \
+               if (Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) != -1 && \
+                   Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) == \
                    CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \
-                       CG(active_op_array)->literals[literal].cache_slot = -1; \
+                       Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = -1; \
                        CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \
                } \
        } while (0)
@@ -350,7 +350,7 @@ static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int li
                }
        }
        ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
-       op_array->literals[literal_position].cache_slot = -1;
+       Z_CACHE_SLOT(op_array->literals[literal_position]) = -1;
 }
 /* }}} */
 
@@ -365,7 +365,7 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ *
                while (i >= CG(context).literals_size) {
                        CG(context).literals_size += 16; /* FIXME */
                }
-               op_array->literals = (zend_literal*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zend_literal));
+               op_array->literals = (zval*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zval));
        }
        zend_insert_literal(op_array, zv, i TSRMLS_CC);
        return i;
@@ -378,7 +378,7 @@ int zend_append_individual_literal(zend_op_array *op_array, const zval *zv TSRML
 {
        int i = op_array->last_literal;
        op_array->last_literal++;
-       op_array->literals = (zend_literal*)erealloc(op_array->literals, (i + 1) * sizeof(zend_literal));
+       op_array->literals = (zval*)erealloc(op_array->literals, (i + 1) * sizeof(zval));
        zend_insert_literal(op_array, zv, i TSRMLS_CC);
        return i;
 }
@@ -391,8 +391,8 @@ int zend_add_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC
        zval c;
 
        if (op_array->last_literal > 0 &&
-           &op_array->literals[op_array->last_literal - 1].constant == zv &&
-           op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+           &op_array->literals[op_array->last_literal - 1] == zv &&
+           Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
                /* we already have function name as last literal (do nothing) */
                ret = op_array->last_literal - 1;
        } else {
@@ -417,8 +417,8 @@ int zend_add_ns_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS
        zval c;
 
        if (op_array->last_literal > 0 &&
-           &op_array->literals[op_array->last_literal - 1].constant == zv &&
-           op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+           &op_array->literals[op_array->last_literal - 1] == zv &&
+           Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
                /* we already have function name as last literal (do nothing) */
                ret = op_array->last_literal - 1;
        } else {
@@ -452,8 +452,8 @@ int zend_add_class_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_D
        zval c;
 
        if (op_array->last_literal > 0 &&
-           &op_array->literals[op_array->last_literal - 1].constant == zv &&
-           op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+           &op_array->literals[op_array->last_literal - 1] == zv &&
+           Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
                /* we already have function name as last literal (do nothing) */
                ret = op_array->last_literal - 1;
        } else {
@@ -486,8 +486,8 @@ int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unq
        zval c;
 
        if (op_array->last_literal > 0 &&
-           &op_array->literals[op_array->last_literal - 1].constant == zv &&
-           op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+           &op_array->literals[op_array->last_literal - 1] == zv &&
+           Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
                /* we already have function name as last literal (do nothing) */
                ret = op_array->last_literal - 1;
        } else {

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index b8ac4f9b1fe566df3af68660c61202a8408842af..bf82b0c1a359341a8a544af2d87925adbd705fe9 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -65,11 +65,6 @@ typedef struct _zend_compiler_context {
        HashTable *labels;
 } zend_compiler_context;
 
-typedef struct _zend_literal {
-       zval       constant;
-       zend_uint  cache_slot;
-} zend_literal;
-
 typedef union _znode_op {
        zend_uint      constant;
        zend_uint      var;
@@ -78,7 +73,6 @@ typedef union _znode_op {
        zend_uint      opline_num; /*  Needs to be signed */
        zend_op       *jmp_addr;
        zval          *zv;
-       zend_literal  *literal;
        void          *ptr;        /* Used for passing pointers from the compile to execution phase, currently used for traits */
 } znode_op;
 
@@ -294,7 +288,7 @@ struct _zend_op_array {
        zend_string *doc_comment;
        zend_uint early_binding; /* the linked list of delayed declarations */
 
-       zend_literal *literals;
+       zval *literals;
        int last_literal;
 
        void **run_time_cache;

diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
index d917fed502f069b9826c441c79d07b68ca67ffe9..f3c58065ee0d4121864b4b6292d5614df6d2fa69 100644 (file)
--- a/Zend/zend_constants.c
+++ b/Zend/zend_constants.c
@@ -440,28 +440,28 @@ finish:
        return zend_get_constant(name, name_len, result TSRMLS_CC);
 }
 
-zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC)
+zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC)
 {
        zend_constant *c;
 
-       if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR(key->constant))) == NULL) {
+       if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
                key++;
-               if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR(key->constant))) == NULL ||
+               if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
                    (c->flags & CONST_CS) != 0) {
                        if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
                                key++;
-                               if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR(key->constant))) == NULL) {
+                               if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
                                    key++;
-                                       if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR(key->constant))) == NULL ||
+                                       if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
                                            (c->flags & CONST_CS) != 0) {
 
                                                key--;
-                                               c = zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant) TSRMLS_CC);
+                                               c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRLEN_P(key) TSRMLS_CC);
                                        }
                                }
                        } else {
                                key--;
-                               c = zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant) TSRMLS_CC);
+                               c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRLEN_P(key) TSRMLS_CC);
                        }
                }
        }

diff --git a/Zend/zend_constants.h b/Zend/zend_constants.h
index 5ededead25429faf45f73c7ea3712e8c1a0fbcc0..df7f27cf8f71908b7e510106a25275e514d9bba3 100644 (file)
--- a/Zend/zend_constants.h
+++ b/Zend/zend_constants.h
@@ -75,7 +75,7 @@ ZEND_API void zend_register_string_constant(const char *name, uint name_len, cha
 ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC);
 ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC);
 void zend_copy_constants(HashTable *target, HashTable *sourc);
-zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC);
+zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC);
 END_EXTERN_C()
 
 #define ZEND_CONSTANT_DTOR free_zend_constant

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 762333d1258ca82305474609260282832da1611a..acc22a8ec530fc4047c2b3959638507802b94c16 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -663,7 +663,7 @@ static void zend_verify_missing_arg(zend_execute_data *execute_data, zend_uint a
        }
 }
 
-static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *property_name, int value_type, znode_op *value_op, const zend_execute_data *execute_data, int opcode, const zend_literal *key TSRMLS_DC)
+static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *property_name, int value_type, znode_op *value_op, const zend_execute_data *execute_data, int opcode, zend_uint cache_slot TSRMLS_DC)
 {
        zend_free_op free_value;
        zval *value = get_zval_ptr(value_type, value_op, execute_data, &free_value, BP_VAR_R);
@@ -744,7 +744,7 @@ static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *p
                        FREE_OP(free_value);
                        return;
                }
-               Z_OBJ_HT_P(object)->write_property(object, property_name, value, key TSRMLS_CC);
+               Z_OBJ_HT_P(object)->write_property(object, property_name, value, cache_slot TSRMLS_CC);
        } else {
                /* Note:  property_name in this case is really the array index! */
                if (!Z_OBJ_HT_P(object)->write_dimension) {
@@ -1346,7 +1346,7 @@ static zend_never_inline void zend_fetch_dimension_address_read_IS(zval *result,
        zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS TSRMLS_CC);
 }
 
-static void zend_fetch_property_address(zval *result, zval *container_ptr, zval *prop_ptr, const zend_literal *key, int type, int is_ref TSRMLS_DC)
+static void zend_fetch_property_address(zval *result, zval *container_ptr, zval *prop_ptr, zend_uint cache_slot, int type, int is_ref TSRMLS_DC)
 {
        zval *container = container_ptr;
 
@@ -1374,10 +1374,10 @@ static void zend_fetch_property_address(zval *result, zval *container_ptr, zval
        }
 
        if (Z_OBJ_HT_P(container)->get_property_ptr_ptr) {
-               zval *ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, key TSRMLS_CC);
+               zval *ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, cache_slot TSRMLS_CC);
                if (NULL == ptr) {
                        if (Z_OBJ_HT_P(container)->read_property &&
-                               (ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key, result TSRMLS_CC)) != NULL) {
+                               (ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result TSRMLS_CC)) != NULL) {
                                if (ptr != result) {
                                        if (is_ref && ptr != &EG(uninitialized_zval)) {
                                                SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
@@ -1398,7 +1398,7 @@ static void zend_fetch_property_address(zval *result, zval *container_ptr, zval
                        }
                }
        } else if (Z_OBJ_HT_P(container)->read_property) {
-               zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key, result TSRMLS_CC);
+               zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result TSRMLS_CC);
                if (ptr != result) {
                        if (is_ref && ptr != &EG(uninitialized_zval)) {
                                SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index a7d97868fc2912eb152713e26d522f0cf7f5fb08..747b116e7fa205cb23eb975d4bbfab4c359ac225 100644 (file)
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -41,7 +41,7 @@ ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC);
 ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci TSRMLS_DC);
 ZEND_API int zend_is_true(zval *op TSRMLS_DC);
 ZEND_API zend_class_entry *zend_lookup_class(zend_string *name TSRMLS_DC);
-ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zend_literal *key, int use_autoload TSRMLS_DC);
+ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload TSRMLS_DC);
 ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
@@ -302,7 +302,7 @@ ZEND_API void zend_set_timeout(long seconds, int reset_signals);
 ZEND_API void zend_unset_timeout(TSRMLS_D);
 ZEND_API void zend_timeout(int dummy);
 ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type TSRMLS_DC);
-ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zend_literal *key, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type TSRMLS_DC);
 void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
 
 #ifdef ZEND_WIN32

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index a72fb5dd6d5f2b56c9a4a50bf42f1df3a84e0929..0c6861c14da1412c44667f05e8b73b9e237757e0 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -1005,7 +1005,7 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 }
 /* }}} */
 
-ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zend_literal *key, int use_autoload TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload TSRMLS_DC) /* {{{ */
 {
        zend_class_entry *ce = NULL;
        zval args[1];
@@ -1016,7 +1016,7 @@ ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zend_li
        zend_fcall_info_cache fcall_cache;
 
        if (key) {
-               lc_name = Z_STR(key->constant);
+               lc_name = Z_STR_P(key);
        } else {
                if (name == NULL || !name->len) {
                        return NULL;
@@ -1248,10 +1248,10 @@ void execute_new_code(TSRMLS_D) /* {{{ */
 
        while (opline<end) {
                if (opline->op1_type == IS_CONST) {
-                       opline->op1.zv = &CG(active_op_array)->literals[opline->op1.constant].constant;
+                       opline->op1.zv = &CG(active_op_array)->literals[opline->op1.constant];
                }
                if (opline->op2_type == IS_CONST) {
-                       opline->op2.zv = &CG(active_op_array)->literals[opline->op2.constant].constant;
+                       opline->op2.zv = &CG(active_op_array)->literals[opline->op2.constant];
                }
                switch (opline->opcode) {
                        case ZEND_GOTO:
@@ -1560,7 +1560,7 @@ check_fetch_type:
 }
 /* }}} */
 
-zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zend_literal *key, int fetch_type TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type TSRMLS_DC) /* {{{ */
 {
        zend_class_entry *ce;
        int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 862ba99bdc3a42f23c46e44c1434d2c00d82fcf0..beea7bdb16722f4b865a2900f4302b7e6f17c653 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -265,13 +265,13 @@ static zend_always_inline zend_bool is_derived_class(zend_class_entry *child_cla
 }
 /* }}} */
 
-static zend_always_inline struct _zend_property_info *zend_get_property_info_quick(zend_class_entry *ce, zend_string *member, int silent, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zend_always_inline struct _zend_property_info *zend_get_property_info_quick(zend_class_entry *ce, zend_string *member, int silent, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_property_info *property_info;
        zend_property_info *scope_property_info;
        zend_bool denied_access = 0;
 
-       if (key && (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) != NULL) {
+       if (cache_slot != -1 && (property_info = CACHED_POLYMORPHIC_PTR(cache_slot, ce)) != NULL) {
                return property_info;
        }
 
@@ -302,8 +302,8 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
                                        if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) != 0) && !silent) {
                                                zend_error(E_STRICT, "Accessing static property %s::$%s as non static", ce->name->val, member->val);
                                        }
-                                       if (key) {
-                                               CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
+                                       if (cache_slot != -1) {
+                                               CACHE_POLYMORPHIC_PTR(cache_slot, ce, property_info);
                                        }
                                        return property_info;
                                }
@@ -318,8 +318,8 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
                && is_derived_class(ce, EG(scope))
                && (scope_property_info = zend_hash_find_ptr(&EG(scope)->properties_info, member)) != NULL
                && scope_property_info->flags & ZEND_ACC_PRIVATE) {
-               if (key) {
-                       CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, scope_property_info);
+               if (cache_slot != -1) {
+                       CACHE_POLYMORPHIC_PTR(cache_slot, ce, scope_property_info);
                }
                return scope_property_info;
        } else if (property_info) {
@@ -331,8 +331,8 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
                        return NULL;
                } else {
                        /* fall through, return property_info... */
-                       if (key) {
-                               CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
+                       if (cache_slot != -1) {
+                               CACHE_POLYMORPHIC_PTR(cache_slot, ce, property_info);
                        }
                }
        } else {
@@ -348,7 +348,7 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
 
 ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zval *member, int silent TSRMLS_DC) /* {{{ */
 {
-       return zend_get_property_info_quick(ce, Z_STR_P(member), silent, NULL TSRMLS_CC);
+       return zend_get_property_info_quick(ce, Z_STR_P(member), silent, -1 TSRMLS_CC);
 }
 /* }}} */
 
@@ -366,7 +366,7 @@ ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_inf
        } else {
                member = STR_COPY(prop_info_name);
        }
-       property_info = zend_get_property_info_quick(zobj->ce, member, 1, NULL TSRMLS_CC);
+       property_info = zend_get_property_info_quick(zobj->ce, member, 1, -1 TSRMLS_CC);
        STR_RELEASE(member);
        if (!property_info) {
                return FAILURE;
@@ -421,7 +421,7 @@ static long *zend_get_property_guard(zend_object *zobj, zend_property_info *prop
 }
 /* }}} */
 
-zval *zend_std_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC) /* {{{ */
+zval *zend_std_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
        zend_object *zobj;
        zval tmp_member;
@@ -437,7 +437,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, const zend_li
                ZVAL_DUP(&tmp_member, member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
 #if DEBUG_OBJECT_HANDLERS
@@ -445,7 +445,7 @@ zval *zend_std_read_property(zval *object, zval *member, int type, const zend_li
 #endif
 
        /* make zend_get_property_info silent if we have getter - we may want to use it */
-       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), silent || (zobj->ce->__get != NULL), key TSRMLS_CC);
+       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), silent || (zobj->ce->__get != NULL), cache_slot TSRMLS_CC);
 
        if (EXPECTED(property_info != NULL)) {
                if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
@@ -519,7 +519,7 @@ exit:
 }
 /* }}} */
 
-ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_object *zobj;
        zval tmp_member;
@@ -533,10 +533,10 @@ ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, c
                ZVAL_DUP(&tmp_member, member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
-       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__set != NULL), key TSRMLS_CC);
+       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__set != NULL), cache_slot TSRMLS_CC);
 
        if (EXPECTED(property_info != NULL)) {
                if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
@@ -723,7 +723,7 @@ static int zend_std_has_dimension(zval *object, zval *offset, int check_empty TS
 }
 /* }}} */
 
-static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_object *zobj;
        zval tmp_member;
@@ -738,14 +738,14 @@ static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type,
                ZVAL_DUP(&tmp_member, member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
 #if DEBUG_OBJECT_HANDLERS
        fprintf(stderr, "Ptr object #%d property: %s\n", Z_OBJ_HANDLE_P(object), Z_STRVAL_P(member));
 #endif
 
-       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__get != NULL), key TSRMLS_CC);
+       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__get != NULL), cache_slot TSRMLS_CC);
 
        if (EXPECTED(property_info != NULL)) {
                if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
@@ -792,7 +792,7 @@ exit:
 }
 /* }}} */
 
-static void zend_std_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void zend_std_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_object *zobj;
        zval tmp_member;
@@ -805,10 +805,10 @@ static void zend_std_unset_property(zval *object, zval *member, const zend_liter
                ZVAL_DUP(&tmp_member, member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
-       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__unset != NULL), key TSRMLS_CC);
+       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__unset != NULL), cache_slot TSRMLS_CC);
 
        if (EXPECTED(property_info != NULL)) {
                if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
@@ -1007,7 +1007,7 @@ static inline union _zend_function *zend_get_user_call_function(zend_class_entry
 }
 /* }}} */
 
-static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *method_name, const zend_literal *key TSRMLS_DC) /* {{{ */
+static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *method_name, const zval *key TSRMLS_DC) /* {{{ */
 {
        zend_object *zobj = *obj_ptr;
        zval *func;
@@ -1015,7 +1015,7 @@ static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_str
        zend_string *lc_method_name;
 
        if (EXPECTED(key != NULL)) {
-               lc_method_name = Z_STR(key->constant);
+               lc_method_name = Z_STR_P(key);
        } else {
                lc_method_name = STR_ALLOC(method_name->len, 0);
                zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len);
@@ -1148,14 +1148,14 @@ static inline union _zend_function *zend_get_user_callstatic_function(zend_class
 
 /* This is not (yet?) in the API, but it belongs in the built-in objects callbacks */
 
-ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name, const zval *key TSRMLS_DC) /* {{{ */
 {
        zend_function *fbc = NULL;
        char *lc_class_name;
        zend_string *lc_function_name;
 
        if (EXPECTED(key != NULL)) {
-               lc_function_name = Z_STR(key->constant);
+               lc_function_name = Z_STR_P(key);
        } else {
                lc_function_name = STR_ALLOC(function_name->len, 0);
                zend_str_tolower_copy(lc_function_name->val, function_name->val, function_name->len);
@@ -1237,12 +1237,12 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_st
 }
 /* }}} */
 
-ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_property_info *property_info;
 
-       if (UNEXPECTED(!key) ||
-           (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) == NULL) {
+       if (UNEXPECTED(cache_slot == -1) ||
+           (property_info = CACHED_POLYMORPHIC_PTR(cache_slot, ce)) == NULL) {
 
                if (UNEXPECTED((property_info = zend_hash_find_ptr(&ce->properties_info, property_name)) == NULL)) {
                        if (!silent) {
@@ -1267,8 +1267,8 @@ ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *p
 
                zend_update_class_constants(ce TSRMLS_CC);
 
-               if (EXPECTED(key != NULL)) {
-                       CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
+               if (EXPECTED(cache_slot != -1)) {
+                       CACHE_POLYMORPHIC_PTR(cache_slot, ce, property_info);
                }
        }
 
@@ -1284,7 +1284,7 @@ ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *p
 }
 /* }}} */
 
-ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_error_noreturn(E_ERROR, "Attempt to unset static property %s::$%s", ce->name->val, property_name->val);
        return 0;
@@ -1389,7 +1389,7 @@ static int zend_std_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int zend_std_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int zend_std_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        zend_object *zobj;
        int result;
@@ -1404,10 +1404,10 @@ static int zend_std_has_property(zval *object, zval *member, int has_set_exists,
                ZVAL_DUP(&tmp_member, member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
-       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), 1, key TSRMLS_CC);
+       property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), 1, cache_slot TSRMLS_CC);
 
        if (EXPECTED(property_info != NULL)) {
                if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&

diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h
index 48e2e49cd84403f4f5ff20b9ea429a274af27b97..1b6c85b8c53fa86331badb11a9fa542ebdf3cc9e 100644 (file)
--- a/Zend/zend_object_handlers.h
+++ b/Zend/zend_object_handlers.h
@@ -24,14 +24,13 @@
 
 union _zend_function;
 struct _zend_property_info;
-struct _zend_literal;
 
 /* The following rule applies to read_property() and read_dimension() implementations:
    If you return a zval which is not otherwise referenced by the extension or the engine's
    symbol table, its reference count should be 0.
 */
 /* Used to fetch property from the object, read-only */
-typedef zval *(*zend_object_read_property_t)(zval *object, zval *member, int type, const struct _zend_literal *key, zval *rv TSRMLS_DC);
+typedef zval *(*zend_object_read_property_t)(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC);
 
 /* Used to fetch dimension from the object, read-only */
 typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int type, zval *rv TSRMLS_DC);
@@ -43,14 +42,14 @@ typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int ty
    any changes.  You should NOT modify the reference count of the value passed to you.
 */
 /* Used to set property of the object */
-typedef void (*zend_object_write_property_t)(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC);
+typedef void (*zend_object_write_property_t)(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to set dimension of the object */
 typedef void (*zend_object_write_dimension_t)(zval *object, zval *offset, zval *value TSRMLS_DC);
 
 
 /* Used to create pointer to the property of the object, for future direct r/w access */
-typedef zval *(*zend_object_get_property_ptr_ptr_t)(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC);
+typedef zval *(*zend_object_get_property_ptr_ptr_t)(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to set object value. Can be used to override assignments and scalar
    write ops (like ++, +=) on the object */
@@ -67,13 +66,13 @@ typedef zval* (*zend_object_get_t)(zval *object, zval *rv TSRMLS_DC);
  * 1 (set) whether property exists and is true
  * 2 (exists) whether property exists
  */
-typedef int (*zend_object_has_property_t)(zval *object, zval *member, int has_set_exists, const struct _zend_literal *key TSRMLS_DC);
+typedef int (*zend_object_has_property_t)(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to check if a dimension of the object exists */
 typedef int (*zend_object_has_dimension_t)(zval *object, zval *member, int check_empty TSRMLS_DC);
 
 /* Used to remove a property of the object */
-typedef void (*zend_object_unset_property_t)(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC);
+typedef void (*zend_object_unset_property_t)(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to remove a dimension of the object */
 typedef void (*zend_object_unset_dimension_t)(zval *object, zval *offset TSRMLS_DC);
@@ -88,7 +87,7 @@ typedef HashTable *(*zend_object_get_debug_info_t)(zval *object, int *is_temp TS
 /* Andi - EX(fbc) (function being called) needs to be initialized already in the INIT fcall opcode so that the parameters can be parsed the right way. We need to add another callback for this.
  */
 typedef int (*zend_object_call_method_t)(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS);
-typedef union _zend_function *(*zend_object_get_method_t)(zend_object **object, zend_string *method, const struct _zend_literal *key TSRMLS_DC);
+typedef union _zend_function *(*zend_object_get_method_t)(zend_object **object, zend_string *method, const zval *key TSRMLS_DC);
 typedef union _zend_function *(*zend_object_get_constructor_t)(zend_object *object TSRMLS_DC);
 
 /* Object maintenance/destruction */
@@ -156,15 +155,15 @@ extern ZEND_API zend_object_handlers std_object_handlers;
        ((fbc)->common.prototype ? (fbc)->common.prototype->common.scope : (fbc)->common.scope)
 
 BEGIN_EXTERN_C()
-ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name_strval, const struct _zend_literal *key TSRMLS_DC);
-ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, const struct _zend_literal *key TSRMLS_DC);
-ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, const struct _zend_literal *key TSRMLS_DC);
+ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name_strval, const zval *key TSRMLS_DC);
+ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, zend_uint cache_slot TSRMLS_DC);
+ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, zend_uint cache_slot TSRMLS_DC);
 ZEND_API union _zend_function *zend_std_get_constructor(zend_object *object TSRMLS_DC);
 ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zval *member, int silent TSRMLS_DC);
 ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC);
 ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC);
 ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type TSRMLS_DC);
-ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC);
+ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
 ZEND_API void rebuild_object_properties(zend_object *zobj);
 
 

diff --git a/Zend/zend_objects_API.c b/Zend/zend_objects_API.c
index 3d97aaaf7a1ae4a629332eee437ef7d9dc17b2db..285a752c2ba6c04595a0c7a247979f32153c750f 100644 (file)
--- a/Zend/zend_objects_API.c
+++ b/Zend/zend_objects_API.c
@@ -270,7 +270,7 @@ ZEND_API void zend_object_proxy_set(zval *property, zval *value TSRMLS_DC)
        zend_proxy_object *probj = (zend_proxy_object*)Z_OBJ_P(property);
 
        if (Z_OBJ_HT(probj->object) && Z_OBJ_HT(probj->object)->write_property) {
-               Z_OBJ_HT(probj->object)->write_property(&probj->object, &probj->property, value, 0 TSRMLS_CC);
+               Z_OBJ_HT(probj->object)->write_property(&probj->object, &probj->property, value, -1 TSRMLS_CC);
        } else {
                zend_error(E_WARNING, "Cannot write property of object - no write handler defined");
        }
@@ -281,7 +281,7 @@ ZEND_API zval* zend_object_proxy_get(zval *property TSRMLS_DC)
        zend_proxy_object *probj = (zend_proxy_object*)Z_OBJ_P(property);
 
        if (Z_OBJ_HT(probj->object) && Z_OBJ_HT(probj->object)->read_property) {
-               return Z_OBJ_HT(probj->object)->read_property(&probj->object, &probj->property, BP_VAR_R, 0, NULL TSRMLS_CC);
+               return Z_OBJ_HT(probj->object)->read_property(&probj->object, &probj->property, BP_VAR_R, -1, NULL TSRMLS_CC);
        } else {
                zend_error(E_WARNING, "Cannot read property of object - no read handler defined");
        }

diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index f0883e8ccbaee396182516aa940825e1f6038938..087960ca338cc1420c462fcc8463e7883ddbc6af 100644 (file)
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -364,8 +364,8 @@ void zend_class_add_ref(zval *zv)
 
 ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
 {
-       zend_literal *literal = op_array->literals;
-       zend_literal *end;
+       zval *literal = op_array->literals;
+       zval *end;
        zend_uint i;
 
        if (op_array->static_variables) {
@@ -395,7 +395,7 @@ ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
        if (literal) {
                end = literal + op_array->last_literal;
                while (literal < end) {
-                       zval_dtor(&literal->constant);
+                       zval_dtor(literal);
                        literal++;
                }
                efree(op_array->literals);
@@ -638,7 +638,7 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC)
                                int nest_levels, array_offset;
                                zend_brk_cont_element *jmp_to;
 
-                               nest_levels = Z_LVAL(op_array->literals[opline->op2.constant].constant);
+                               nest_levels = Z_LVAL(op_array->literals[opline->op2.constant]);
                                array_offset = opline->op1.opline_num;
                                do {
                                        jmp_to = &op_array->brk_cont_array[array_offset];
@@ -650,9 +650,9 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC)
                                break;
                        }
                        case ZEND_GOTO:
-                               if (Z_TYPE(op_array->literals[opline->op2.constant].constant) != IS_LONG) {
+                               if (Z_TYPE(op_array->literals[opline->op2.constant]) != IS_LONG) {
                                        zend_uint num = opline->op2.constant;
-                                       opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
+                                       opline->op2.zv = &op_array->literals[opline->op2.constant];
                                        zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC);
                                        opline->op2.constant = num;                                     
                                }
@@ -695,19 +695,19 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
                CG(context).opcodes_size = op_array->last;
        }
        if (!(op_array->fn_flags & ZEND_ACC_INTERACTIVE) && CG(context).literals_size != op_array->last_literal) {
-               op_array->literals = (zend_literal*)erealloc(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
+               op_array->literals = (zval*)erealloc(op_array->literals, sizeof(zval) * op_array->last_literal);
                CG(context).literals_size = op_array->last_literal;
        }
        opline = op_array->opcodes;
        end = opline + op_array->last;
        while (opline < end) {
                if (opline->op1_type == IS_CONST) {
-                       opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
+                       opline->op1.zv = &op_array->literals[opline->op1.constant];
                } else if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
                        opline->op1.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->op1.var);
                }
                if (opline->op2_type == IS_CONST) {
-                       opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
+                       opline->op2.zv = &op_array->literals[opline->op2.constant];
                } else if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
                        opline->op2.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->op2.var);
                }

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index 6b35b2af9b27776d181cd44b724821f6acba842c..0142e53c4044f9d7536ba5aa13e503672112ae81 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -118,6 +118,7 @@ struct _zval_struct {
                zend_uint     var_flags;
                zend_uint     next;                 /* hash collision chain */
                zend_uint     str_offset;           /* string offset */
+               zend_uint     cache_slot;           /* literal cache slot */
        } u2;
 };
 
@@ -237,6 +238,9 @@ static inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_NEXT(zval)                           (zval).u2.next
 #define Z_NEXT_P(zval_p)                       Z_NEXT(*(zval_p))
 
+#define Z_CACHE_SLOT(zval)                     (zval).u2.cache_slot
+#define Z_CACHE_SLOT_P(zval_p)         Z_CACHE_SLOT(*(zval_p))
+
 #define Z_COUNTED(zval)                                (zval).value.counted
 #define Z_COUNTED_P(zval_p)                    Z_COUNTED(*(zval_p))
 

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 0672657a35fa2e4f8368a98a34c5f2d214b5b003..73006119711b0013e8875d5850a9aff55ef8d945 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -356,7 +356,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -374,7 +374,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -395,7 +395,7 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -715,7 +715,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -731,7 +731,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -746,7 +746,7 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -805,7 +805,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -820,7 +820,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -836,7 +836,7 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -1104,10 +1104,10 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
                zend_class_entry *ce;
 
                if (OP2_TYPE == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (OP1_TYPE != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -1116,12 +1116,12 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((OP1_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                FREE_OP1();
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -1381,7 +1381,7 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -1414,7 +1414,7 @@ ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1438,7 +1438,7 @@ ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1467,7 +1467,7 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -1497,7 +1497,7 @@ ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                FREE_OP2();
                if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1523,7 +1523,7 @@ ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        FREE_OP2();
        if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -1569,7 +1569,7 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
        if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        FREE_OP2();
        FREE_OP1_VAR_PTR();
        /* assign_obj has two opcodes! */
@@ -1597,7 +1597,7 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
                zend_free_op free_op2;
                zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                FREE_OP2();
        } else {
                zend_free_op free_op2, free_op_data1, free_op_data2;
@@ -2312,11 +2312,11 @@ ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
                zval *class_name = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
 
                if (OP2_TYPE == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-                               CACHE_PTR(opline->op2.literal->cache_slot, Z_CE_P(EX_VAR(opline->result.var)));
+                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), Z_CE_P(EX_VAR(opline->result.var)));
                        }
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
@@ -2362,7 +2362,7 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (OP2_TYPE != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -2370,7 +2370,7 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -2378,7 +2378,7 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -2417,17 +2417,17 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 
        if (OP1_TYPE == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -2442,11 +2442,11 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 
        if (OP1_TYPE == IS_CONST &&
            OP2_TYPE == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (OP1_TYPE != IS_CONST &&
                   OP2_TYPE == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (OP2_TYPE != IS_UNUSED) {
                zend_free_op free_op2;
@@ -2464,7 +2464,7 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -2473,9 +2473,9 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (OP1_TYPE == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (OP2_TYPE != IS_CONST) {
@@ -2527,15 +2527,15 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
        call_slot *call = EX(call_slots) + opline->result.num;
 
        if (OP2_TYPE == IS_CONST) {
-               function_name_ptr = function_name = (zval*)(opline->op2.literal+1);
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+               function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
 
                call->object = NULL;
@@ -2672,25 +2672,25 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
 {
        USE_OPLINE
-       zend_literal *func_name;
+       zval *func_name;
        zval *func;
        call_slot *call = EX(call_slots) + opline->result.num;
 
-       func_name = opline->op2.literal + 1;
-       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-       } else if ((func = zend_hash_find(EG(function_table), Z_STR(func_name->constant))) == NULL) {
+       func_name = opline->op2.zv + 1;
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+       } else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) {
                func_name++;
-               if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR(func_name->constant))) == NULL)) {
+               if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
        } else {
                call->fbc = Z_FUNC_P(func);
-               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
        }
 
        call->object = NULL;
@@ -2716,14 +2716,14 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, CONST, ANY)
        zval *func;
        call_slot *call = EX(call_slots) + opline->op2.num;
 
-       if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-               EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+               EX(function_state).function = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
        } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(fname))) == NULL)) {
            SAVE_OPLINE();
                zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(fname));
        } else {
                EX(function_state).function = Z_FUNC_P(func);
-               CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), EX(function_state).function);
        }
 
        call->fbc = EX(function_state).function;
@@ -2881,12 +2881,12 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
                ZEND_VM_CONTINUE(); /* CHECK_ME */
        }
-       if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-               catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+               catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
        } else {
-               catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
+               catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
 
-               CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce);
        }
        ce = zend_get_class_entry(EG(exception) TSRMLS_CC);
 
@@ -3539,9 +3539,9 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
                zend_constant *c;
                zval *retval;
 
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       c = CACHED_PTR(opline->op2.literal->cache_slot);
-               } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+               } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
                        if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
                                char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
                                if(!actual) {
@@ -3558,7 +3558,7 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
                                zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
                        }
                } else {
-                       CACHE_PTR(opline->op2.literal->cache_slot, c);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
                }
                retval = EX_VAR(opline->result.var);
                ZVAL_DUP(retval, &c->value);
@@ -3570,26 +3570,26 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
                zval *value;
 
                if (OP1_TYPE == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               value = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
-                       } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op1.literal->cache_slot);
+                       } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        HANDLE_EXCEPTION();
                                }
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                                }
-                               CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op1.var));
-                       if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
+                       if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
@@ -3608,9 +3608,9 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
                                EG(scope) = old_scope;
                        }
                        if (OP1_TYPE == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, value);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
                        }
                        ZVAL_DUP(EX_VAR(opline->result.var), value);
                } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
@@ -3948,10 +3948,10 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
                zend_class_entry *ce;
 
                if (OP2_TYPE == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (OP1_TYPE != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -3964,12 +3964,12 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((OP1_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -4096,7 +4096,7 @@ ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -4447,20 +4447,20 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
                        zend_class_entry *ce;
 
                        if (OP2_TYPE == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((OP1_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -4555,7 +4555,7 @@ ZEND_VM_C_LABEL(str_index_prop):
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -4940,15 +4940,15 @@ ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
        zend_class_entry *iface;
 
        SAVE_OPLINE();
-       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-               iface = CACHED_PTR(opline->op2.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else {
-               iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
+               iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
                if (UNEXPECTED(iface == NULL)) {
                        CHECK_EXCEPTION();
                        ZEND_VM_NEXT_OPCODE();
                }
-               CACHE_PTR(opline->op2.literal->cache_slot, iface);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface);
        }
 
        if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
@@ -4967,11 +4967,11 @@ ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
        zend_class_entry *trait;
 
        SAVE_OPLINE();
-       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-               trait = CACHED_PTR(opline->op2.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else {
                trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv),
-                                                opline->op2.literal + 1,
+                                                opline->op2.zv + 1,
                                                 opline->extended_value TSRMLS_CC);
                if (UNEXPECTED(trait == NULL)) {
                        CHECK_EXCEPTION();
@@ -4980,7 +4980,7 @@ ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
                if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
                        zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val);
                }
-               CACHE_PTR(opline->op2.literal->cache_slot, trait);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait);
        }
 
        zend_do_implement_trait(ce, trait TSRMLS_CC);

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index e0b002a16fb13a0b76bd6eb2edf7395af004d2c9..8b00fb5b6ba9bbdba5a67999ab978d2a02d81cce 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -1113,11 +1113,11 @@ static int ZEND_FASTCALL  ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zend_class_entry *trait;
 
        SAVE_OPLINE();
-       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-               trait = CACHED_PTR(opline->op2.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else {
                trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv),
-                                                opline->op2.literal + 1,
+                                                opline->op2.zv + 1,
                                                 opline->extended_value TSRMLS_CC);
                if (UNEXPECTED(trait == NULL)) {
                        CHECK_EXCEPTION();
@@ -1126,7 +1126,7 @@ static int ZEND_FASTCALL  ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
                if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
                        zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val);
                }
-               CACHE_PTR(opline->op2.literal->cache_slot, trait);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait);
        }
 
        zend_do_implement_trait(ce, trait TSRMLS_CC);
@@ -1383,11 +1383,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
                zval *class_name = opline->op2.zv;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-                               CACHE_PTR(opline->op2.literal->cache_slot, Z_CE_P(EX_VAR(opline->result.var)));
+                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), Z_CE_P(EX_VAR(opline->result.var)));
                        }
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
@@ -1412,15 +1412,15 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
        call_slot *call = EX(call_slots) + opline->result.num;
 
        if (IS_CONST == IS_CONST) {
-               function_name_ptr = function_name = (zval*)(opline->op2.literal+1);
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+               function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
 
                call->object = NULL;
@@ -1555,25 +1555,25 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
        USE_OPLINE
-       zend_literal *func_name;
+       zval *func_name;
        zval *func;
        call_slot *call = EX(call_slots) + opline->result.num;
 
-       func_name = opline->op2.literal + 1;
-       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-       } else if ((func = zend_hash_find(EG(function_table), Z_STR(func_name->constant))) == NULL) {
+       func_name = opline->op2.zv + 1;
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+       } else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) {
                func_name++;
-               if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR(func_name->constant))) == NULL)) {
+               if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
        } else {
                call->fbc = Z_FUNC_P(func);
-               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
        }
 
        call->object = NULL;
@@ -1675,15 +1675,15 @@ static int ZEND_FASTCALL  ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
        zend_class_entry *iface;
 
        SAVE_OPLINE();
-       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-               iface = CACHED_PTR(opline->op2.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else {
-               iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
+               iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
                if (UNEXPECTED(iface == NULL)) {
                        CHECK_EXCEPTION();
                        ZEND_VM_NEXT_OPCODE();
                }
-               CACHE_PTR(opline->op2.literal->cache_slot, iface);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface);
        }
 
        if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
@@ -1712,11 +1712,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
                zval *class_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
                if (IS_TMP_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-                               CACHE_PTR(opline->op2.literal->cache_slot, Z_CE_P(EX_VAR(opline->result.var)));
+                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), Z_CE_P(EX_VAR(opline->result.var)));
                        }
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
@@ -1742,15 +1742,15 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
        call_slot *call = EX(call_slots) + opline->result.num;
 
        if (IS_TMP_VAR == IS_CONST) {
-               function_name_ptr = function_name = (zval*)(opline->op2.literal+1);
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+               function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
 
                call->object = NULL;
@@ -1901,11 +1901,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
                zval *class_name = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-                               CACHE_PTR(opline->op2.literal->cache_slot, Z_CE_P(EX_VAR(opline->result.var)));
+                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), Z_CE_P(EX_VAR(opline->result.var)));
                        }
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
@@ -1931,15 +1931,15 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
        call_slot *call = EX(call_slots) + opline->result.num;
 
        if (IS_VAR == IS_CONST) {
-               function_name_ptr = function_name = (zval*)(opline->op2.literal+1);
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+               function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
 
                call->object = NULL;
@@ -2090,11 +2090,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL
                zval *class_name = NULL;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-                               CACHE_PTR(opline->op2.literal->cache_slot, Z_CE_P(EX_VAR(opline->result.var)));
+                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), Z_CE_P(EX_VAR(opline->result.var)));
                        }
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
@@ -2129,11 +2129,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
                zval *class_name = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
                if (IS_CV == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-                               CACHE_PTR(opline->op2.literal->cache_slot, Z_CE_P(EX_VAR(opline->result.var)));
+                               Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), Z_CE_P(EX_VAR(opline->result.var)));
                        }
                } else if (Z_TYPE_P(class_name) == IS_OBJECT) {
                        Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
@@ -2158,15 +2158,15 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
        call_slot *call = EX(call_slots) + opline->result.num;
 
        if (IS_CV == IS_CONST) {
-               function_name_ptr = function_name = (zval*)(opline->op2.literal+1);
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+               function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
                        SAVE_OPLINE();
                        zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
                } else {
                        call->fbc = Z_FUNC_P(func);
-                       CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                }
 
                call->object = NULL;
@@ -2509,14 +2509,14 @@ static int ZEND_FASTCALL  ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        zval *func;
        call_slot *call = EX(call_slots) + opline->op2.num;
 
-       if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-               EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+               EX(function_state).function = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
        } else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(fname))) == NULL)) {
            SAVE_OPLINE();
                zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(fname));
        } else {
                EX(function_state).function = Z_FUNC_P(func);
-               CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), EX(function_state).function);
        }
 
        call->fbc = EX(function_state).function;
@@ -3528,10 +3528,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_CONST != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -3540,12 +3540,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
 
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -3701,17 +3701,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 
        if (IS_CONST == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -3726,11 +3726,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 
        if (IS_CONST == IS_CONST &&
            IS_CONST == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_CONST != IS_CONST &&
                   IS_CONST == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_CONST != IS_UNUSED) {
 
@@ -3748,7 +3748,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -3757,9 +3757,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_CONST == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_CONST != IS_CONST) {
@@ -3828,9 +3828,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
                zend_constant *c;
                zval *retval;
 
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       c = CACHED_PTR(opline->op2.literal->cache_slot);
-               } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+               } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
                        if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
                                char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
                                if(!actual) {
@@ -3847,7 +3847,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
                                zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
                        }
                } else {
-                       CACHE_PTR(opline->op2.literal->cache_slot, c);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
                }
                retval = EX_VAR(opline->result.var);
                ZVAL_DUP(retval, &c->value);
@@ -3859,26 +3859,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
                zval *value;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               value = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
-                       } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op1.literal->cache_slot);
+                       } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        HANDLE_EXCEPTION();
                                }
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                                }
-                               CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op1.var));
-                       if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
+                       if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
@@ -3897,9 +3897,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
                                EG(scope) = old_scope;
                        }
                        if (IS_CONST == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, value);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
                        }
                        ZVAL_DUP(EX_VAR(opline->result.var), value);
                } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
@@ -4041,10 +4041,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_CONST != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -4057,12 +4057,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -4109,20 +4109,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
                        zend_class_entry *ce;
 
                        if (IS_CONST == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -4627,17 +4627,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
 
        if (IS_CONST == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -4652,11 +4652,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
 
        if (IS_CONST == IS_CONST &&
            IS_TMP_VAR == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_CONST != IS_CONST &&
                   IS_TMP_VAR == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
@@ -4674,7 +4674,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -4683,9 +4683,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_CONST == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_TMP_VAR != IS_CONST) {
@@ -5266,10 +5266,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_CONST != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -5278,12 +5278,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
 
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -5417,17 +5417,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
 
        if (IS_CONST == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -5442,11 +5442,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
 
        if (IS_CONST == IS_CONST &&
            IS_VAR == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_CONST != IS_CONST &&
                   IS_VAR == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
@@ -5464,7 +5464,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -5473,9 +5473,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_CONST == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_VAR != IS_CONST) {
@@ -5662,10 +5662,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_CONST != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -5678,12 +5678,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -5730,20 +5730,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
                        zend_class_entry *ce;
 
                        if (IS_VAR == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -5931,10 +5931,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_CONST != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -5943,12 +5943,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
 
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -6065,17 +6065,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 
        if (IS_CONST == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -6090,11 +6090,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 
        if (IS_CONST == IS_CONST &&
            IS_UNUSED == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_CONST != IS_CONST &&
                   IS_UNUSED == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_UNUSED != IS_UNUSED) {
 
@@ -6112,7 +6112,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -6121,9 +6121,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_CONST == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_UNUSED != IS_CONST) {
@@ -6294,10 +6294,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_CONST != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -6310,12 +6310,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -6362,20 +6362,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
                        zend_class_entry *ce;
 
                        if (IS_UNUSED == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -6862,17 +6862,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
 
        if (IS_CONST == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -6887,11 +6887,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
 
        if (IS_CONST == IS_CONST &&
            IS_CV == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_CONST != IS_CONST &&
                   IS_CV == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_CV != IS_UNUSED) {
 
@@ -6909,7 +6909,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -6918,9 +6918,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_CONST == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_CV != IS_CONST) {
@@ -6978,12 +6978,12 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
                ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
                ZEND_VM_CONTINUE(); /* CHECK_ME */
        }
-       if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-               catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
+       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+               catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
        } else {
-               catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
+               catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
 
-               CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
+               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce);
        }
        ce = zend_get_class_entry(EG(exception) TSRMLS_CC);
 
@@ -8522,10 +8522,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_TMP_VAR != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -8534,12 +8534,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                zval_dtor(free_op1.var);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -8749,7 +8749,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CONST != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -8757,7 +8757,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -8765,7 +8765,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -8932,10 +8932,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -8948,12 +8948,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -9000,20 +9000,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
                        zend_class_entry *ce;
 
                        if (IS_CONST == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -9542,7 +9542,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_TMP_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -9550,7 +9550,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -9558,7 +9558,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -10121,10 +10121,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_TMP_VAR != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -10133,12 +10133,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                zval_dtor(free_op1.var);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -10332,7 +10332,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -10340,7 +10340,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -10348,7 +10348,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -10517,10 +10517,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -10533,12 +10533,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -10585,20 +10585,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
                        zend_class_entry *ce;
 
                        if (IS_VAR == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -10786,10 +10786,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_TMP_VAR != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -10798,12 +10798,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                zval_dtor(free_op1.var);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -11035,10 +11035,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -11051,12 +11051,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -11103,20 +11103,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
                        zend_class_entry *ce;
 
                        if (IS_UNUSED == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -11644,7 +11644,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CV != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -11652,7 +11652,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -11660,7 +11660,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -13627,7 +13627,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -13645,7 +13645,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -13666,7 +13666,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -13985,7 +13985,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -14001,7 +14001,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -14016,7 +14016,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -14074,7 +14074,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -14089,7 +14089,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -14105,7 +14105,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -14152,10 +14152,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_VAR != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -14164,12 +14164,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -14429,7 +14429,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -14461,7 +14461,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -14485,7 +14485,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -14514,7 +14514,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -14543,7 +14543,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
                if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -14569,7 +14569,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCOD
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -14593,7 +14593,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
        /* assign_obj has two opcodes! */
@@ -14621,7 +14621,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
 
                zval *property_name = opline->op2.zv;
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        } else {
                zend_free_op free_op_data1, free_op_data2;
@@ -14732,7 +14732,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CONST != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -14740,7 +14740,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -14748,7 +14748,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -14786,17 +14786,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
 
        if (IS_VAR == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -14811,11 +14811,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
 
        if (IS_VAR == IS_CONST &&
            IS_CONST == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_VAR != IS_CONST &&
                   IS_CONST == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_CONST != IS_UNUSED) {
 
@@ -14833,7 +14833,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -14842,9 +14842,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_VAR == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_CONST != IS_CONST) {
@@ -14913,9 +14913,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
                zend_constant *c;
                zval *retval;
 
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       c = CACHED_PTR(opline->op2.literal->cache_slot);
-               } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+               } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
                        if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
                                char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
                                if(!actual) {
@@ -14932,7 +14932,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
                                zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
                        }
                } else {
-                       CACHE_PTR(opline->op2.literal->cache_slot, c);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
                }
                retval = EX_VAR(opline->result.var);
                ZVAL_DUP(retval, &c->value);
@@ -14944,26 +14944,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
                zval *value;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               value = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
-                       } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op1.literal->cache_slot);
+                       } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        HANDLE_EXCEPTION();
                                }
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                                }
-                               CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op1.var));
-                       if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
+                       if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
@@ -14982,9 +14982,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
                                EG(scope) = old_scope;
                        }
                        if (IS_VAR == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, value);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
                        }
                        ZVAL_DUP(EX_VAR(opline->result.var), value);
                } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
@@ -15126,10 +15126,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_VAR != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -15142,12 +15142,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -15274,7 +15274,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -15316,20 +15316,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
                        zend_class_entry *ce;
 
                        if (IS_CONST == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -15424,7 +15424,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -15920,7 +15920,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -15938,7 +15938,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -15959,7 +15959,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -16279,7 +16279,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t i
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -16295,7 +16295,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t i
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -16310,7 +16310,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t i
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -16369,7 +16369,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -16384,7 +16384,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -16400,7 +16400,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -16579,7 +16579,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -16612,7 +16612,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -16636,7 +16636,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -16665,7 +16665,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -16695,7 +16695,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO
                if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                zval_dtor(free_op2.var);
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -16721,7 +16721,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -16745,7 +16745,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
        /* assign_obj has two opcodes! */
@@ -16773,7 +16773,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
                zend_free_op free_op2;
                zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                zval_dtor(free_op2.var);
        } else {
                zend_free_op free_op2, free_op_data1, free_op_data2;
@@ -16885,7 +16885,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_TMP_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -16893,7 +16893,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -16901,7 +16901,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -16940,17 +16940,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
 
        if (IS_VAR == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -16965,11 +16965,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
 
        if (IS_VAR == IS_CONST &&
            IS_TMP_VAR == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_VAR != IS_CONST &&
                   IS_TMP_VAR == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_TMP_VAR != IS_UNUSED) {
                zend_free_op free_op2;
@@ -16987,7 +16987,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -16996,9 +16996,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_VAR == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_TMP_VAR != IS_CONST) {
@@ -17261,7 +17261,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -17332,7 +17332,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -17829,7 +17829,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -17847,7 +17847,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -17868,7 +17868,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -18188,7 +18188,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t i
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -18204,7 +18204,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t i
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -18219,7 +18219,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t i
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -18278,7 +18278,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -18293,7 +18293,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -18309,7 +18309,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -18357,10 +18357,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_VAR != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -18369,12 +18369,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -18634,7 +18634,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -18667,7 +18667,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18691,7 +18691,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18720,7 +18720,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -18750,7 +18750,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO
                if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op2.var);
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18776,7 +18776,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -18800,7 +18800,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
        /* assign_obj has two opcodes! */
@@ -18828,7 +18828,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
                zend_free_op free_op2;
                zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op2.var);
        } else {
                zend_free_op free_op2, free_op_data1, free_op_data2;
@@ -19004,7 +19004,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -19012,7 +19012,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -19020,7 +19020,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -19059,17 +19059,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
 
        if (IS_VAR == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -19084,11 +19084,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
 
        if (IS_VAR == IS_CONST &&
            IS_VAR == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_VAR != IS_CONST &&
                   IS_VAR == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_VAR != IS_UNUSED) {
                zend_free_op free_op2;
@@ -19106,7 +19106,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -19115,9 +19115,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_VAR == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_VAR != IS_CONST) {
@@ -19304,10 +19304,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_VAR != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -19320,12 +19320,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -19452,7 +19452,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -19494,20 +19494,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
                        zend_class_entry *ce;
 
                        if (IS_VAR == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -19602,7 +19602,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -19823,7 +19823,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -19841,7 +19841,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -19862,7 +19862,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -20170,10 +20170,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_VAR != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -20182,12 +20182,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -20392,7 +20392,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
 
                zval *property_name = NULL;
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        } else {
                zend_free_op free_op_data1, free_op_data2;
@@ -20447,17 +20447,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
 
        if (IS_VAR == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -20472,11 +20472,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
 
        if (IS_VAR == IS_CONST &&
            IS_UNUSED == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_VAR != IS_CONST &&
                   IS_UNUSED == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_UNUSED != IS_UNUSED) {
 
@@ -20494,7 +20494,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -20503,9 +20503,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_VAR == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_UNUSED != IS_CONST) {
@@ -20676,10 +20676,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_VAR != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -20692,12 +20692,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -20744,20 +20744,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
                        zend_class_entry *ce;
 
                        if (IS_UNUSED == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -21246,7 +21246,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -21264,7 +21264,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -21285,7 +21285,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -21604,7 +21604,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t in
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -21620,7 +21620,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t in
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -21635,7 +21635,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t in
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -21693,7 +21693,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -21708,7 +21708,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -21724,7 +21724,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -21902,7 +21902,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -21934,7 +21934,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -21958,7 +21958,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -21987,7 +21987,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -22016,7 +22016,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
                if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
                if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -22042,7 +22042,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_H
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
        if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -22066,7 +22066,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
        if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
        /* assign_obj has two opcodes! */
@@ -22094,7 +22094,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 
                zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        } else {
                zend_free_op free_op_data1, free_op_data2;
@@ -22267,7 +22267,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CV != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -22275,7 +22275,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -22283,7 +22283,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -22321,17 +22321,17 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
 
        if (IS_VAR == IS_CONST) {
                /* no function found. try a static method in class */
-               if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                       ce = CACHED_PTR(opline->op1.literal->cache_slot);
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                } else {
-                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                        if (UNEXPECTED(EG(exception) != NULL)) {
                                HANDLE_EXCEPTION();
                        }
                        if (UNEXPECTED(ce == NULL)) {
                                zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                        }
-                       CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                }
                call->called_scope = ce;
        } else {
@@ -22346,11 +22346,11 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
 
        if (IS_VAR == IS_CONST &&
            IS_CV == IS_CONST &&
-           CACHED_PTR(opline->op2.literal->cache_slot)) {
-               call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+           CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+               call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
        } else if (IS_VAR != IS_CONST &&
                   IS_CV == IS_CONST &&
-                  (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+                  (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
                /* do nothing */
        } else if (IS_CV != IS_UNUSED) {
 
@@ -22368,7 +22368,7 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
                if (ce->get_static_method) {
                        call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
                } else {
-                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                }
                if (UNEXPECTED(call->fbc == NULL)) {
                        zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
@@ -22377,9 +22377,9 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
                    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
                        if (IS_VAR == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, call->fbc);
                        }
                }
                if (IS_CV != IS_CONST) {
@@ -22641,7 +22641,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -22712,7 +22712,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -23012,7 +23012,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -23030,7 +23030,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -23051,7 +23051,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -23369,7 +23369,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -23385,7 +23385,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -23400,7 +23400,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -23458,7 +23458,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -23473,7 +23473,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -23489,7 +23489,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -23533,7 +23533,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -23565,7 +23565,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -23589,7 +23589,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -23618,7 +23618,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -23647,7 +23647,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND
                if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
                if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -23673,7 +23673,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OP
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -23697,7 +23697,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
 
        /* assign_obj has two opcodes! */
@@ -23771,7 +23771,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CONST != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -23779,7 +23779,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -23787,7 +23787,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -23822,9 +23822,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
                zend_constant *c;
                zval *retval;
 
-               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                       c = CACHED_PTR(opline->op2.literal->cache_slot);
-               } else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                       c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+               } else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
                        if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
                                char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
                                if(!actual) {
@@ -23841,7 +23841,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
                                zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
                        }
                } else {
-                       CACHE_PTR(opline->op2.literal->cache_slot, c);
+                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
                }
                retval = EX_VAR(opline->result.var);
                ZVAL_DUP(retval, &c->value);
@@ -23853,26 +23853,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
                zval *value;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               value = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
-                       } else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op1.literal->cache_slot);
+                       } else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        HANDLE_EXCEPTION();
                                }
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
                                }
-                               CACHE_PTR(opline->op1.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op1.var));
-                       if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
+                       if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
                                ZVAL_DUP(EX_VAR(opline->result.var), value);
                                CHECK_EXCEPTION();
                                ZEND_VM_NEXT_OPCODE();
@@ -23891,9 +23891,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
                                EG(scope) = old_scope;
                        }
                        if (IS_UNUSED == IS_CONST) {
-                               CACHE_PTR(opline->op2.literal->cache_slot, value);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
                        } else {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
                        }
                        ZVAL_DUP(EX_VAR(opline->result.var), value);
                } else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
@@ -24034,7 +24034,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -24105,7 +24105,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -24324,7 +24324,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -24342,7 +24342,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -24363,7 +24363,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -24682,7 +24682,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -24698,7 +24698,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -24713,7 +24713,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -24772,7 +24772,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -24787,7 +24787,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -24803,7 +24803,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -24848,7 +24848,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -24881,7 +24881,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_H
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -24905,7 +24905,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -24934,7 +24934,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -24964,7 +24964,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_O
                if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                zval_dtor(free_op2.var);
                if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -24990,7 +24990,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCO
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -25014,7 +25014,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HA
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        zval_dtor(free_op2.var);
 
        /* assign_obj has two opcodes! */
@@ -25094,7 +25094,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_TMP_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -25102,7 +25102,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -25110,7 +25110,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -25262,7 +25262,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -25333,7 +25333,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -25553,7 +25553,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -25571,7 +25571,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -25592,7 +25592,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -25911,7 +25911,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -25927,7 +25927,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -25942,7 +25942,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -26001,7 +26001,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -26016,7 +26016,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -26032,7 +26032,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -26077,7 +26077,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -26110,7 +26110,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_H
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -26134,7 +26134,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -26163,7 +26163,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -26193,7 +26193,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_O
                if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op2.var);
                if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -26219,7 +26219,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCO
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -26243,7 +26243,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HA
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
 
        /* assign_obj has two opcodes! */
@@ -26323,7 +26323,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -26331,7 +26331,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -26339,7 +26339,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -26491,7 +26491,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -26562,7 +26562,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -26782,7 +26782,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -26800,7 +26800,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -26821,7 +26821,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -27278,7 +27278,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -27296,7 +27296,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -27317,7 +27317,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -27635,7 +27635,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -27651,7 +27651,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -27666,7 +27666,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -27724,7 +27724,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -27739,7 +27739,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -27755,7 +27755,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -27799,7 +27799,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -27831,7 +27831,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -27855,7 +27855,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -27884,7 +27884,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -27913,7 +27913,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OP
                if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
                if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -27939,7 +27939,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCOD
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
        if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -27963,7 +27963,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
        if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
 
        /* assign_obj has two opcodes! */
@@ -28042,7 +28042,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CV != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -28050,7 +28050,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -28058,7 +28058,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -28209,7 +28209,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -28280,7 +28280,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -30001,7 +30001,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -30019,7 +30019,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -30040,7 +30040,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -30358,7 +30358,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -30374,7 +30374,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -30389,7 +30389,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -30447,7 +30447,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -30462,7 +30462,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -30478,7 +30478,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -30525,10 +30525,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_CV != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -30537,12 +30537,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
 
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -30802,7 +30802,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -30834,7 +30834,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -30858,7 +30858,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -30887,7 +30887,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -30916,7 +30916,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
                if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -30942,7 +30942,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -30966,7 +30966,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
 
        /* assign_obj has two opcodes! */
@@ -30994,7 +30994,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 
                zval *property_name = opline->op2.zv;
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        } else {
                zend_free_op free_op_data1, free_op_data2;
@@ -31105,7 +31105,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CONST != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -31113,7 +31113,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -31121,7 +31121,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -31288,10 +31288,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
                zend_class_entry *ce;
 
                if (IS_CONST == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_CV != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -31304,12 +31304,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -31436,7 +31436,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -31478,20 +31478,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
                        zend_class_entry *ce;
 
                        if (IS_CONST == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -31586,7 +31586,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -32081,7 +32081,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -32099,7 +32099,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -32120,7 +32120,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -32439,7 +32439,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t in
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -32455,7 +32455,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t in
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -32470,7 +32470,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t in
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -32529,7 +32529,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -32544,7 +32544,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -32560,7 +32560,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -32739,7 +32739,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -32772,7 +32772,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -32796,7 +32796,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -32825,7 +32825,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -32855,7 +32855,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD
                if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                zval_dtor(free_op2.var);
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -32881,7 +32881,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_H
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        zval_dtor(free_op2.var);
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -32905,7 +32905,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        zval_dtor(free_op2.var);
 
        /* assign_obj has two opcodes! */
@@ -32933,7 +32933,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
                zend_free_op free_op2;
                zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                zval_dtor(free_op2.var);
        } else {
                zend_free_op free_op2, free_op_data1, free_op_data2;
@@ -33045,7 +33045,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_TMP_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -33053,7 +33053,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -33061,7 +33061,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -33306,7 +33306,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -33377,7 +33377,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -33873,7 +33873,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -33891,7 +33891,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -33912,7 +33912,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -34231,7 +34231,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t in
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -34247,7 +34247,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t in
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -34262,7 +34262,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t in
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -34321,7 +34321,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -34336,7 +34336,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -34352,7 +34352,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -34400,10 +34400,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_CV != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -34412,12 +34412,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
 
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -34677,7 +34677,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -34710,7 +34710,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -34734,7 +34734,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -34763,7 +34763,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -34793,7 +34793,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD
                if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op2.var);
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -34819,7 +34819,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_H
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -34843,7 +34843,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op2.var);
 
        /* assign_obj has two opcodes! */
@@ -34871,7 +34871,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
                zend_free_op free_op2;
                zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op2.var);
        } else {
                zend_free_op free_op2, free_op_data1, free_op_data2;
@@ -35046,7 +35046,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_VAR != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -35054,7 +35054,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -35062,7 +35062,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -35231,10 +35231,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
                zend_class_entry *ce;
 
                if (IS_VAR == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_CV != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -35247,12 +35247,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -35379,7 +35379,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -35421,20 +35421,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
                        zend_class_entry *ce;
 
                        if (IS_VAR == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -35529,7 +35529,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;
@@ -35749,7 +35749,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -35767,7 +35767,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -35788,7 +35788,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -36095,10 +36095,10 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(ce == NULL)) {
                                        if (IS_CV != IS_CONST) {
                                                zval_dtor(&tmp_varname);
@@ -36107,12 +36107,12 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
                                        CHECK_EXCEPTION();
                                        ZEND_VM_NEXT_OPCODE();
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
 
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
@@ -36317,7 +36317,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
 
                zval *property_name = NULL;
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        } else {
                zend_free_op free_op_data1, free_op_data2;
@@ -36487,10 +36487,10 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
                zend_class_entry *ce;
 
                if (IS_UNUSED == IS_CONST) {
-                       if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                               ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                       if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                               ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                        } else {
-                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                               ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                if (UNEXPECTED(EG(exception) != NULL)) {
                                        if (IS_CV != IS_CONST && tmp_is_dup) {
                                                zval_dtor(&tmp);
@@ -36503,12 +36503,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
                                if (UNEXPECTED(ce == NULL)) {
                                        zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
                                }
-                               CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                               CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                        }
                } else {
                        ce = Z_CE_P(EX_VAR(opline->op2.var));
                }
-               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+               zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
        } else {
                target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
                zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
@@ -36555,20 +36555,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
                        zend_class_entry *ce;
 
                        if (IS_UNUSED == IS_CONST) {
-                               if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-                                       ce = CACHED_PTR(opline->op2.literal->cache_slot);
+                               if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+                                       ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
                                } else {
-                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+                                       ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
                                        if (UNEXPECTED(ce == NULL)) {
                                                CHECK_EXCEPTION();
                                                ZEND_VM_NEXT_OPCODE();
                                        }
-                                       CACHE_PTR(opline->op2.literal->cache_slot, ce);
+                                       CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
                                }
                        } else {
                                ce = Z_CE_P(EX_VAR(opline->op2.var));
                        }
-                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+                       value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op1.zv) : -1) TSRMLS_CC);
                        if (!value) {
                                isset = 0;
                        }
@@ -37038,7 +37038,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
                /* here we are sure we are dealing with an object */
                if (opline->extended_value == ZEND_ASSIGN_OBJ
                        && Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                                SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -37056,7 +37056,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
 
                        if (opline->extended_value == ZEND_ASSIGN_OBJ) {
                                if (Z_OBJ_HT_P(object)->read_property) {
-                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                                       z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                                }
                        } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                if (Z_OBJ_HT_P(object)->read_dimension) {
@@ -37077,7 +37077,7 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
                                SEPARATE_ZVAL_IF_NOT_REF(z);
                                binary_op(z, z, value TSRMLS_CC);
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                                } else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
                                        Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
                                }
@@ -37395,7 +37395,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
@@ -37411,7 +37411,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc
                zval rv;
 
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
                                zval rv;
@@ -37426,7 +37426,7 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc
                        SEPARATE_ZVAL_IF_NOT_REF(z);
                        incdec_op(z);
                        ZVAL_COPY_VALUE(retval, z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        SELECTIVE_PZVAL_LOCK(retval, opline);
                        zval_ptr_dtor(z);
                } else {
@@ -37484,7 +37484,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in
        /* here we are sure we are dealing with an object */
 
        if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                if (zptr != NULL) {                     /* NULL means no success in getting PTR */
                        have_get_ptr = 1;
                        SEPARATE_ZVAL_IF_NOT_REF(zptr);
@@ -37499,7 +37499,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in
        if (!have_get_ptr) {
                if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
                        zval rv;
-                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), &rv TSRMLS_CC);
+                       zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), &rv TSRMLS_CC);
                        zval z_copy;
 
                        if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
@@ -37515,7 +37515,7 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in
                        ZVAL_DUP(&z_copy, z);
                        incdec_op(&z_copy);
                        if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
-                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        zval_ptr_dtor(&z_copy);
                        zval_ptr_dtor(z);
                } else {
@@ -37693,7 +37693,7 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -37725,7 +37725,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
 
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -37749,7 +37749,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -37778,7 +37778,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
                zval *retval;
 
                /* here we are sure we are dealing with an object */
-               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), EX_VAR(opline->result.var) TSRMLS_CC);
+               retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
                if (retval != EX_VAR(opline->result.var)) {
                        ZVAL_COPY(EX_VAR(opline->result.var), retval);
@@ -37807,7 +37807,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
                if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                        zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
                }
-               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W, 0 TSRMLS_CC);
+               zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
                if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                        EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -37833,7 +37833,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
        }
-       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET, 0 TSRMLS_CC);
+       zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
        if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
                EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
@@ -37857,7 +37857,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
        if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
                zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
        }
-       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+       zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
 
        /* assign_obj has two opcodes! */
@@ -37885,7 +37885,7 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 
                zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+               zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
 
        } else {
                zend_free_op free_op_data1, free_op_data2;
@@ -38057,7 +38057,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
                call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
                if (IS_CV != IS_CONST ||
-                   (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
+                   (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope)) == NULL) {
                    zend_object *object = call->object;
 
                        if (UNEXPECTED(object->handlers->get_method == NULL)) {
@@ -38065,7 +38065,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
                        }
 
                        /* First, locate the function. */
-                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+                       call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
                        if (UNEXPECTED(call->fbc == NULL)) {
                                zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
                        }
@@ -38073,7 +38073,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
                            EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
                            EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
                            EXPECTED(call->object == object)) {
-                               CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+                               CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->called_scope, call->fbc);
                        }
                }
        } else {
@@ -38316,7 +38316,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
        ZVAL_DEREF(container);
        if (Z_TYPE_P(container) == IS_OBJECT) {
                if (Z_OBJ_HT_P(container)->unset_property) {
-                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                       Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                } else {
                        zend_error(E_NOTICE, "Trying to unset property of non-object");
                }
@@ -38387,7 +38387,7 @@ str_index_prop:
        } else if (Z_TYPE_P(container) == IS_OBJECT) {
                if (prop_dim) {
                        if (Z_OBJ_HT_P(container)->has_property) {
-                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+                               result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(opline->op2.zv) : -1) TSRMLS_CC);
                        } else {
                                zend_error(E_NOTICE, "Trying to check property of non-object");
                                result = 0;

diff --git a/ext/date/php_date.c b/ext/date/php_date.c
index 634f08afa73dd98e9a78e98b575ac5bd182aef33..06c131014eb13cfdb146c8ab606f99927e01a647 100644 (file)
--- a/ext/date/php_date.c
+++ b/ext/date/php_date.c
@@ -633,10 +633,10 @@ static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC);
 static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC);
 static HashTable *date_object_get_gc_timezone(zval *object, zval **table, int *n TSRMLS_DC);
 
-zval *date_interval_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC);
-void date_interval_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC);
-static zval *date_period_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC);
-static void date_period_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC);
+zval *date_interval_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC);
+void date_interval_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
+static zval *date_period_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC);
+static void date_period_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
 
 /* {{{ Module struct */
 zend_module_entry date_module_entry = {
@@ -3947,7 +3947,7 @@ static int date_interval_initialize(timelib_rel_time **rt, /*const*/ char *forma
 } /* }}} */
 
 /* {{{ date_interval_read_property */
-zval *date_interval_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC)
+zval *date_interval_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
        php_interval_obj *obj;
        zval *retval;
@@ -3959,13 +3959,13 @@ zval *date_interval_read_property(zval *object, zval *member, int type, const ze
                zval_copy_ctor(&tmp_member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
        obj = Z_PHPINTERVAL_P(object);
 
        if (!obj->initialized) {
-               retval = (zend_get_std_object_handlers())->read_property(object, member, type, key, rv TSRMLS_CC);
+               retval = (zend_get_std_object_handlers())->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
                if (member == &tmp_member) {
                        zval_dtor(member);
                }
@@ -3987,7 +3987,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, const ze
                GET_VALUE_FROM_STRUCT(invert, "invert");
                GET_VALUE_FROM_STRUCT(days, "days");
                /* didn't find any */
-               retval = (zend_get_std_object_handlers())->read_property(object, member, type, key, rv TSRMLS_CC);
+               retval = (zend_get_std_object_handlers())->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 
                if (member == &tmp_member) {
                        zval_dtor(member);
@@ -4013,7 +4013,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, const ze
 /* }}} */
 
 /* {{{ date_interval_write_property */
-void date_interval_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+void date_interval_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
        php_interval_obj *obj;
        zval tmp_member, tmp_value;
@@ -4023,13 +4023,13 @@ void date_interval_write_property(zval *object, zval *member, zval *value, const
                zval_copy_ctor(&tmp_member);
                convert_to_string(&tmp_member);
                member = &tmp_member;
-               key = NULL;
+               cache_slot = -1;
        }
 
        obj = Z_PHPINTERVAL_P(object);
 
        if (!obj->initialized) {
-               (zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
+               (zend_get_std_object_handlers())->write_property(object, member, value, cache_slot TSRMLS_CC);
                if (member == &tmp_member) {
                        zval_dtor(member);
                }
@@ -4051,7 +4051,7 @@ void date_interval_write_property(zval *object, zval *member, zval *value, const
                SET_VALUE_FROM_STRUCT(s, "s");
                SET_VALUE_FROM_STRUCT(invert, "invert");
                /* didn't find any */
-               (zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
+               (zend_get_std_object_handlers())->write_property(object, member, value, cache_slot TSRMLS_CC);
        } while(0);
 
        if (member == &tmp_member) {
@@ -4930,7 +4930,7 @@ PHP_METHOD(DatePeriod, __wakeup)
 /* }}} */
 
 /* {{{ date_period_read_property */
-static zval *date_period_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC)
+static zval *date_period_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
        zval *zv;
        if (type != BP_VAR_IS && type != BP_VAR_R) {
@@ -4939,7 +4939,7 @@ static zval *date_period_read_property(zval *object, zval *member, int type, con
 
        Z_OBJPROP_P(object); /* build properties hash table */
 
-       zv = std_object_handlers.read_property(object, member, type, key, rv TSRMLS_CC);
+       zv = std_object_handlers.read_property(object, member, type, cache_slot, rv TSRMLS_CC);
        if (Z_TYPE_P(zv) == IS_OBJECT && Z_OBJ_HANDLER_P(zv, clone_obj)) {
                /* defensive copy */
 //???          MAKE_STD_ZVAL(zv);
@@ -4951,7 +4951,7 @@ static zval *date_period_read_property(zval *object, zval *member, int type, con
 /* }}} */
 
 /* {{{ date_period_write_property */
-static void date_period_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void date_period_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
        php_error_docref(NULL TSRMLS_CC, E_ERROR, "Writing to DatePeriod properties is unsupported");
 }

diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
index c6856cf66a491fe9e0c27a098c7c5c9b9e85d0c9..c51be7f66c269e0bad4702f6b432f9facc607794 100644 (file)
--- a/ext/dom/php_dom.c
+++ b/ext/dom/php_dom.c
@@ -310,7 +310,7 @@ static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_r
 }
 /* }}} */
 
-static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        dom_object *obj = Z_DOMOBJ_P(object);
        zend_string *member_str = zval_get_string(member TSRMLS_CC);
@@ -318,7 +318,7 @@ static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, cons
 
        if (!obj->prop_handler || !zend_hash_exists(obj->prop_handler, member_str)) {
                zend_object_handlers *std_hnd = zend_get_std_object_handlers();
-               retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
+               retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot TSRMLS_CC);
        }
 
        STR_RELEASE(member_str);
@@ -327,7 +327,7 @@ static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, cons
 /* }}} */
 
 /* {{{ dom_read_property */
-zval *dom_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC)
+zval *dom_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
        dom_object *obj = Z_DOMOBJ_P(object);
        zend_string *member_str = zval_get_string(member TSRMLS_CC);
@@ -349,7 +349,7 @@ zval *dom_read_property(zval *object, zval *member, int type, const zend_literal
                }
        } else {
                zend_object_handlers *std_hnd = zend_get_std_object_handlers();
-               retval = std_hnd->read_property(object, member, type, key, rv TSRMLS_CC);
+               retval = std_hnd->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
        }
 
        STR_RELEASE(member_str);
@@ -358,7 +358,7 @@ zval *dom_read_property(zval *object, zval *member, int type, const zend_literal
 /* }}} */
 
 /* {{{ dom_write_property */
-void dom_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+void dom_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
        dom_object *obj = Z_DOMOBJ_P(object);
        zend_string *member_str = zval_get_string(member TSRMLS_CC);
@@ -371,7 +371,7 @@ void dom_write_property(zval *object, zval *member, zval *value, const zend_lite
                hnd->write_func(obj, value TSRMLS_CC);
        } else {
                zend_object_handlers *std_hnd = zend_get_std_object_handlers();
-               std_hnd->write_property(object, member, value, key TSRMLS_CC);
+               std_hnd->write_property(object, member, value, cache_slot TSRMLS_CC);
        }
 
        STR_RELEASE(member_str);
@@ -379,7 +379,7 @@ void dom_write_property(zval *object, zval *member, zval *value, const zend_lite
 /* }}} */
 
 /* {{{ dom_property_exists */
-static int dom_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
+static int dom_property_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)
 {
        dom_object *obj = Z_DOMOBJ_P(object);
        zend_string *member_str = zval_get_string(member TSRMLS_CC);
@@ -404,7 +404,7 @@ static int dom_property_exists(zval *object, zval *member, int check_empty, cons
                }
        } else {
                zend_object_handlers *std_hnd = zend_get_std_object_handlers();
-               retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
+               retval = std_hnd->has_property(object, member, check_empty, cache_slot TSRMLS_CC);
        }
 
        STR_RELEASE(member_str);
@@ -437,7 +437,7 @@ static HashTable* dom_get_debug_info_helper(zval *object, int *is_temp TSRMLS_DC
        ZVAL_STRING(&object_value, "(object value omitted)");
 
        for (zend_hash_internal_pointer_reset_ex(prop_handlers, &pos);
-                       entry = zend_hash_get_current_data_ptr_ex(prop_handlers, &pos);
+                       (entry = zend_hash_get_current_data_ptr_ex(prop_handlers, &pos)) != NULL;
                        zend_hash_move_forward_ex(prop_handlers, &pos)) {
                zval value;
                zend_string *string_key;

diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c
index 1905e661366e2d8af80766087b06be6c65a80ee9..6c3bf41ec3705ccdf991e0b4bcc9b35fdfe82ece 100644 (file)
--- a/ext/opcache/Optimizer/compact_literals.c
+++ b/ext/opcache/Optimizer/compact_literals.c
@@ -63,7 +63,7 @@ static void optimizer_literal_obj_info(literal_info   *info,
         * In general it's also possible to do it for any CV variable as well,
         * but it would require complex dataflow and/or type analysis.
         */
-       if (Z_TYPE(op_array->literals[constant].constant) == IS_STRING &&
+       if (Z_TYPE(op_array->literals[constant]) == IS_STRING &&
            op_type == IS_UNUSED) {
                LITERAL_INFO_OBJ(constant, kind, 1, slots, related, op_array->this_var);
        } else {
@@ -285,10 +285,10 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
                for (i = 0; i < op_array->last_literal; i++) {
                        if (!info[i].flags) {
                                /* unsed literal */
-                               zval_dtor(&op_array->literals[i].constant);
+                               zval_dtor(&op_array->literals[i]);
                                continue;
                        }
-                       switch (Z_TYPE(op_array->literals[i].constant)) {
+                       switch (Z_TYPE(op_array->literals[i])) {
                                case IS_NULL:
                                        if (l_null < 0) {
                                                l_null = j;
@@ -301,7 +301,7 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
                                        map[i] = l_null;
                                        break;
                                case IS_BOOL:
-                                       if (Z_LVAL(op_array->literals[i].constant)) {
+                                       if (Z_LVAL(op_array->literals[i])) {
                                                if (l_true < 0) {
                                                        l_true = j;
                                                        if (i != j) {
@@ -324,11 +324,11 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
                                        }
                                        break;
                                case IS_LONG:
-                                       if ((pos = (int)zend_hash_index_find_ptr(&hash, Z_LVAL(op_array->literals[i].constant))) != 0) {
+                                       if ((pos = (int)zend_hash_index_find_ptr(&hash, Z_LVAL(op_array->literals[i]))) != 0) {
                                                map[i] = pos - 1;
                                        } else {
                                                map[i] = j;
-                                               zend_hash_index_update_ptr(&hash, Z_LVAL(op_array->literals[i].constant), (void*)j + 1);
+                                               zend_hash_index_update_ptr(&hash, Z_LVAL(op_array->literals[i]), (void*)j + 1);
                                                if (i != j) {
                                                        op_array->literals[j] = op_array->literals[i];
                                                        info[j] = info[i];
@@ -337,11 +337,11 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
                                        }
                                        break;
                                case IS_DOUBLE:
-                                       if ((pos = (int)zend_hash_str_find_ptr(&hash, (char*)&Z_DVAL(op_array->literals[i].constant), sizeof(double))) != 0) {
+                                       if ((pos = (int)zend_hash_str_find_ptr(&hash, (char*)&Z_DVAL(op_array->literals[i]), sizeof(double))) != 0) {
                                                map[i] = pos - 1;
                                        } else {
                                                map[i] = j;
-                                               zend_hash_str_add_ptr(&hash, (char*)&Z_DVAL(op_array->literals[i].constant), sizeof(double), (void*)j + 1);
+                                               zend_hash_str_add_ptr(&hash, (char*)&Z_DVAL(op_array->literals[i]), sizeof(double), (void*)j + 1);
                                                if (i != j) {
                                                        op_array->literals[j] = op_array->literals[i];
                                                        info[j] = info[i];
@@ -353,37 +353,37 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
                                case IS_CONSTANT:
                                        if (info[i].flags & LITERAL_MAY_MERGE) {
                                                if (info[i].flags & LITERAL_EX_OBJ) {
-                                                       int key_len = MAX_LENGTH_OF_LONG + sizeof("->") + Z_STRLEN(op_array->literals[i].constant);
+                                                       int key_len = MAX_LENGTH_OF_LONG + sizeof("->") + Z_STRLEN(op_array->literals[i]);
                                                        key = STR_ALLOC(key_len, 0);
-                                                       key->len = snprintf(key->val, key->len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i].constant));
+                                                       key->len = snprintf(key->val, key->len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i]));
                                                } else if (info[i].flags & LITERAL_EX_CLASS) {
                                                        int key_len;
-                                                       zval *class_name = &op_array->literals[(info[i].u.num < i) ? map[info[i].u.num] : info[i].u.num].constant;
-                                                       key_len = Z_STRLEN_P(class_name) + sizeof("::") + Z_STRLEN(op_array->literals[i].constant);
+                                                       zval *class_name = &op_array->literals[(info[i].u.num < i) ? map[info[i].u.num] : info[i].u.num];
+                                                       key_len = Z_STRLEN_P(class_name) + sizeof("::") + Z_STRLEN(op_array->literals[i]);
                                                        key = STR_ALLOC(key_len, 0);
                                                        memcpy(key->val, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
                                                        memcpy(key->val + Z_STRLEN_P(class_name), "::", sizeof("::") - 1);
                                                        memcpy(key->val + Z_STRLEN_P(class_name) + sizeof("::") - 1,
-                                                               Z_STRVAL(op_array->literals[i].constant),
-                                                               Z_STRLEN(op_array->literals[i].constant) + 1);
+                                                               Z_STRVAL(op_array->literals[i]),
+                                                               Z_STRLEN(op_array->literals[i]) + 1);
                                                } else {
-                                                       key = STR_INIT(Z_STRVAL(op_array->literals[i].constant), Z_STRLEN(op_array->literals[i].constant), 0);
+                                                       key = STR_INIT(Z_STRVAL(op_array->literals[i]), Z_STRLEN(op_array->literals[i]), 0);
                                                }
                                                key->h = zend_hash_func(key->val, key->len);
                                                key->h += info[i].flags;
                                        }
                                        if ((info[i].flags & LITERAL_MAY_MERGE) &&
                                                (pos = (int)zend_hash_find_ptr(&hash, key)) != 0 &&
-                                               Z_TYPE(op_array->literals[i].constant) == Z_TYPE(op_array->literals[pos-1].constant) &&
+                                               Z_TYPE(op_array->literals[i]) == Z_TYPE(op_array->literals[pos-1]) &&
                                                info[i].flags == info[pos-1].flags) {
 
                                                STR_RELEASE(key);
                                                map[i] = pos - 1;
-                                               zval_dtor(&op_array->literals[i].constant);
+                                               zval_dtor(&op_array->literals[i]);
                                                n = LITERAL_NUM_RELATED(info[i].flags);
                                                while (n > 1) {
                                                        i++;
-                                                       zval_dtor(&op_array->literals[i].constant);
+                                                       zval_dtor(&op_array->literals[i]);
                                                        n--;
                                                }
                                        } else {
@@ -404,7 +404,7 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 //???                                                  }
 //???                                          }
                                                if (LITERAL_NUM_SLOTS(info[i].flags)) {
-                                                       op_array->literals[j].cache_slot = cache_slots;
+                                                       Z_CACHE_SLOT(op_array->literals[j]) = cache_slots;
                                                        cache_slots += LITERAL_NUM_SLOTS(info[i].flags);
                                                }
                                                j++;

diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c
index d7461b5908cf150a3e01011e440deb4d335cd84a..f9ae14290f57557fe5e3524efd06024c659892f6 100644 (file)
--- a/ext/opcache/Optimizer/optimize_func_calls.c
+++ b/ext/opcache/Optimizer/optimize_func_calls.c
@@ -25,7 +25,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_persistent_script
                        case ZEND_INIT_NS_FCALL_BY_NAME:
                                if (ZEND_OP2_TYPE(opline) == IS_CONST) {
                                        zend_function *func;
-                                       zval *function_name = &op_array->literals[opline->op2.constant + 1].constant;
+                                       zval *function_name = &op_array->literals[opline->op2.constant + 1];
                                        if ((func = zend_hash_find_ptr(&script->function_table,
                                                        Z_STR_P(function_name))) != NULL) {
                                                call_stack[call].func = func;
@@ -53,10 +53,10 @@ static void optimize_func_calls(zend_op_array *op_array, zend_persistent_script
                                        opline->opcode = ZEND_DO_FCALL;
                                        ZEND_OP1_TYPE(opline) = IS_CONST;
                                        opline->op1.constant = fcall->op2.constant + 1;
-                                       op_array->literals[fcall->op2.constant + 1].cache_slot = op_array->literals[fcall->op2.constant].cache_slot;
+                                       Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]);
                                        literal_dtor(&ZEND_OP2_LITERAL(fcall));
                                        if (fcall->opcode == ZEND_INIT_NS_FCALL_BY_NAME) {
-                                               literal_dtor(&op_array->literals[fcall->op2.constant + 2].constant);
+                                               literal_dtor(&op_array->literals[fcall->op2.constant + 2]);
                                        }
                                        MAKE_NOP(fcall);
                                } else if (opline->extended_value == 0 &&
@@ -69,7 +69,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_persistent_script
                                        opline->opcode = ZEND_DO_FCALL;
                                        ZEND_OP1_TYPE(opline) = IS_CONST;
                                        opline->op1.constant = fcall->op2.constant + 1;
-                                       op_array->literals[fcall->op2.constant + 1].cache_slot = op_array->literals[fcall->op2.constant].cache_slot;
+                                       Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]);
                                        literal_dtor(&ZEND_OP2_LITERAL(fcall));
                                        MAKE_NOP(fcall);
                                }

diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c
index c2551df5906c863b1331e2b0eafe82f5c53ab5fd..207b8d0e61d2d2bf62e30c9fd7a9ba0538377687 100644 (file)
--- a/ext/opcache/Optimizer/pass1_5.c
+++ b/ext/opcache/Optimizer/pass1_5.c
@@ -274,7 +274,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
                                                ce = op_array->scope;
                                        } else { 
                                                if ((ce = zend_hash_find_ptr(EG(class_table), 
-                                                               Z_STR(op_array->literals[opline->op1.constant + 1].constant))) == NULL ||
+                                                               Z_STR(op_array->literals[opline->op1.constant + 1]))) == NULL ||
                                                                (ce->type == ZEND_INTERNAL_CLASS &&
                                                                 ce->info.internal.module->type != MODULE_PERSISTENT) ||
                                                                (ce->type == ZEND_USER_CLASS &&

diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index f92c866e413c670fe24810efc0be72b291196e47..0498bcba077599d9b426e1ed0658b94de4a0a88d 100644 (file)
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -109,9 +109,9 @@ int zend_optimizer_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC)
 {
        int i = op_array->last_literal;
        op_array->last_literal++;
-       op_array->literals = (zend_literal*)erealloc(op_array->literals, op_array->last_literal * sizeof(zend_literal));
-       ZVAL_COPY_VALUE(&op_array->literals[i].constant, zv);
-       op_array->literals[i].cache_slot = -1;
+       op_array->literals = (zval*)erealloc(op_array->literals, op_array->last_literal * sizeof(zval));
+       ZVAL_COPY_VALUE(&op_array->literals[i], zv);
+       Z_CACHE_SLOT(op_array->literals[i]) = -1;
 //???  Z_SET_REFCOUNT(op_array->literals[i].constant, 2);
 //???  Z_SET_ISREF(op_array->literals[i].constant);
        return i;
@@ -171,10 +171,10 @@ static void update_op1_const(zend_op_array *op_array,
                                        opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
                                        STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline)));
 //???                                  Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1);
-                                       op_array->literals[opline->op1.constant].cache_slot = op_array->last_cache_slot++;
+                                       Z_CACHE_SLOT(op_array->literals[opline->op1.constant]) = op_array->last_cache_slot++;
                                        zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
                                        zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-                                       STR_HASH_VAL(Z_STR(op_array->literals[opline->op1.constant+1].constant));
+                                       STR_HASH_VAL(Z_STR(op_array->literals[opline->op1.constant+1]));
 //???                                  op_array->literals[opline->op1.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op1.constant+1].constant), Z_STRLEN(op_array->literals[opline->op1.constant+1].constant) + 1);
                                        break;
                                case ZEND_DO_FCALL:
@@ -182,7 +182,7 @@ static void update_op1_const(zend_op_array *op_array,
                                        opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
                                        STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline)));
 //???                                  Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1);
-                                       op_array->literals[opline->op1.constant].cache_slot = op_array->last_cache_slot++;
+                                       Z_CACHE_SLOT(op_array->literals[opline->op1.constant]) = op_array->last_cache_slot++;
                                        break;
                                default:
                                        opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
@@ -223,17 +223,17 @@ static void update_op2_const(zend_op_array *op_array,
                        case ZEND_ISSET_ISEMPTY_VAR:
                        case ZEND_ADD_INTERFACE:
                        case ZEND_ADD_TRAIT:
-                               op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot++;
+                               Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot++;
                                zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
                                zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-                               STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1].constant));
+                               STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1]));
 //???                          op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1);
                                break;
                        case ZEND_INIT_METHOD_CALL:
                        case ZEND_INIT_STATIC_METHOD_CALL:
                                zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
                                zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-                               STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1].constant));
+                               STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1]));
 //???                          op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1);
                                /* break missing intentionally */                                               
                        /*case ZEND_FETCH_CONSTANT:*/
@@ -250,7 +250,7 @@ static void update_op2_const(zend_op_array *op_array,
                        case ZEND_POST_INC_OBJ:
                        case ZEND_POST_DEC_OBJ:
                        case ZEND_ISSET_ISEMPTY_PROP_OBJ:
-                               op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot;
+                               Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot;
                                op_array->last_cache_slot += 2;
                                break;
                        case ZEND_ASSIGN_ADD:
@@ -265,7 +265,7 @@ static void update_op2_const(zend_op_array *op_array,
                        case ZEND_ASSIGN_BW_AND:
                        case ZEND_ASSIGN_BW_XOR:
                                if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-                                       op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot;
+                                       Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot;
                                        op_array->last_cache_slot += 2;
                                }
                                break;
@@ -307,7 +307,7 @@ check_numeric:
                                        if (numeric) {
                                                zval_dtor(val);
                                                ZVAL_LONG(val, index);
-                                               op_array->literals[opline->op2.constant].constant = *val;
+                                               op_array->literals[opline->op2.constant] = *val;
                                }
                                }
                                break;
@@ -488,10 +488,10 @@ static void zend_accel_optimize(zend_op_array           *op_array,
        while (opline < end) {
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
                if (opline->op1_type == IS_CONST) {
-                       opline->op1.constant = opline->op1.literal - op_array->literals;
+                       opline->op1.constant = opline->op1.zv - op_array->literals;
                }
                if (opline->op2_type == IS_CONST) {
-                       opline->op2.constant = opline->op2.literal - op_array->literals;
+                       opline->op2.constant = opline->op2.zv - op_array->literals;
                }
 #endif
                switch (opline->opcode) {
@@ -529,10 +529,10 @@ static void zend_accel_optimize(zend_op_array           *op_array,
        while (opline < end) {
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
                if (opline->op1_type == IS_CONST) {
-                       opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
+                       opline->op1.zv = &op_array->literals[opline->op1.constant];
                }
                if (opline->op2_type == IS_CONST) {
-                       opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
+                       opline->op2.zv = &op_array->literals[opline->op2.constant];
                }
 #endif
                switch (opline->opcode) {

diff --git a/ext/opcache/ZendAccelerator.h b/ext/opcache/ZendAccelerator.h
index 192b2ec6d05e3cc4cd6e3f817a6af014dc4e8595..9db5739a10a93d712b8203e7b5ad259d18ccbb53 100644 (file)
--- a/ext/opcache/ZendAccelerator.h
+++ b/ext/opcache/ZendAccelerator.h
@@ -351,11 +351,11 @@ zend_string *accel_new_interned_string(zend_string *str TSRMLS_DC);
 # define ZEND_OP1_TYPE(opline)         (opline)->op1_type
 # define ZEND_OP1(opline)                      (opline)->op1
 # define ZEND_OP1_CONST(opline)                (*(opline)->op1.zv)
-# define ZEND_OP1_LITERAL(opline)      (op_array)->literals[(opline)->op1.constant].constant
+# define ZEND_OP1_LITERAL(opline)      (op_array)->literals[(opline)->op1.constant]
 # define ZEND_OP2_TYPE(opline)         (opline)->op2_type
 # define ZEND_OP2(opline)                      (opline)->op2
 # define ZEND_OP2_CONST(opline)                (*(opline)->op2.zv)
-# define ZEND_OP2_LITERAL(opline)      (op_array)->literals[(opline)->op2.constant].constant
+# define ZEND_OP2_LITERAL(opline)      (op_array)->literals[(opline)->op2.constant]
 # define ZEND_DONE_PASS_TWO(op_array)  (((op_array)->fn_flags & ZEND_ACC_DONE_PASS_TWO) != 0)
 # define ZEND_CE_FILENAME(ce)                  (ce)->info.user.filename
 # define ZEND_CE_DOC_COMMENT(ce)        (ce)->info.user.doc_comment

diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index eea260d53e41cc9bff5f7bbeed1352cf41edcf7f..ca8835c2edf047896ee027ab1af608a56b4536f3 100644 (file)
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -179,7 +179,7 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
        int has_jmp = 0;
 #endif
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-       zend_literal *orig_literals = NULL;
+       zval *orig_literals = NULL;
 #endif
        
        if (op_array->type != ZEND_USER_FUNCTION) {
@@ -228,12 +228,12 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
                        ZEND_ASSERT(orig_literals != NULL);
                        op_array->literals = orig_literals;
                } else {
-                       zend_literal *p = zend_accel_memdup(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
-                       zend_literal *end = p + op_array->last_literal;
+                       zval *p = zend_accel_memdup(op_array->literals, sizeof(zval) * op_array->last_literal);
+                       zval *end = p + op_array->last_literal;
                        orig_literals = op_array->literals;
                        op_array->literals = p;
                        while (p < end) {
-                               zend_persist_zval(&p->constant TSRMLS_CC);
+                               zend_persist_zval(p TSRMLS_CC);
                                p++;
                        }
                        efree(orig_literals);

diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index b9cf4240c1ba5b7bf950e90321c17355b3417f01..20e6b083c486612be61c757c1ac708beb50b28fa 100644 (file)
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -156,7 +156,6 @@ static uint zend_persist_zval_calc(zval *z TSRMLS_DC)
 
 static uint zend_persist_op_array_calc_ex(zend_op_array *op_array TSRMLS_DC)
 {
-       zend_op *opline, *end;
        START_SIZE();
 
        if (op_array->type != ZEND_USER_FUNCTION) {
@@ -181,11 +180,11 @@ static uint zend_persist_op_array_calc_ex(zend_op_array *op_array TSRMLS_DC)
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
        if (op_array->literals) {
-               zend_literal *p = op_array->literals;
-               zend_literal *end = p + op_array->last_literal;
-               ADD_DUP_SIZE(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
+               zval *p = op_array->literals;
+               zval *end = p + op_array->last_literal;
+               ADD_DUP_SIZE(op_array->literals, sizeof(zval) * op_array->last_literal);
                while (p < end) {
-                       ADD_SIZE(zend_persist_zval_calc(&p->constant TSRMLS_CC));
+                       ADD_SIZE(zend_persist_zval_calc(p TSRMLS_CC));
                        p++;
                }
        }

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index d080b8146766fafb16e7797292b2466fbf062851..d2a6790d6b75a074865f02d5fde1789288375d87 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -44,7 +44,7 @@
 #define reflection_update_property(object, name, value) do { \
                zval member; \
                ZVAL_STRINGL(&member, name, sizeof(name)-1); \
-               zend_std_write_property(object, &member, value, NULL TSRMLS_CC); \
+               zend_std_write_property(object, &member, value, -1 TSRMLS_CC); \
                if (Z_REFCOUNTED_P(value)) Z_DELREF_P(value); \
                zval_ptr_dtor(&member); \
        } while (0)
@@ -3430,7 +3430,7 @@ ZEND_METHOD(reflection_class, getStaticPropertyValue)
        GET_REFLECTION_OBJECT_PTR(ce);
 
        zend_update_class_constants(ce TSRMLS_CC);
-       prop = zend_std_get_static_property(ce, name, 1, NULL TSRMLS_CC);
+       prop = zend_std_get_static_property(ce, name, 1, -1 TSRMLS_CC);
        if (!prop) {
                if (def_value) {
                        RETURN_ZVAL(def_value, 1, 0);
@@ -3463,7 +3463,7 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue)
        GET_REFLECTION_OBJECT_PTR(ce);
 
        zend_update_class_constants(ce TSRMLS_CC);
-       variable_ptr = zend_std_get_static_property(ce, name, 1, NULL TSRMLS_CC);
+       variable_ptr = zend_std_get_static_property(ce, name, 1, -1 TSRMLS_CC);
        if (!variable_ptr) {
                zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
                                "Class %s does not have a property named %s", ce->name->val, name->val);
@@ -3816,7 +3816,7 @@ ZEND_METHOD(reflection_class, hasProperty)
        } else {
                if (Z_TYPE(intern->obj) != IS_UNDEF && Z_OBJ_HANDLER(intern->obj, has_property)) {
                        ZVAL_STR(&property, STR_COPY(name));
-                       if (Z_OBJ_HANDLER(intern->obj, has_property)(&intern->obj, &property, 2, 0 TSRMLS_CC)) {
+                       if (Z_OBJ_HANDLER(intern->obj, has_property)(&intern->obj, &property, 2, -1 TSRMLS_CC)) {
                                zval_ptr_dtor(&property);
                                RETURN_TRUE;
                        }
@@ -6068,7 +6068,7 @@ const zend_function_entry reflection_ext_functions[] = { /* {{{ */
 static zend_object_handlers *zend_std_obj_handlers;
 
 /* {{{ _reflection_write_property */
-static void _reflection_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void _reflection_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
        if ((Z_TYPE_P(member) == IS_STRING)
                && zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member))
@@ -6080,7 +6080,7 @@ static void _reflection_write_property(zval *object, zval *member, zval *value,
        }
        else
        {
-               zend_std_obj_handlers->write_property(object, member, value, key TSRMLS_CC);
+               zend_std_obj_handlers->write_property(object, member, value, cache_slot TSRMLS_CC);
        }
 }
 /* }}} */

diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c
index 95225d14727794951794c06183868bb9c234c11a..5d5d9c6fbc25845218512759cbdc6b4e8eba3f00 100644 (file)
--- a/ext/simplexml/simplexml.c
+++ b/ext/simplexml/simplexml.c
@@ -382,7 +382,7 @@ static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, z
 
 /* {{{ sxe_property_read()
  */
-static zval *sxe_property_read(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC)
+static zval *sxe_property_read(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
        return sxe_prop_dim_read(object, member, 1, 0, type, rv TSRMLS_CC);
 }
@@ -666,7 +666,7 @@ next_iter:
 
 /* {{{ sxe_property_write()
  */
-static void sxe_property_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void sxe_property_write(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
        sxe_prop_dim_write(object, member, value, 1, 0, NULL TSRMLS_CC);
 }
@@ -680,7 +680,7 @@ static void sxe_dimension_write(zval *object, zval *offset, zval *value TSRMLS_D
 }
 /* }}} */
 
-static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        php_sxe_object *sxe;
        xmlNodePtr      node;
@@ -832,7 +832,7 @@ static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend
 
 /* {{{ sxe_property_exists()
  */
-static int sxe_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
+static int sxe_property_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)
 {
        return sxe_prop_dim_exists(object, member, check_empty, 1, 0 TSRMLS_CC);
 }
@@ -957,7 +957,7 @@ next_iter:
 
 /* {{{ sxe_property_delete()
  */
-static void sxe_property_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
+static void sxe_property_delete(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC)
 {
        sxe_prop_dim_delete(object, member, 1, 0 TSRMLS_CC);
 }

diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c
index 3d744af3a8a54877a806e2a5a6685bd379c77cb9..208f9de7a63e7afc6f6007c9d5f43c8d2a10cdf4 100644 (file)
--- a/ext/spl/spl_array.c
+++ b/ext/spl/spl_array.c
@@ -845,35 +845,35 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /*
 }
 /* }}} */
 
-static zval *spl_array_read_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC) /* {{{ */
+static zval *spl_array_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
        spl_array_object *intern = Z_SPLARRAY_P(object);
 
        if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-               && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+               && !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
                return spl_array_read_dimension(object, member, type, rv TSRMLS_CC);
        }
-       return std_object_handlers.read_property(object, member, type, key, rv TSRMLS_CC);
+       return std_object_handlers.read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 } /* }}} */
 
-static void spl_array_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void spl_array_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        spl_array_object *intern = Z_SPLARRAY_P(object);
 
        if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-       && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+       && !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
                spl_array_write_dimension(object, member, value TSRMLS_CC);
                return;
        }
-       std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
+       std_object_handlers.write_property(object, member, value, cache_slot TSRMLS_CC);
 } /* }}} */
 
-static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        spl_array_object *intern = Z_SPLARRAY_P(object);
 
        if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-               && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+               && !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
                return spl_array_get_dimension_ptr(1, object, member, type TSRMLS_CC);
        }
        //!!! FIXME
@@ -881,28 +881,28 @@ static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type
        return NULL;
 } /* }}} */
 
-static int spl_array_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int spl_array_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        spl_array_object *intern = Z_SPLARRAY_P(object);
 
        if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-               && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+               && !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
                return spl_array_has_dimension(object, member, has_set_exists TSRMLS_CC);
        }
-       return std_object_handlers.has_property(object, member, has_set_exists, key TSRMLS_CC);
+       return std_object_handlers.has_property(object, member, has_set_exists, cache_slot TSRMLS_CC);
 } /* }}} */
 
-static void spl_array_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void spl_array_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        spl_array_object *intern = Z_SPLARRAY_P(object);
 
        if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-               && !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+               && !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
                spl_array_unset_dimension(object, member TSRMLS_CC);
                spl_array_rewind(intern TSRMLS_CC); /* because deletion might invalidate position */
                return;
        }
-       std_object_handlers.unset_property(object, member, key TSRMLS_CC);
+       std_object_handlers.unset_property(object, member, cache_slot TSRMLS_CC);
 } /* }}} */
 
 static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */

diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c
index 0400332dc405cc524b1afa00e529c65e5a7c2a85..9c80be4aaab09706ea1410926300d177e43e319a 100644 (file)
--- a/ext/spl/spl_directory.c
+++ b/ext/spl/spl_directory.c
@@ -653,7 +653,7 @@ static HashTable *spl_filesystem_object_get_debug_info(zval *object, int *is_tem
 }
 /* }}} */
 
-zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend_string *method, const struct _zend_literal *key TSRMLS_DC) /* {{{ */
+zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend_string *method, const zval *key TSRMLS_DC) /* {{{ */
 {
        spl_filesystem_object *fsobj = spl_filesystem_from_obj(*object);
        

diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index a227b82ffd763050f34f0000797a51194a36f48d..7bc67ec300ad36644d89d58f7fd67ca93020061a 100644 (file)
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -828,7 +828,7 @@ SPL_METHOD(RecursiveIteratorIterator, getMaxDepth)
        }
 } /* }}} */
 
-static union _zend_function *spl_recursive_it_get_method(zend_object **zobject, zend_string *method, const zend_literal *key TSRMLS_DC)
+static union _zend_function *spl_recursive_it_get_method(zend_object **zobject, zend_string *method, const zval *key TSRMLS_DC)
 {
        union _zend_function    *function_handler;
        spl_recursive_it_object *object = spl_recursive_it_from_obj(*zobject);
@@ -1272,7 +1272,7 @@ static int spl_dual_it_gets_implemented(zend_class_entry *interface, zend_class_
 }
 #endif
 
-static union _zend_function *spl_dual_it_get_method(zend_object **object, zend_string *method, const zend_literal *key TSRMLS_DC)
+static union _zend_function *spl_dual_it_get_method(zend_object **object, zend_string *method, const zval *key TSRMLS_DC)
 {
        union _zend_function *function_handler;
        spl_dual_it_object   *intern;

diff --git a/ext/standard/incomplete_class.c b/ext/standard/incomplete_class.c
index c017edff8937e774ff052bd38b46e65689aa5853..0a08ad4929432931851467e3c44de19f3adf597c 100644 (file)
--- a/ext/standard/incomplete_class.c
+++ b/ext/standard/incomplete_class.c
@@ -49,7 +49,7 @@ static void incomplete_class_message(zval *object, int error_type TSRMLS_DC)
 }
 /* }}} */
 
-static zval *incomplete_class_get_property(zval *object, zval *member, int type, const zend_literal *key, zval *rv TSRMLS_DC) /* {{{ */
+static zval *incomplete_class_get_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
        incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 
@@ -61,33 +61,33 @@ static zval *incomplete_class_get_property(zval *object, zval *member, int type,
 }
 /* }}} */
 
-static void incomplete_class_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void incomplete_class_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 }
 /* }}} */
 
-static zval *incomplete_class_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *incomplete_class_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        incomplete_class_message(object, E_NOTICE TSRMLS_CC);
        return &EG(error_zval);
 }
 /* }}} */
 
-static void incomplete_class_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void incomplete_class_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 }
 /* }}} */
 
-static int incomplete_class_has_property(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int incomplete_class_has_property(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
        incomplete_class_message(object, E_NOTICE TSRMLS_CC);
        return 0;
 }
 /* }}} */
 
-static union _zend_function *incomplete_class_get_method(zend_object **object, zend_string *method, const zend_literal *key TSRMLS_DC) /* {{{ */
+static union _zend_function *incomplete_class_get_method(zend_object **object, zend_string *method, const zval *key TSRMLS_DC) /* {{{ */
 {
        zval zobject;
 

diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c
index 44b96e3bdd04428d1439d588dd33973cf0f3ff2d..7c03d1767a453226553580e8414af4ae669a61f7 100644 (file)
--- a/ext/standard/user_filters.c
+++ b/ext/standard/user_filters.c
@@ -248,7 +248,7 @@ php_stream_filter_status_t userfilter_filter(
         * keeping a reference to the stream resource here would prevent it
         * from being destroyed properly */
        ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1);
-       Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, 0 TSRMLS_CC);
+       Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, -1 TSRMLS_CC);
        zval_ptr_dtor(&zpropname);
 
        zval_ptr_dtor(&args[3]);

diff --git a/sapi/phpdbg/phpdbg_info.c b/sapi/phpdbg/phpdbg_info.c
index 660404883ce68605f58bbbe771fd786623545118..f7c7ab08466e55bc715f20db56292c83a0fc0369 100644 (file)
--- a/sapi/phpdbg/phpdbg_info.c
+++ b/sapi/phpdbg/phpdbg_info.c
@@ -212,10 +212,10 @@ PHPDBG_INFO(literal) /* {{{ */
                }
 
                while (literal < ops->last_literal) {
-                       if (Z_TYPE(ops->literals[literal].constant) != IS_NULL) {
+                       if (Z_TYPE(ops->literals[literal]) != IS_NULL) {
                                phpdbg_write("|-------- C%u -------> [", literal);
                                zend_print_zval(
-                                       &ops->literals[literal].constant, 0);
+                                       &ops->literals[literal], 0);
                                phpdbg_write("]");
                                phpdbg_writeln(EMPTY);
                        }

diff --git a/sapi/phpdbg/phpdbg_opcode.c b/sapi/phpdbg/phpdbg_opcode.c
index 17c5fbdec54f3dfd9609dfd4a9fa42add4a08083..130f868d673ee8eaadd434a5102cf30dce33bfb2 100644 (file)
--- a/sapi/phpdbg/phpdbg_opcode.c
+++ b/sapi/phpdbg/phpdbg_opcode.c
@@ -26,7 +26,7 @@
 
 ZEND_EXTERN_MODULE_GLOBALS(phpdbg);
 
-static inline zend_uint phpdbg_decode_literal(zend_op_array *ops, zend_literal *literal TSRMLS_DC) /* {{{ */
+static inline zend_uint phpdbg_decode_literal(zend_op_array *ops, zval *literal TSRMLS_DC) /* {{{ */
 {
        int iter = 0;
 
@@ -64,7 +64,7 @@ static inline char *phpdbg_decode_op(zend_op_array *ops, znode_op *op, zend_uint
                } break;
 
                case IS_CONST:
-                       asprintf(&decode, "C%u", phpdbg_decode_literal(ops, op->literal TSRMLS_CC));
+                       asprintf(&decode, "C%u", phpdbg_decode_literal(ops, op->zv TSRMLS_CC));
                break;
 
                case IS_UNUSED: