From 9c8f018dc51077f3ce26346f6106fe74dab1fcd3 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 02:40:52 +0100 Subject: [PATCH 1/9] Optimizer: use zend_string* instead of zval* --- Zend/Optimizer/compact_literals.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Zend/Optimizer/compact_literals.c b/Zend/Optimizer/compact_literals.c index a73b46c0e332..4ce556f54593 100644 --- a/Zend/Optimizer/compact_literals.c +++ b/Zend/Optimizer/compact_literals.c @@ -51,10 +51,10 @@ static uint32_t add_static_slot( uint32_t *cache_size ) { uint32_t ret; - const zval *class_name = &op_array->literals[op1]; - const zval *prop_name = &op_array->literals[op2]; + const zend_string *class_name = Z_STR(op_array->literals[op1]); + const zend_string *prop_name = Z_STR(op_array->literals[op2]); - zend_string *key = zend_create_member_string(Z_STR_P(class_name), Z_STR_P(prop_name)); + zend_string *key = zend_create_member_string(class_name, prop_name); ZSTR_H(key) = zend_string_hash_func(key); ZSTR_H(key) += kind; From b057a999788505e87b6ce33d0207097087d262f0 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 03:06:23 +0100 Subject: [PATCH 2/9] Optimizer: use bool type instead of int type --- Zend/Optimizer/sccp.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Zend/Optimizer/sccp.c b/Zend/Optimizer/sccp.c index 72ba6d98888e..ae9ff6dcc5ad 100644 --- a/Zend/Optimizer/sccp.c +++ b/Zend/Optimizer/sccp.c @@ -387,7 +387,7 @@ static inline zend_result fetch_array_elem(zval **result, const zval *op1, const } } -static inline zend_result ct_eval_fetch_dim(zval *result, const zval *op1, const zval *op2, int support_strings) { +static inline zend_result ct_eval_fetch_dim(zval *result, const zval *op1, const zval *op2, bool support_strings) { if (Z_TYPE_P(op1) == IS_ARRAY || IS_PARTIAL_ARRAY(op1)) { zval *value; if (fetch_array_elem(&value, op1, op2) == SUCCESS && value && !IS_BOT(value)) { @@ -1301,7 +1301,7 @@ static void sccp_visit_instr(scdf_ctx *scdf, zend_op *opline, zend_ssa_op *ssa_o SKIP_IF_TOP(data); - if (ct_eval_fetch_dim(&tmp, op1, op2, 0) == SUCCESS) { + if (ct_eval_fetch_dim(&tmp, op1, op2, false) == SUCCESS) { if (IS_BOT(data)) { dup_partial_array(&zv, op1); ct_eval_del_array_elem(&zv, op2); From de30913d9bb1cee310a17a584714d6cff841c81b Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 14:40:29 +0100 Subject: [PATCH 3/9] Zend: use MAY_BE_type instead of explicit bitshifts --- Zend/Optimizer/block_pass.c | 4 ++-- Zend/zend_compile.c | 4 ++-- Zend/zend_vm_def.h | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/Zend/Optimizer/block_pass.c b/Zend/Optimizer/block_pass.c index 6f67fb0e0a78..12535fbbf558 100644 --- a/Zend/Optimizer/block_pass.c +++ b/Zend/Optimizer/block_pass.c @@ -471,7 +471,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array break; case ZEND_TYPE_CHECK: optimize_type_check: - if (opline->extended_value == (1 << IS_TRUE) || opline->extended_value == (1 << IS_FALSE)) { + if (opline->extended_value == MAY_BE_TRUE || opline->extended_value == MAY_BE_FALSE) { if (opline->op1_type == IS_TMP_VAR && !zend_bitset_in(used_ext, VAR_NUM(opline->op1.var))) { src = VAR_SOURCE(opline->op1); @@ -486,7 +486,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array * T = BOOL_NOT(X) + TYPE_CHECK(T, FALSE) -> BOOL(X), NOP */ src->opcode = - ((src->opcode == ZEND_BOOL) == (opline->extended_value == (1 << IS_TRUE))) ? + ((src->opcode == ZEND_BOOL) == (opline->extended_value == MAY_BE_TRUE)) ? ZEND_BOOL : ZEND_BOOL_NOT; COPY_NODE(src->result, opline->result); SET_VAR_SOURCE(src); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 317114265c57..841f3038bedd 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -4375,7 +4375,7 @@ static zend_result zend_compile_func_typecheck(znode *result, const zend_ast_lis if (type != _IS_BOOL) { opline->extended_value = (1 << type); } else { - opline->extended_value = (1 << IS_FALSE) | (1 << IS_TRUE); + opline->extended_value = MAY_BE_BOOL; } return SUCCESS; } @@ -4392,7 +4392,7 @@ static zend_result zend_compile_func_is_scalar(znode *result, const zend_ast_lis zend_compile_expr(&arg_node, args->child[0]); opline = zend_emit_op_tmp(result, ZEND_TYPE_CHECK, &arg_node, NULL); - opline->extended_value = (1 << IS_FALSE | 1 << IS_TRUE | 1 << IS_DOUBLE | 1 << IS_LONG | 1 << IS_STRING); + opline->extended_value = (MAY_BE_BOOL | MAY_BE_DOUBLE | MAY_BE_LONG | MAY_BE_STRING); return SUCCESS; } diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 01131b5d3ae0..f84b38b07b86 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -8919,7 +8919,7 @@ ZEND_VM_C_LABEL(type_check_resource): ZEND_VM_C_GOTO(type_check_resource); } } else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { From d5896b6a866da850fef4b7f9e28dd9f805d81081 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 02:54:03 +0100 Subject: [PATCH 4/9] Optimizer: reduce scope of variables --- Zend/Optimizer/dfa_pass.c | 6 ++---- Zend/Optimizer/zend_cfg.c | 6 ++---- Zend/Optimizer/zend_inference.c | 7 +++---- ext/opcache/ZendAccelerator.c | 3 +-- 4 files changed, 8 insertions(+), 14 deletions(-) diff --git a/Zend/Optimizer/dfa_pass.c b/Zend/Optimizer/dfa_pass.c index ff4c2de4eaf7..9766ada8df34 100644 --- a/Zend/Optimizer/dfa_pass.c +++ b/Zend/Optimizer/dfa_pass.c @@ -552,7 +552,6 @@ static void compress_block(zend_op_array *op_array, zend_basic_block *block) static void replace_predecessor(zend_ssa *ssa, int block_id, int old_pred, int new_pred) { zend_basic_block *block = &ssa->cfg.blocks[block_id]; int *predecessors = &ssa->cfg.predecessors[block->predecessor_offset]; - zend_ssa_phi *phi; int old_pred_idx = -1; int new_pred_idx = -1; @@ -579,7 +578,7 @@ static void replace_predecessor(zend_ssa *ssa, int block_id, int old_pred, int n ); /* Also remove the corresponding phi node entries */ - for (phi = ssa->blocks[block_id].phis; phi; phi = phi->next) { + for (zend_ssa_phi *phi = ssa->blocks[block_id].phis; phi; phi = phi->next) { if (phi->pi >= 0) { if (phi->pi == old_pred || phi->pi == new_pred) { zend_ssa_rename_var_uses( @@ -604,7 +603,6 @@ static void zend_ssa_replace_control_link(const zend_op_array *op_array, zend_ss const zend_basic_block *src = &ssa->cfg.blocks[from]; const zend_basic_block *old = &ssa->cfg.blocks[to]; const zend_basic_block *dst = &ssa->cfg.blocks[new_to]; - zend_op *opline; for (uint32_t i = 0; i < src->successors_count; i++) { if (src->successors[i] == to) { @@ -613,7 +611,7 @@ static void zend_ssa_replace_control_link(const zend_op_array *op_array, zend_ss } if (src->len > 0) { - opline = op_array->opcodes + src->start + src->len - 1; + zend_op *opline = op_array->opcodes + src->start + src->len - 1; switch (opline->opcode) { case ZEND_JMP: case ZEND_FAST_CALL: diff --git a/Zend/Optimizer/zend_cfg.c b/Zend/Optimizer/zend_cfg.c index 837515169d70..4f6eb1efa6ad 100644 --- a/Zend/Optimizer/zend_cfg.c +++ b/Zend/Optimizer/zend_cfg.c @@ -109,7 +109,6 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * zend_mark_reachable(op_array->opcodes, cfg, blocks + start); if (op_array->last_try_catch) { - zend_basic_block *b; int changed; uint32_t *block_map = cfg->map; @@ -120,7 +119,7 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * for (uint32_t j = 0; j < op_array->last_try_catch; j++) { /* check for jumps into the middle of try block */ - b = blocks + block_map[op_array->try_catch_array[j].try_op]; + zend_basic_block *b = blocks + block_map[op_array->try_catch_array[j].try_op]; if (!(b->flags & ZEND_BB_REACHABLE)) { zend_basic_block *end; @@ -198,11 +197,10 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * } if (cfg->flags & ZEND_FUNC_FREE_LOOP_VAR) { - zend_basic_block *b; uint32_t *block_map = cfg->map; /* Mark blocks that are unreachable, but free a loop var created in a reachable block. */ - for (b = blocks; b < blocks + cfg->blocks_count; b++) { + for (zend_basic_block *b = blocks; b < blocks + cfg->blocks_count; b++) { if (b->flags & ZEND_BB_REACHABLE) { continue; } diff --git a/Zend/Optimizer/zend_inference.c b/Zend/Optimizer/zend_inference.c index c2f6098a8122..ca1c4e870e1c 100644 --- a/Zend/Optimizer/zend_inference.c +++ b/Zend/Optimizer/zend_inference.c @@ -1829,7 +1829,7 @@ static void zend_infer_ranges(const zend_op_array *op_array, zend_ssa *ssa) /* { int *scc_var; zend_ssa_phi *p; zend_ssa_range tmp; - int scc, j; + int j; ALLOCA_FLAG(use_heap); worklist = do_alloca( @@ -1850,7 +1850,7 @@ static void zend_infer_ranges(const zend_op_array *op_array, zend_ssa *ssa) /* { } } - for (scc = 0; scc < ssa->sccs; scc++) { + for (int scc = 0; scc < ssa->sccs; scc++) { j = scc_var[scc]; if (next_scc_var[j] < 0) { /* SCC with a single element */ @@ -2037,10 +2037,9 @@ static void add_usages(const zend_op_array *op_array, const zend_ssa *ssa, zend_ } if (ssa->vars[var].use_chain >= 0) { int use = ssa->vars[var].use_chain; - const zend_ssa_op *op; do { - op = ssa->ops + use; + const zend_ssa_op *op = ssa->ops + use; if (op->result_def >= 0) { zend_bitset_incl(worklist, op->result_def); } diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index 96bf83a35527..0b0dd3e4e58f 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -2270,7 +2270,6 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type) if (!persistent_script) { /* try to find cached script by full real path */ - zend_accel_hash_entry *bucket; /* open file to resolve the path */ if (file_handle->type == ZEND_HANDLE_FILENAME @@ -2286,7 +2285,7 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type) } if (file_handle->opened_path) { - bucket = zend_accel_hash_find_entry(&ZCSG(hash), file_handle->opened_path); + zend_accel_hash_entry *bucket = zend_accel_hash_find_entry(&ZCSG(hash), file_handle->opened_path); if (bucket) { persistent_script = (zend_persistent_script *)bucket->data; From 2358e88e8651f9cc6b8e89421b63f7729e1573d7 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 02:53:11 +0100 Subject: [PATCH 5/9] Optimizer: add more const qualifiers --- Zend/Optimizer/block_pass.c | 2 +- Zend/Optimizer/dfa_pass.c | 30 ++++++++++++------------ Zend/Optimizer/zend_cfg.c | 20 ++++++++-------- Zend/Optimizer/zend_cfg.h | 2 +- Zend/Optimizer/zend_optimizer_internal.h | 2 +- Zend/zend_vm_execute.h | 12 +++++----- ext/opcache/ZendAccelerator.c | 2 +- 7 files changed, 35 insertions(+), 35 deletions(-) diff --git a/Zend/Optimizer/block_pass.c b/Zend/Optimizer/block_pass.c index 12535fbbf558..1b0537e2c1f8 100644 --- a/Zend/Optimizer/block_pass.c +++ b/Zend/Optimizer/block_pass.c @@ -105,7 +105,7 @@ static void strip_nops(const zend_op_array *op_array, zend_basic_block *b) } static uint32_t get_const_switch_target(const zend_cfg *cfg, const zend_op_array *op_array, const zend_basic_block *block, zend_op *opline, const zval *val) { - HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); + const HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; if ((opline->opcode == ZEND_SWITCH_LONG && Z_TYPE_P(val) != IS_LONG) || (opline->opcode == ZEND_SWITCH_STRING && Z_TYPE_P(val) != IS_STRING)) { diff --git a/Zend/Optimizer/dfa_pass.c b/Zend/Optimizer/dfa_pass.c index 9766ada8df34..ee3dbc646abe 100644 --- a/Zend/Optimizer/dfa_pass.c +++ b/Zend/Optimizer/dfa_pass.c @@ -36,7 +36,7 @@ # include "ssa_integrity.c" #endif -zend_result zend_dfa_analyze_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa) +zend_result zend_dfa_analyze_op_array(const zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa) { uint32_t build_flags; @@ -111,7 +111,7 @@ zend_result zend_dfa_analyze_op_array(zend_op_array *op_array, zend_optimizer_ct static void zend_ssa_remove_nops(zend_op_array *op_array, const zend_ssa *ssa, zend_optimizer_ctx *ctx) { zend_basic_block *blocks = ssa->cfg.blocks; - zend_basic_block *blocks_end = blocks + ssa->cfg.blocks_count; + const zend_basic_block *blocks_end = blocks + ssa->cfg.blocks_count; zend_basic_block *b; zend_func_info *func_info; int j; @@ -475,9 +475,9 @@ static uint32_t zend_dfa_optimize_calls(zend_op_array *op_array, zend_ssa *ssa) * instances of a PFA. */ uint32_t const_args = 0; for (uint32_t i = 0, l = MIN(sizeof(const_args)*CHAR_BIT, call_info->num_args); i < l; i++) { - zend_op *send_opline = call_info->arg_info[i].opline; + const zend_op *send_opline = call_info->arg_info[i].opline; if (send_opline->op1_type == IS_CONST) { - zval *value = CT_CONSTANT_EX(op_array, send_opline->op1.constant); + const zval *value = CT_CONSTANT_EX(op_array, send_opline->op1.constant); if (Z_TYPE_P(value) == IS_CONSTANT_AST) { /* Const exprs can evaluate to non-const zvals (e.g. objects), and are not idempotent */ continue; @@ -536,10 +536,10 @@ static zend_always_inline void take_successor_ex(zend_ssa *ssa, uint32_t block_n block->successors_count = 1; } -static void compress_block(zend_op_array *op_array, zend_basic_block *block) +static void compress_block(const zend_op_array *op_array, zend_basic_block *block) { while (block->len > 0) { - zend_op *opline = &op_array->opcodes[block->start + block->len - 1]; + const zend_op *opline = &op_array->opcodes[block->start + block->len - 1]; if (opline->opcode == ZEND_NOP) { block->len--; @@ -651,7 +651,7 @@ static void zend_ssa_replace_control_link(const zend_op_array *op_array, zend_ss case ZEND_SWITCH_STRING: case ZEND_MATCH: { - HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); + const HashTable *jumptable = Z_ARRVAL(ZEND_OP2_LITERAL(opline)); zval *zv; ZEND_HASH_FOREACH_VAL(jumptable, zv) { if (ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)) == old->start) { @@ -673,12 +673,12 @@ static void zend_ssa_unlink_block(const zend_op_array *op_array, zend_ssa *ssa, { if (block->predecessors_count == 1 && ssa->blocks[block_num].phis == NULL) { int *predecessors; - zend_basic_block *fe_fetch_block = NULL; + const zend_basic_block *fe_fetch_block = NULL; ZEND_ASSERT(block->successors_count == 1); predecessors = &ssa->cfg.predecessors[block->predecessor_offset]; if (block->predecessors_count == 1 && (block->flags & ZEND_BB_FOLLOW)) { - zend_basic_block *pred_block = &ssa->cfg.blocks[predecessors[0]]; + const zend_basic_block *pred_block = &ssa->cfg.blocks[predecessors[0]]; if (pred_block->len > 0 && (pred_block->flags & ZEND_BB_REACHABLE)) { if ((op_array->opcodes[pred_block->start + pred_block->len - 1].opcode == ZEND_FE_FETCH_R @@ -702,7 +702,7 @@ static void zend_ssa_unlink_block(const zend_op_array *op_array, zend_ssa *ssa, } } -static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) +static int zend_dfa_optimize_jmps(const zend_op_array *op_array, zend_ssa *ssa) { int removed_ops = 0; uint32_t block_num = 0; @@ -909,7 +909,7 @@ static int zend_dfa_optimize_jmps(zend_op_array *op_array, zend_ssa *ssa) case ZEND_SWITCH_STRING: case ZEND_MATCH: if (opline->op1_type == IS_CONST) { - zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); + const zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); uint8_t type = Z_TYPE_P(zv); bool correct_type = (opline->opcode == ZEND_SWITCH_LONG && type == IS_LONG) @@ -1134,7 +1134,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx // op_1: ASSIGN ? -> #v [use_as_double], long(?) => ASSIGN ? -> #v, double(?) - zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant); + const zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant); ZEND_ASSERT(Z_TYPE_INFO_P(zv) == IS_LONG); ZVAL_DOUBLE(&tmp, zval_get_double(zv)); opline->op2.constant = zend_optimizer_add_literal(op_array, &tmp); @@ -1145,7 +1145,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx // op_1: QM_ASSIGN #v [use_as_double], long(?) => QM_ASSIGN #v, double(?) - zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); + const zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); ZEND_ASSERT(Z_TYPE_INFO_P(zv) == IS_LONG); ZVAL_DOUBLE(&tmp, zval_get_double(zv)); opline->op1.constant = zend_optimizer_add_literal(op_array, &tmp); @@ -1162,7 +1162,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx ) { if (opline->op1_type == IS_CONST && opline->op2_type != IS_CONST) { - zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); + const zval *zv = CT_CONSTANT_EX(op_array, opline->op1.constant); if ((OP2_INFO() & MAY_BE_ANY) == MAY_BE_DOUBLE && Z_TYPE_INFO_P(zv) == IS_LONG) { @@ -1215,7 +1215,7 @@ void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx } } } else if (opline->op1_type != IS_CONST && opline->op2_type == IS_CONST) { - zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant); + const zval *zv = CT_CONSTANT_EX(op_array, opline->op2.constant); if ((OP1_INFO() & MAY_BE_ANY) == MAY_BE_DOUBLE && Z_TYPE_INFO_P(CT_CONSTANT_EX(op_array, opline->op2.constant)) == IS_LONG) { diff --git a/Zend/Optimizer/zend_cfg.c b/Zend/Optimizer/zend_cfg.c index 4f6eb1efa6ad..37b7bd7249b5 100644 --- a/Zend/Optimizer/zend_cfg.c +++ b/Zend/Optimizer/zend_cfg.c @@ -22,7 +22,7 @@ #include "zend_optimizer_internal.h" #include "zend_sort.h" -static void zend_mark_reachable(zend_op *opcodes, zend_cfg *cfg, zend_basic_block *b) /* {{{ */ +static void zend_mark_reachable(const zend_op *opcodes, const zend_cfg *cfg, zend_basic_block *b) /* {{{ */ { zend_basic_block *blocks = cfg->blocks; @@ -101,7 +101,7 @@ static void zend_mark_reachable(zend_op *opcodes, zend_cfg *cfg, zend_basic_bloc } /* }}} */ -static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg *cfg, uint32_t start) /* {{{ */ +static void zend_mark_reachable_blocks(const zend_op_array *op_array, const zend_cfg *cfg, uint32_t start) /* {{{ */ { zend_basic_block *blocks = cfg->blocks; @@ -110,7 +110,7 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * if (op_array->last_try_catch) { int changed; - uint32_t *block_map = cfg->map; + const uint32_t *block_map = cfg->map; do { changed = 0; @@ -197,7 +197,7 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * } if (cfg->flags & ZEND_FUNC_FREE_LOOP_VAR) { - uint32_t *block_map = cfg->map; + const uint32_t *block_map = cfg->map; /* Mark blocks that are unreachable, but free a loop var created in a reachable block. */ for (zend_basic_block *b = blocks; b < blocks + cfg->blocks_count; b++) { @@ -208,7 +208,7 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * for (uint32_t j = b->start; j < b->start + b->len; j++) { zend_op *opline = &op_array->opcodes[j]; if (zend_optimizer_is_loop_var_free(opline)) { - zend_op *def_opline = zend_optimizer_get_loop_var_def(op_array, opline); + const zend_op *def_opline = zend_optimizer_get_loop_var_def(op_array, opline); if (def_opline) { uint32_t def_block = block_map[def_opline - op_array->opcodes]; if (blocks[def_block].flags & ZEND_BB_REACHABLE) { @@ -223,7 +223,7 @@ static void zend_mark_reachable_blocks(const zend_op_array *op_array, zend_cfg * } /* }}} */ -void zend_cfg_remark_reachable_blocks(const zend_op_array *op_array, zend_cfg *cfg) /* {{{ */ +void zend_cfg_remark_reachable_blocks(const zend_op_array *op_array, const zend_cfg *cfg) /* {{{ */ { zend_basic_block *blocks = cfg->blocks; uint32_t i; @@ -555,7 +555,7 @@ ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, case ZEND_SWITCH_STRING: case ZEND_MATCH: { - HashTable *jumptable = Z_ARRVAL_P(CRT_CONSTANT(opline->op2)); + const HashTable *jumptable = Z_ARRVAL_P(CRT_CONSTANT(opline->op2)); zval *zv; uint32_t s = 0; @@ -589,7 +589,7 @@ ZEND_API void zend_cfg_build_predecessors(zend_arena **arena, zend_cfg *cfg) /* { zend_basic_block *b; zend_basic_block *blocks = cfg->blocks; - zend_basic_block *end = blocks + cfg->blocks_count; + const zend_basic_block *end = blocks + cfg->blocks_count; uint32_t edges = 0; int *predecessors; @@ -648,7 +648,7 @@ ZEND_API void zend_cfg_build_predecessors(zend_arena **arena, zend_cfg *cfg) /* static void compute_postnum_recursive( int *postnum, uint32_t *cur, const zend_cfg *cfg, int block_num) /* {{{ */ { - zend_basic_block *block = &cfg->blocks[block_num]; + const zend_basic_block *block = &cfg->blocks[block_num]; if (postnum[block_num] != -1) { return; } @@ -757,7 +757,7 @@ ZEND_API void zend_cfg_compute_dominators_tree(const zend_op_array *op_array, ze } /* }}} */ -static bool dominates(zend_basic_block *blocks, int a, int b) /* {{{ */ +static bool dominates(const zend_basic_block *blocks, int a, int b) /* {{{ */ { while (blocks[b].level > blocks[a].level) { b = blocks[b].idom; diff --git a/Zend/Optimizer/zend_cfg.h b/Zend/Optimizer/zend_cfg.h index 3ed635ecdedc..f98c271118c2 100644 --- a/Zend/Optimizer/zend_cfg.h +++ b/Zend/Optimizer/zend_cfg.h @@ -114,7 +114,7 @@ typedef struct _zend_cfg { BEGIN_EXTERN_C() ZEND_API void zend_build_cfg(zend_arena **arena, const zend_op_array *op_array, uint32_t build_flags, zend_cfg *cfg); -void zend_cfg_remark_reachable_blocks(const zend_op_array *op_array, zend_cfg *cfg); +void zend_cfg_remark_reachable_blocks(const zend_op_array *op_array, const zend_cfg *cfg); ZEND_API void zend_cfg_build_predecessors(zend_arena **arena, zend_cfg *cfg); ZEND_API void zend_cfg_compute_dominators_tree(const zend_op_array *op_array, zend_cfg *cfg); ZEND_API void zend_cfg_identify_loops(const zend_op_array *op_array, zend_cfg *cfg); diff --git a/Zend/Optimizer/zend_optimizer_internal.h b/Zend/Optimizer/zend_optimizer_internal.h index 6add0f76bc02..a86dd96f78a0 100644 --- a/Zend/Optimizer/zend_optimizer_internal.h +++ b/Zend/Optimizer/zend_optimizer_internal.h @@ -111,7 +111,7 @@ void zend_optimizer_pass3(zend_op_array *op_array, zend_optimizer_ctx *ctx); void zend_optimize_func_calls(zend_op_array *op_array, zend_optimizer_ctx *ctx); void zend_optimize_cfg(zend_op_array *op_array, zend_optimizer_ctx *ctx); void zend_optimize_dfa(zend_op_array *op_array, zend_optimizer_ctx *ctx); -zend_result zend_dfa_analyze_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa); +zend_result zend_dfa_analyze_op_array(const zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa); void zend_dfa_optimize_op_array(zend_op_array *op_array, zend_optimizer_ctx *ctx, zend_ssa *ssa, zend_call_info **call_map); void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_ctx *ctx); void zend_optimizer_nop_removal(zend_op_array *op_array, zend_optimizer_ctx *ctx); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 5061d772ee82..8f419330c95e 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -6104,7 +6104,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ goto type_check_resource; } } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { @@ -18285,7 +18285,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_T goto type_check_resource; } } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { @@ -40974,7 +40974,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_T goto type_check_resource; } } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { @@ -58949,7 +58949,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_ goto type_check_resource; } } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { @@ -71028,7 +71028,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_C goto type_check_resource; } } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { @@ -93617,7 +93617,7 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_C goto type_check_resource; } } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; + result = (MAY_BE_NULL & opline->extended_value) != 0; SAVE_OPLINE(); ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception))) { diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index 0b0dd3e4e58f..fb1f39f6f2bd 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -2058,7 +2058,7 @@ const zend_op_array *zend_accel_pfa_cache_get( const uint32_t *declaring_lineno_ptr, const zend_function *called_function, bool cacheable_in_shm) { zend_string *key = zend_accel_pfa_key(declaring_lineno_ptr, called_function); - zend_op_array *op_array = NULL; + const zend_op_array *op_array = NULL; /* A PFA is SHM-cacheable if the declaring op_array and called_function are * cached. */ From f8f396b0bd2643fb80754600c020be82b919de6c Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 14:55:07 +0100 Subject: [PATCH 6/9] Zend: add const qualifier to parent CE of zend_inheritance_cache_get --- Zend/zend_inheritance.c | 2 +- Zend/zend_inheritance.h | 2 +- ext/opcache/ZendAccelerator.c | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 4424c9a1a3ab..967b8dca2e71 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -31,7 +31,7 @@ #include "zend_constants.h" #include "zend_observer.h" -ZEND_API zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces) = NULL; +ZEND_API zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, const zend_class_entry *parent, zend_class_entry **traits_and_interfaces) = NULL; ZEND_API zend_class_entry* (*zend_inheritance_cache_add)(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies) = NULL; /* Unresolved means that class declarations that are currently not available are needed to diff --git a/Zend/zend_inheritance.h b/Zend/zend_inheritance.h index fdcbd95764b3..cc324cb4f158 100644 --- a/Zend/zend_inheritance.h +++ b/Zend/zend_inheritance.h @@ -39,7 +39,7 @@ ZEND_API zend_class_entry *zend_try_early_bind(zend_class_entry *ce, zend_class_ void zend_inheritance_check_override(const zend_class_entry *ce); -ZEND_API extern zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces); +ZEND_API extern zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, const zend_class_entry *parent, zend_class_entry **traits_and_interfaces); ZEND_API extern zend_class_entry* (*zend_inheritance_cache_add)(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies); typedef enum { diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c index fb1f39f6f2bd..1190b495ca78 100644 --- a/ext/opcache/ZendAccelerator.c +++ b/ext/opcache/ZendAccelerator.c @@ -127,7 +127,7 @@ bool fallback_process = false; /* process uses file cache fallback */ #endif static zend_op_array *(*accelerator_orig_compile_file)(zend_file_handle *file_handle, int type); -static zend_class_entry* (*accelerator_orig_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces); +static zend_class_entry* (*accelerator_orig_inheritance_cache_get)(zend_class_entry *ce, const zend_class_entry *parent, zend_class_entry **traits_and_interfaces); static zend_class_entry* (*accelerator_orig_inheritance_cache_add)(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies); static zend_result (*accelerator_orig_zend_stream_open_function)(zend_file_handle *handle ); static zend_string *(*accelerator_orig_zend_resolve_path)(zend_string *filename); @@ -2529,7 +2529,7 @@ static zend_always_inline zend_inheritance_cache_entry* zend_accel_inheritance_c return NULL; } -static zend_class_entry* zend_accel_inheritance_cache_get(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces) +static zend_class_entry* zend_accel_inheritance_cache_get(zend_class_entry *ce, const zend_class_entry *parent, zend_class_entry **traits_and_interfaces) { bool needs_autoload; zend_inheritance_cache_entry *entry = ce->inheritance_cache; From eebea31f97ad5578a4363c156452324b73de08c8 Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 15:20:57 +0100 Subject: [PATCH 7/9] Optimizer/sccp: return zval* directly for fetch_obj_prop() --- Zend/Optimizer/sccp.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/Zend/Optimizer/sccp.c b/Zend/Optimizer/sccp.c index ae9ff6dcc5ad..816bf8b386d1 100644 --- a/Zend/Optimizer/sccp.c +++ b/Zend/Optimizer/sccp.c @@ -587,20 +587,19 @@ static inline zend_result ct_eval_assign_dim(zval *result, zval *value, const zv } } -static inline zend_result fetch_obj_prop(zval **result, const zval *op1, const zval *op2) { +static inline zval* fetch_obj_prop(const zval *op1, const zval *op2) { switch (Z_TYPE_P(op2)) { case IS_STRING: - *result = zend_symtable_find(Z_ARR_P(op1), Z_STR_P(op2)); - return SUCCESS; + return zend_symtable_find(Z_ARR_P(op1), Z_STR_P(op2)); default: - return FAILURE; + return NULL; } } static inline zend_result ct_eval_fetch_obj(zval *result, const zval *op1, const zval *op2) { if (IS_PARTIAL_OBJECT(op1)) { - zval *value; - if (fetch_obj_prop(&value, op1, op2) == SUCCESS && value && !IS_BOT(value)) { + const zval *value = fetch_obj_prop(op1, op2); + if (value && !IS_BOT(value)) { ZVAL_COPY(result, value); return SUCCESS; } @@ -610,10 +609,7 @@ static inline zend_result ct_eval_fetch_obj(zval *result, const zval *op1, const static inline zend_result ct_eval_isset_obj(zval *result, uint32_t extended_value, const zval *op1, const zval *op2) { if (IS_PARTIAL_OBJECT(op1)) { - zval *value; - if (fetch_obj_prop(&value, op1, op2) == FAILURE) { - return FAILURE; - } + zval *value = fetch_obj_prop(op1, op2); if (!value || IS_BOT(value)) { return FAILURE; } From 290ea3bac1ea666e44c3b9f5eaf24fee6f41916c Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 16:02:13 +0100 Subject: [PATCH 8/9] JIT: mark some CE* usages as const --- ext/opcache/jit/zend_jit.c | 8 ++++---- ext/opcache/jit/zend_jit_ir.c | 7 ++----- 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c index e91da6aeb8d3..fda17fb34e23 100644 --- a/ext/opcache/jit/zend_jit.c +++ b/ext/opcache/jit/zend_jit.c @@ -565,9 +565,9 @@ static bool zend_jit_is_persistent_constant(zval *key, uint32_t flags) return c && (ZEND_CONSTANT_FLAGS(c) & CONST_PERSISTENT); } -static zend_class_entry* zend_get_known_class(const zend_op_array *op_array, const zend_op *opline, uint8_t op_type, znode_op op) +static const zend_class_entry* zend_get_known_class(const zend_op_array *op_array, const zend_op *opline, uint8_t op_type, znode_op op) { - zend_class_entry *ce = NULL; + const zend_class_entry *ce = NULL; if (op_type == IS_CONST) { zval *zv = RT_CONSTANT(opline, op); @@ -602,7 +602,7 @@ static zend_class_entry* zend_get_known_class(const zend_op_array *op_array, con return ce; } -static zend_property_info* zend_get_known_property_info(const zend_op_array *op_array, zend_class_entry *ce, zend_string *member, bool on_this, zend_string *filename) +static zend_property_info* zend_get_known_property_info(const zend_op_array *op_array, const zend_class_entry *ce, zend_string *member, bool on_this, zend_string *filename) { zend_property_info *info = NULL; @@ -621,7 +621,7 @@ static zend_property_info* zend_get_known_property_info(const zend_op_array *op_ } if (ce->parent) { - zend_class_entry *parent = ce->parent; + const zend_class_entry *parent = ce->parent; do { if (parent->type == ZEND_INTERNAL_CLASS) { diff --git a/ext/opcache/jit/zend_jit_ir.c b/ext/opcache/jit/zend_jit_ir.c index 9849bda4cd2f..cc3821cc0cfb 100644 --- a/ext/opcache/jit/zend_jit_ir.c +++ b/ext/opcache/jit/zend_jit_ir.c @@ -9233,7 +9233,6 @@ static int zend_jit_init_static_method_call(zend_jit_ctx *jit, { zend_func_info *info = ZEND_FUNC_INFO(op_array); zend_call_info *call_info = NULL; - zend_class_entry *ce; zend_function *func = NULL; ir_ref func_ref, func_ref2, scope_ref, scope_ref2, if_cached, cold_path, ref; ir_ref if_static = IR_UNUSED; @@ -9248,7 +9247,7 @@ static int zend_jit_init_static_method_call(zend_jit_ctx *jit, } } - ce = zend_get_known_class(op_array, opline, opline->op1_type, opline->op1); + const zend_class_entry *ce = zend_get_known_class(op_array, opline, opline->op1_type, opline->op1); if (!func && ce && (opline->op1_type == IS_CONST || !(ce->ce_flags & ZEND_ACC_TRAIT))) { zval *zv = RT_CONSTANT(opline, opline->op2); zend_string *method_name; @@ -16127,9 +16126,7 @@ static int zend_jit_fetch_static_prop(zend_jit_ctx *jit, const zend_op *opline, ir_ref ref, ref2, if_cached, fast_path, cold_path, prop_info_ref, if_typed, if_def; int fetch_type; zend_property_info *known_prop_info = NULL; - zend_class_entry *ce; - - ce = zend_get_known_class(op_array, opline, opline->op2_type, opline->op2); + const zend_class_entry *ce = zend_get_known_class(op_array, opline, opline->op2_type, opline->op2); if (ce && (opline->op2_type == IS_CONST || !(ce->ce_flags & ZEND_ACC_TRAIT))) { zval *zv = RT_CONSTANT(opline, opline->op1); zend_string *prop_name; From 3739cb5dfcddb3e0b94640552ce953696476189e Mon Sep 17 00:00:00 2001 From: Gina Peter Banyard Date: Wed, 19 Aug 2026 16:12:23 +0100 Subject: [PATCH 9/9] Zend/lazy_objects: add const qualifiers --- Zend/zend_lazy_objects.c | 40 ++++++++++++++++++++-------------------- Zend/zend_lazy_objects.h | 2 +- 2 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Zend/zend_lazy_objects.c b/Zend/zend_lazy_objects.c index a8316768ef5f..49692d83dd31 100644 --- a/Zend/zend_lazy_objects.c +++ b/Zend/zend_lazy_objects.c @@ -127,11 +127,11 @@ zval* zend_lazy_object_get_initializer_zv(zend_object *obj) return &info->u.initializer.zv; } -static zend_fcall_info_cache* zend_lazy_object_get_initializer_fcc(zend_object *obj) +static const zend_fcall_info_cache* zend_lazy_object_get_initializer_fcc(const zend_object *obj) { ZEND_ASSERT(!zend_lazy_object_initialized(obj)); - zend_lazy_object_info *info = zend_lazy_object_get_info(obj); + const zend_lazy_object_info *info = zend_lazy_object_get_info(obj); ZEND_ASSERT(!(info->flags & ZEND_LAZY_OBJECT_INITIALIZED)); @@ -143,7 +143,7 @@ zend_object* zend_lazy_object_get_instance(zend_object *obj) ZEND_ASSERT(zend_lazy_object_initialized(obj)); if (zend_object_is_lazy_proxy(obj)) { - zend_lazy_object_info *info = zend_lazy_object_get_info(obj); + const zend_lazy_object_info *info = zend_lazy_object_get_info(obj); ZEND_ASSERT(info->flags & ZEND_LAZY_OBJECT_INITIALIZED); @@ -189,7 +189,7 @@ ZEND_API bool zend_class_can_be_lazy(const zend_class_entry *ce) return false; } - for (zend_class_entry *parent = ce->parent; parent; parent = parent->parent) { + for (const zend_class_entry *parent = ce->parent; parent; parent = parent->parent) { if (UNEXPECTED(parent->type == ZEND_INTERNAL_CLASS && parent != zend_standard_class_def)) { return false; } @@ -223,7 +223,7 @@ static bool zlo_is_iterating(zend_object *object) * class 'reflection_ce' */ ZEND_API zend_object *zend_object_make_lazy(zend_object *obj, zend_class_entry *reflection_ce, zval *initializer_zv, - zend_fcall_info_cache *initializer_fcc, zend_lazy_object_flags_t flags) + const zend_fcall_info_cache *initializer_fcc, zend_lazy_object_flags_t flags) { ZEND_ASSERT(!(flags & ~(ZEND_LAZY_OBJECT_USER_MASK|ZEND_LAZY_OBJECT_STRATEGY_MASK))); ZEND_ASSERT((flags & ZEND_LAZY_OBJECT_STRATEGY_MASK) == ZEND_LAZY_OBJECT_STRATEGY_GHOST @@ -238,7 +238,7 @@ ZEND_API zend_object *zend_object_make_lazy(zend_object *obj, return NULL; } - for (zend_class_entry *parent = reflection_ce->parent; parent; parent = parent->parent) { + for (const zend_class_entry *parent = reflection_ce->parent; parent; parent = parent->parent) { if (UNEXPECTED(parent->type == ZEND_INTERNAL_CLASS && parent != zend_standard_class_def)) { zend_throw_error(NULL, "Cannot make instance of internal class lazy: %s inherits internal class %s", ZSTR_VAL(reflection_ce->name), ZSTR_VAL(parent->name)); @@ -273,7 +273,7 @@ ZEND_API zend_object *zend_object_make_lazy(zend_object *obj, ZVAL_UNDEF(p); Z_PROP_FLAG_P(p) = 0; - zend_property_info *prop_info = obj->ce->properties_info_table[i]; + const zend_property_info *prop_info = obj->ce->properties_info_table[i]; if (prop_info) { zval *p = &obj->properties_table[OBJ_PROP_TO_NUM(prop_info->offset)]; Z_PROP_FLAG_P(p) = IS_PROP_UNINIT | IS_PROP_LAZY; @@ -380,11 +380,11 @@ ZEND_API zend_object *zend_lazy_object_mark_as_initialized(zend_object *obj) ZEND_ASSERT(zend_object_is_lazy(obj)); ZEND_ASSERT(!zend_lazy_object_initialized(obj)); - zend_class_entry *ce = obj->ce; + const zend_class_entry *ce = obj->ce; ZEND_ASSERT(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED); - zval *default_properties_table = CE_DEFAULT_PROPERTIES_TABLE(ce); + const zval *default_properties_table = CE_DEFAULT_PROPERTIES_TABLE(ce); zval *properties_table = obj->properties_table; OBJ_EXTRA_FLAGS(obj) &= ~(IS_OBJ_LAZY_UNINITIALIZED|IS_OBJ_LAZY_PROXY); @@ -403,7 +403,7 @@ ZEND_API zend_object *zend_lazy_object_mark_as_initialized(zend_object *obj) /* Revert initializer effects */ static void zend_lazy_object_revert_init(zend_object *obj, zval *properties_table_snapshot, HashTable *properties_snapshot) { - zend_class_entry *ce = obj->ce; + const zend_class_entry *ce = obj->ce; if (ce->default_properties_count) { ZEND_ASSERT(properties_table_snapshot); @@ -488,7 +488,7 @@ static zend_object *zend_lazy_object_init_proxy(zend_object *obj) /* Snapshot declared properties */ if (obj->ce->default_properties_count) { - zval *properties_table = obj->properties_table; + const zval *properties_table = obj->properties_table; properties_table_snapshot = emalloc(sizeof(*properties_table_snapshot) * obj->ce->default_properties_count); for (int i = 0; i < obj->ce->default_properties_count; i++) { @@ -501,7 +501,7 @@ static zend_object *zend_lazy_object_init_proxy(zend_object *obj) int argc = 1; zval zobj; HashTable *named_params = NULL; - zend_fcall_info_cache *initializer = &info->u.initializer.fcc; + const zend_fcall_info_cache *initializer = &info->u.initializer.fcc; zend_object *instance = NULL; ZVAL_OBJ(&zobj, obj); @@ -602,7 +602,7 @@ ZEND_API zend_object *zend_lazy_object_init(zend_object *obj) */ if (zend_lazy_object_initialized(obj)) { ZEND_ASSERT(zend_object_is_lazy_proxy(obj)); - zend_lazy_object_info *info = zend_lazy_object_get_info(obj); + const zend_lazy_object_info *info = zend_lazy_object_get_info(obj); ZEND_ASSERT(info->flags & ZEND_LAZY_OBJECT_INITIALIZED); if (zend_object_is_lazy(info->u.instance)) { return zend_lazy_object_init(info->u.instance); @@ -610,7 +610,7 @@ ZEND_API zend_object *zend_lazy_object_init(zend_object *obj) return info->u.instance; } - zend_class_entry *ce = obj->ce; + const zend_class_entry *ce = obj->ce; ZEND_ASSERT(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED); @@ -621,7 +621,7 @@ ZEND_API zend_object *zend_lazy_object_init(zend_object *obj) /* Prevent object from being released during initialization */ GC_ADDREF(obj); - zend_fcall_info_cache *initializer = zend_lazy_object_get_initializer_fcc(obj); + const zend_fcall_info_cache *initializer = zend_lazy_object_get_initializer_fcc(obj); /* Prevent reentrant initialization */ OBJ_EXTRA_FLAGS(obj) &= ~IS_OBJ_LAZY_UNINITIALIZED; @@ -637,7 +637,7 @@ ZEND_API zend_object *zend_lazy_object_init(zend_object *obj) /* Snapshot declared properties and initialize lazy properties to their * default value */ if (ce->default_properties_count) { - zval *default_properties_table = CE_DEFAULT_PROPERTIES_TABLE(ce); + const zval *default_properties_table = CE_DEFAULT_PROPERTIES_TABLE(ce); zval *properties_table = obj->properties_table; properties_table_snapshot = emalloc(sizeof(*properties_table_snapshot) * ce->default_properties_count); @@ -759,7 +759,7 @@ zend_object *zend_lazy_object_clone(zend_object *old_obj) return zend_objects_clone_obj(old_obj); } - zend_lazy_object_info *info = zend_lazy_object_get_info(old_obj); + const zend_lazy_object_info *info = zend_lazy_object_get_info(old_obj); zend_class_entry *ce = old_obj->ce; zend_object *new_proxy = zend_objects_new(ce); @@ -769,7 +769,7 @@ zend_object *zend_lazy_object_clone(zend_object *old_obj) ZVAL_UNDEF(p); Z_PROP_FLAG_P(p) = 0; - zend_property_info *prop_info = ce->properties_info_table[i]; + const zend_property_info *prop_info = ce->properties_info_table[i]; if (prop_info) { zval *p = &new_proxy->properties_table[OBJ_PROP_TO_NUM(prop_info->offset)]; Z_PROP_FLAG_P(p) = IS_PROP_UNINIT | IS_PROP_LAZY; @@ -821,7 +821,7 @@ HashTable *zend_lazy_object_get_gc(zend_object *zobj, zval **table, int *n) return NULL; } - zend_fcall_info_cache *fcc = &info->u.initializer.fcc; + const zend_fcall_info_cache *fcc = &info->u.initializer.fcc; if (fcc->object) { zend_get_gc_buffer_add_obj(gc_buffer, fcc->object); } @@ -833,7 +833,7 @@ HashTable *zend_lazy_object_get_gc(zend_object *zobj, zval **table, int *n) /* Uninitialized lazy objects can not have dynamic properties, so we can * ignore zobj->properties. */ zval *prop = zobj->properties_table; - zval *end = prop + zobj->ce->default_properties_count; + const zval *end = prop + zobj->ce->default_properties_count; for ( ; prop < end; prop++) { zend_get_gc_buffer_add_zval(gc_buffer, prop); } diff --git a/Zend/zend_lazy_objects.h b/Zend/zend_lazy_objects.h index 8e66ee3facd6..bb79ae59ac46 100644 --- a/Zend/zend_lazy_objects.h +++ b/Zend/zend_lazy_objects.h @@ -59,7 +59,7 @@ typedef struct _zend_fcall_info_cache zend_fcall_info_cache; ZEND_API bool zend_class_can_be_lazy(const zend_class_entry *ce); ZEND_API zend_object *zend_object_make_lazy(zend_object *obj, zend_class_entry *class_type, zval *initializer_zv, - zend_fcall_info_cache *initializer_fcc, zend_lazy_object_flags_t flags); + const zend_fcall_info_cache *initializer_fcc, zend_lazy_object_flags_t flags); ZEND_API zend_object *zend_lazy_object_init(zend_object *obj); ZEND_API zend_object *zend_lazy_object_mark_as_initialized(zend_object *obj);