From b685991b441e7745d9e18c98636620c5ab83729b Mon Sep 17 00:00:00 2001 From: Dmitry Stogov Date: Tue, 4 Jul 2017 09:50:57 +0300 Subject: [PATCH] Get rid of old compatibility macros --- ext/opcache/Optimizer/block_pass.c | 96 +++++++++---------- ext/opcache/Optimizer/compact_literals.c | 34 +++---- ext/opcache/Optimizer/dfa_pass.c | 2 +- ext/opcache/Optimizer/nop_removal.c | 2 +- ext/opcache/Optimizer/optimize_func_calls.c | 4 +- ext/opcache/Optimizer/optimize_temp_vars_5.c | 26 ++--- ext/opcache/Optimizer/pass1_5.c | 64 ++++++------- ext/opcache/Optimizer/pass2.c | 28 +++--- ext/opcache/Optimizer/pass3.c | 44 ++++----- ext/opcache/Optimizer/zend_optimizer.c | 34 +++---- .../Optimizer/zend_optimizer_internal.h | 6 -- 11 files changed, 167 insertions(+), 173 deletions(-) diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c index 1d50184e65..b535d0760c 100644 --- a/ext/opcache/Optimizer/block_pass.c +++ b/ext/opcache/Optimizer/block_pass.c @@ -299,7 +299,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array /* mark as removed (empty live range) */ op_array->live_range[opline->op2.num].var = (uint32_t)-1; } - ZEND_RESULT_TYPE(src) = IS_UNUSED; + src->result_type = IS_UNUSED; MAKE_NOP(opline); } } @@ -312,13 +312,13 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array extension_loaded(x) BAD: interacts badly with Accelerator */ - if((ZEND_OP1_TYPE(opline) & IS_VAR) && + if((opline->op1_type & IS_VAR) && VAR_SOURCE(opline->op1) && VAR_SOURCE(opline->op1)->opcode == ZEND_DO_CF_FCALL && VAR_SOURCE(opline->op1)->extended_value == 1) { zend_op *fcall = VAR_SOURCE(opline->op1); zend_op *sv = fcall-1; if(sv >= block->start_opline && sv->opcode == ZEND_SEND_VAL && - ZEND_OP1_TYPE(sv) == IS_CONST && Z_TYPE(OPLINE_OP1_LITERAL(sv)) == IS_STRING && + sv->op1_type == IS_CONST && Z_TYPE(OPLINE_OP1_LITERAL(sv)) == IS_STRING && Z_LVAL(OPLINE_OP2_LITERAL(sv)) == 1 ) { zval *arg = &OPLINE_OP1_LITERAL(sv); @@ -333,7 +333,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array MAKE_NOP(sv); MAKE_NOP(fcall); LITERAL_BOOL(opline->op1, 1); - ZEND_OP1_TYPE(opline) = IS_CONST; + opline->op1_type = IS_CONST; } } else if(flen == sizeof("constant")-1 && zend_binary_strcasecmp(fname, flen, "constant", sizeof("constant")-1) == 0) { zval c; @@ -343,7 +343,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array MAKE_NOP(fcall); ZEND_OP1_LITERAL(opline) = zend_optimizer_add_literal(op_array, &c); /* no copy ctor - get already copied it */ - ZEND_OP1_TYPE(opline) = IS_CONST; + opline->op1_type = IS_CONST; } } else if(flen == sizeof("extension_loaded")-1 && zend_binary_strcasecmp(fname, flen, "extension_loaded", sizeof("extension_loaded")-1) == 0) { if(zend_hash_exists(&module_registry, Z_STR_P(arg))) { @@ -351,7 +351,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array MAKE_NOP(sv); MAKE_NOP(fcall); LITERAL_BOOL(opline->op1, 1); - ZEND_OP1_TYPE(opline) = IS_CONST; + opline->op1_type = IS_CONST; } } } @@ -865,10 +865,10 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array) zend_op *op = op_array->opcodes + b->start; zend_op *end = op + b->len; for (; op < end; op++) { - if (ZEND_OP1_TYPE(op) == IS_CONST) { + if (op->op1_type == IS_CONST) { literal_dtor(&ZEND_OP1_LITERAL(op)); } - if (ZEND_OP2_TYPE(op) == IS_CONST) { + if (op->op2_type == IS_CONST) { literal_dtor(&ZEND_OP2_LITERAL(op)); } } @@ -1054,7 +1054,7 @@ static void assemble_code_blocks(zend_cfg *cfg, zend_op_array *op_array) while (opline < end) { if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) { *opline_num = opline - op_array->opcodes; - opline_num = &ZEND_RESULT(opline).opline_num; + opline_num = &opline->result.opline_num; } ++opline; } @@ -1112,7 +1112,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr !(target_block->flags & ZEND_BB_PROTECTED)) { /* JMP L, L: JMPZNZ L1,L2 -> JMPZNZ L1,L2 */ *last_op = *target; - if (ZEND_OP1_TYPE(last_op) == IS_CONST) { + if (last_op->op1_type == IS_CONST) { zval zv = ZEND_OP1_LITERAL(last_op); zval_copy_ctor(&zv); last_op->op1.constant = zend_optimizer_add_literal(op_array, &zv); @@ -1129,7 +1129,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) { /* JMP L, L: RETURN to immediate RETURN */ *last_op = *target; - if (ZEND_OP1_TYPE(last_op) == IS_CONST) { + if (last_op->op1_type == IS_CONST) { zval zv = ZEND_OP1_LITERAL(last_op); zval_copy_ctor(&zv); last_op->op1.constant = zend_optimizer_add_literal(op_array, &zv); @@ -1196,14 +1196,14 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr case ZEND_JMPZ: case ZEND_JMPNZ: /* constant conditional JMPs */ - if (ZEND_OP1_TYPE(last_op) == IS_CONST) { + if (last_op->op1_type == IS_CONST) { int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(last_op)); if (last_op->opcode == ZEND_JMPZ) { should_jmp = !should_jmp; } literal_dtor(&ZEND_OP1_LITERAL(last_op)); - ZEND_OP1_TYPE(last_op) = IS_UNUSED; + last_op->op1_type = IS_UNUSED; if (should_jmp) { /* JMPNZ(true) -> JMP */ last_op->opcode = ZEND_JMP; @@ -1236,7 +1236,7 @@ static void zend_jmp_optimization(zend_basic_block *block, zend_op_array *op_arr } if (1) { - zend_uchar same_type = ZEND_OP1_TYPE(last_op); + zend_uchar same_type = last_op->op1_type; uint32_t same_var = VAR_NUM_EX(last_op->op1); zend_op *target; zend_op *target_end; @@ -1255,8 +1255,8 @@ next_target: goto next_target; } else if (target->opcode == INV_COND(last_op->opcode) && /* JMPZ(X, L), L: JMPNZ(X, L2) -> JMPZ(X, L+1) */ - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - same_type == ZEND_OP1_TYPE(target) && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + same_type == target->op1_type && same_var == VAR_NUM_EX(target->op1) && !(target_block->flags & ZEND_BB_PROTECTED) ) { @@ -1264,8 +1264,8 @@ next_target: block->successors[0] = target_block->successors[1]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == INV_COND_EX(last_op->opcode) && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - same_type == ZEND_OP1_TYPE(target) && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + same_type == target->op1_type && same_var == VAR_NUM_EX(target->op1) && !(target_block->flags & ZEND_BB_PROTECTED)) { /* JMPZ(X, L), L: T = JMPNZ_EX(X, L2) -> T = JMPZ_EX(X, L+1) */ @@ -1275,8 +1275,8 @@ next_target: block->successors[0] = target_block->successors[1]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == last_op->opcode && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - same_type == ZEND_OP1_TYPE(target) && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + same_type == target->op1_type && same_var == VAR_NUM_EX(target->op1) && !(target_block->flags & ZEND_BB_PROTECTED)) { /* JMPZ(X, L), L: JMPZ(X, L2) -> JMPZ(X, L2) */ @@ -1290,8 +1290,8 @@ next_target: block->successors[0] = target_block->successors[0]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == ZEND_JMPZNZ && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - same_type == ZEND_OP1_TYPE(target) && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + same_type == target->op1_type && same_var == VAR_NUM_EX(target->op1) && !(target_block->flags & ZEND_BB_PROTECTED)) { /* JMPZ(X, L), L: JMPZNZ(X, L2, L3) -> JMPZ(X, L2) */ @@ -1347,7 +1347,7 @@ next_target: case ZEND_JMPNZ_EX: case ZEND_JMPZ_EX: /* constant conditional JMPs */ - if (ZEND_OP1_TYPE(last_op) == IS_CONST) { + if (last_op->op1_type == IS_CONST) { int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(last_op)); if (last_op->opcode == ZEND_JMPZ_EX) { @@ -1375,8 +1375,8 @@ next_target: return; } memset(same_t, 0, var_num); - same_t[VAR_NUM_EX(last_op->op1)] |= ZEND_OP1_TYPE(last_op); - same_t[VAR_NUM_EX(last_op->result)] |= ZEND_RESULT_TYPE(last_op); + same_t[VAR_NUM_EX(last_op->op1)] |= last_op->op1_type; + same_t[VAR_NUM_EX(last_op->result)] |= last_op->result_type; target_block = blocks + block->successors[0]; next_target_ex: target = op_array->opcodes + target_block->start; @@ -1389,34 +1389,34 @@ next_target_ex: target_block = blocks + target_block->successors[0]; goto next_target_ex; } else if (target->opcode == last_op->opcode-3 && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - (same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 && !(target_block->flags & ZEND_BB_PROTECTED)) { /* T = JMPZ_EX(X, L1), L1: JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */ DEL_SOURCE(block, block->successors[0]); block->successors[0] = target_block->successors[0]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == INV_EX_COND(last_op->opcode) && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - (same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 && !(target_block->flags & ZEND_BB_PROTECTED)) { /* T = JMPZ_EX(X, L1), L1: JMPNZ({X|T1}, L2) -> T = JMPZ_EX(X, L1+1) */ DEL_SOURCE(block, block->successors[0]); block->successors[0] = target_block->successors[1]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == INV_EX_COND_EX(last_op->opcode) && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - (same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && - (same_t[VAR_NUM_EX(target->result)] & ZEND_RESULT_TYPE(target)) != 0 && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 && + (same_t[VAR_NUM_EX(target->result)] & target->result_type) != 0 && !(target_block->flags & ZEND_BB_PROTECTED)) { /* T = JMPZ_EX(X, L1), L1: T = JMPNZ_EX(T, L2) -> T = JMPZ_EX(X, L1+1) */ DEL_SOURCE(block, block->successors[0]); block->successors[0] = target_block->successors[1]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == last_op->opcode && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - (same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && - (same_t[VAR_NUM_EX(target->result)] & ZEND_RESULT_TYPE(target)) != 0 && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 && + (same_t[VAR_NUM_EX(target->result)] & target->result_type) != 0 && !(target_block->flags & ZEND_BB_PROTECTED)) { /* T = JMPZ_EX(X, L1), L1: T = JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */ DEL_SOURCE(block, block->successors[0]); @@ -1429,8 +1429,8 @@ next_target_ex: block->successors[0] = target_block->successors[0]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == ZEND_JMPZNZ && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - (same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 && !(target_block->flags & ZEND_BB_PROTECTED)) { /* T = JMPZ_EX(X, L), L: JMPZNZ({X|T}, L2, L3) -> T = JMPZ_EX(X, L2) */ DEL_SOURCE(block, block->successors[0]); @@ -1452,7 +1452,7 @@ next_target_ex: next++; } - if (ZEND_OP1_TYPE(last_op) == IS_CONST) { + if (last_op->op1_type == IS_CONST) { if (!zend_is_true(&ZEND_OP1_LITERAL(last_op))) { /* JMPZNZ(false,L1,L2) -> JMP(L1) */ literal_dtor(&ZEND_OP1_LITERAL(last_op)); @@ -1495,7 +1495,7 @@ next_target_ex: } if (last_op->opcode == ZEND_JMPZNZ) { - zend_uchar same_type = ZEND_OP1_TYPE(last_op); + zend_uchar same_type = last_op->op1_type; zend_uchar same_var = VAR_NUM_EX(last_op->op1); zend_op *target; zend_op *target_end; @@ -1512,8 +1512,8 @@ next_target_znz: target_block = blocks + target_block->successors[0]; goto next_target_znz; } else if ((target->opcode == ZEND_JMPZ || target->opcode == ZEND_JMPZNZ) && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - same_type == ZEND_OP1_TYPE(target) && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + same_type == target->op1_type && same_var == VAR_NUM_EX(target->op1) && !(target_block->flags & ZEND_BB_PROTECTED)) { /* JMPZNZ(X, L1, L2), L1: JMPZ(X, L3) -> JMPZNZ(X, L3, L2) */ @@ -1521,8 +1521,8 @@ next_target_znz: block->successors[0] = target_block->successors[0]; ADD_SOURCE(block, block->successors[0]); } else if (target->opcode == ZEND_JMPNZ && - (ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && - same_type == ZEND_OP1_TYPE(target) && + (target->op1_type & (IS_TMP_VAR|IS_CV)) && + same_type == target->op1_type && same_var == VAR_NUM_EX(target->op1) && !(target_block->flags & ZEND_BB_PROTECTED)) { /* JMPZNZ(X, L1, L2), L1: X = JMPNZ(X, L3) -> JMPZNZ(X, L1+1, L2) */ @@ -1709,14 +1709,14 @@ static void zend_t_usage(zend_cfg *cfg, zend_op_array *op_array, zend_bitset use case ZEND_QM_ASSIGN: case ZEND_BOOL: case ZEND_BOOL_NOT: - if (ZEND_OP1_TYPE(opline) == IS_CV) { + if (opline->op1_type == IS_CV) { opline->opcode = ZEND_CHECK_VAR; SET_UNUSED(opline->result); - } else if (ZEND_OP1_TYPE(opline) & (IS_TMP_VAR|IS_VAR)) { + } else if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) { opline->opcode = ZEND_FREE; SET_UNUSED(opline->result); } else { - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { literal_dtor(&ZEND_OP1_LITERAL(opline)); } MAKE_NOP(opline); @@ -1791,10 +1791,10 @@ static void zend_merge_blocks(zend_op_array *op_array, zend_cfg *cfg) zend_op *op = op_array->opcodes + bb->start; zend_op *end = op + bb->len; while (op < end) { - if (ZEND_OP1_TYPE(op) == IS_CONST) { + if (op->op1_type == IS_CONST) { literal_dtor(&ZEND_OP1_LITERAL(op)); } - if (ZEND_OP2_TYPE(op) == IS_CONST) { + if (op->op2_type == IS_CONST) { literal_dtor(&ZEND_OP2_LITERAL(op)); } MAKE_NOP(op); diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c index 90eab75e5a..bb0a768989 100644 --- a/ext/opcache/Optimizer/compact_literals.c +++ b/ext/opcache/Optimizer/compact_literals.c @@ -147,10 +147,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx LITERAL_INFO(opline->op2.constant, LITERAL_FUNC, 1, 1, 3); break; case ZEND_INIT_METHOD_CALL: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1); } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { optimizer_literal_obj_info( info, opline->op1_type, @@ -161,16 +161,16 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx } break; case ZEND_INIT_STATIC_METHOD_CALL: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2); } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { optimizer_literal_class_info( info, opline->op1_type, opline->op1, opline->op2.constant, - LITERAL_STATIC_METHOD, (ZEND_OP1_TYPE(opline) == IS_CONST) ? 1 : 2, 2, + LITERAL_STATIC_METHOD, (opline->op1_type == IS_CONST) ? 1 : 2, 2, op_array); } break; @@ -188,7 +188,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx } break; case ZEND_FETCH_CLASS_CONSTANT: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2); } optimizer_literal_class_info( @@ -196,7 +196,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx opline->op1_type, opline->op1, opline->op2.constant, - LITERAL_CLASS_CONST, (ZEND_OP1_TYPE(opline) == IS_CONST) ? 1 : 2, 1, + LITERAL_CLASS_CONST, (opline->op1_type == IS_CONST) ? 1 : 2, 1, op_array); break; case ZEND_FETCH_STATIC_PROP_R: @@ -207,10 +207,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx case ZEND_FETCH_STATIC_PROP_FUNC_ARG: case ZEND_UNSET_STATIC_PROP: case ZEND_ISSET_ISEMPTY_STATIC_PROP: - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 1, 1, 2); } - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { optimizer_literal_class_info( info, opline->op2_type, @@ -224,12 +224,12 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx case ZEND_ADD_INTERFACE: case ZEND_ADD_TRAIT: case ZEND_INSTANCEOF: - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 1, 1, 2); } break; case ZEND_NEW: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2); } break; @@ -246,7 +246,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx case ZEND_POST_INC_OBJ: case ZEND_POST_DEC_OBJ: case ZEND_ISSET_ISEMPTY_PROP_OBJ: - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { optimizer_literal_obj_info( info, opline->op1_type, @@ -268,7 +268,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx case ZEND_ASSIGN_BW_OR: case ZEND_ASSIGN_BW_AND: case ZEND_ASSIGN_BW_XOR: - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { if (opline->extended_value == ZEND_ASSIGN_OBJ) { optimizer_literal_obj_info( info, @@ -306,10 +306,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx cache_size += sizeof(void *); } default: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1); } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 1, 0, 1); } break; @@ -520,10 +520,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx opline = op_array->opcodes; end = opline + op_array->last; while (opline < end) { - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { opline->op1.constant = map[opline->op1.constant]; } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { opline->op2.constant = map[opline->op2.constant]; } opline++; diff --git a/ext/opcache/Optimizer/dfa_pass.c b/ext/opcache/Optimizer/dfa_pass.c index 0d9aaecbcc..1b589eed45 100644 --- a/ext/opcache/Optimizer/dfa_pass.c +++ b/ext/opcache/Optimizer/dfa_pass.c @@ -231,7 +231,7 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa) do { *opline_num -= shiftlist[*opline_num]; - opline_num = &ZEND_RESULT(&op_array->opcodes[*opline_num]).opline_num; + opline_num = &op_array->opcodes[*opline_num].result.opline_num; } while (*opline_num != (uint32_t)-1); } diff --git a/ext/opcache/Optimizer/nop_removal.c b/ext/opcache/Optimizer/nop_removal.c index da2d4610a3..9316eb1095 100644 --- a/ext/opcache/Optimizer/nop_removal.c +++ b/ext/opcache/Optimizer/nop_removal.c @@ -103,7 +103,7 @@ void zend_optimizer_nop_removal(zend_op_array *op_array) do { *opline_num -= shiftlist[*opline_num]; - opline_num = &ZEND_RESULT(&op_array->opcodes[*opline_num]).opline_num; + opline_num = &op_array->opcodes[*opline_num].result.opline_num; } while (*opline_num != (uint32_t)-1); } } diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c index 5d477c1a73..5f3dc35dff 100644 --- a/ext/opcache/Optimizer/optimize_func_calls.c +++ b/ext/opcache/Optimizer/optimize_func_calls.c @@ -30,10 +30,10 @@ #include "zend_vm.h" #define ZEND_OP1_IS_CONST_STRING(opline) \ - (ZEND_OP1_TYPE(opline) == IS_CONST && \ + (opline->op1_type == IS_CONST && \ Z_TYPE(op_array->literals[(opline)->op1.constant]) == IS_STRING) #define ZEND_OP2_IS_CONST_STRING(opline) \ - (ZEND_OP2_TYPE(opline) == IS_CONST && \ + (opline->op2_type == IS_CONST && \ Z_TYPE(op_array->literals[(opline)->op2.constant]) == IS_STRING) typedef struct _optimizer_call_info { diff --git a/ext/opcache/Optimizer/optimize_temp_vars_5.c b/ext/opcache/Optimizer/optimize_temp_vars_5.c index 930a926a0e..88ef01316b 100644 --- a/ext/opcache/Optimizer/optimize_temp_vars_5.c +++ b/ext/opcache/Optimizer/optimize_temp_vars_5.c @@ -66,8 +66,8 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c /* Find T definition points */ while (opline >= end) { - if (ZEND_RESULT_TYPE(opline) & (IS_VAR | IS_TMP_VAR)) { - start_of_T[VAR_NUM(ZEND_RESULT(opline).var) - offset] = opline; + if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { + start_of_T[VAR_NUM(opline->result.var) - offset] = opline; } opline--; } @@ -79,8 +79,8 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c opline = &op_array->opcodes[op_array->last - 1]; while (opline >= end) { - if ((ZEND_OP1_TYPE(opline) & (IS_VAR | IS_TMP_VAR))) { - currT = VAR_NUM(ZEND_OP1(opline).var) - offset; + if ((opline->op1_type & (IS_VAR | IS_TMP_VAR))) { + currT = VAR_NUM(opline->op1.var) - offset; if (opline->opcode == ZEND_ROPE_END) { int num = (((opline->extended_value + 1) * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval); int var; @@ -94,7 +94,7 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c map_T[currT] = var; zend_bitset_incl(valid_T, currT); zend_bitset_incl(taken_T, var); - ZEND_OP1(opline).var = NUM_VAR(var + offset); + opline->op1.var = NUM_VAR(var + offset); while (num > 1) { num--; zend_bitset_incl(taken_T, var + num); @@ -136,22 +136,22 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c map_T[currT] = i; zend_bitset_incl(valid_T, currT); } - ZEND_OP1(opline).var = NUM_VAR(map_T[currT] + offset); + opline->op1.var = NUM_VAR(map_T[currT] + offset); } } - if ((ZEND_OP2_TYPE(opline) & (IS_VAR | IS_TMP_VAR))) { - currT = VAR_NUM(ZEND_OP2(opline).var) - offset; + if ((opline->op2_type & (IS_VAR | IS_TMP_VAR))) { + currT = VAR_NUM(opline->op2.var) - offset; if (!zend_bitset_in(valid_T, currT)) { GET_AVAILABLE_T(); map_T[currT] = i; zend_bitset_incl(valid_T, currT); } - ZEND_OP2(opline).var = NUM_VAR(map_T[currT] + offset); + opline->op2.var = NUM_VAR(map_T[currT] + offset); } - if (ZEND_RESULT_TYPE(opline) & (IS_VAR | IS_TMP_VAR)) { - currT = VAR_NUM(ZEND_RESULT(opline).var) - offset; + if (opline->result_type & (IS_VAR | IS_TMP_VAR)) { + currT = VAR_NUM(opline->result.var) - offset; if (zend_bitset_in(valid_T, currT)) { if (start_of_T[currT] == opline) { /* ZEND_FAST_CALL can not share temporary var with others @@ -161,7 +161,7 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c zend_bitset_excl(taken_T, map_T[currT]); } } - ZEND_RESULT(opline).var = NUM_VAR(map_T[currT] + offset); + opline->result.var = NUM_VAR(map_T[currT] + offset); if (opline->opcode == ZEND_ROPE_INIT) { if (start_of_T[currT] == opline) { uint32_t num = ((opline->extended_value * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval); @@ -176,7 +176,7 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c GET_AVAILABLE_T(); map_T[currT] = i; zend_bitset_incl(valid_T, currT); - ZEND_RESULT(opline).var = NUM_VAR(i + offset); + opline->result.var = NUM_VAR(i + offset); } } diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c index ca49347899..8e8759fb58 100644 --- a/ext/opcache/Optimizer/pass1_5.c +++ b/ext/opcache/Optimizer/pass1_5.c @@ -68,11 +68,11 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_BW_XOR: case ZEND_BOOL_XOR: case ZEND_SPACESHIP: - if (ZEND_OP1_TYPE(opline) == IS_CONST && - ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST && + opline->op2_type == IS_CONST) { /* binary operation with constant operands */ binary_op_type binary_op = get_binary_op(opline->opcode); - uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ + uint32_t tv = opline->result.var; /* temporary variable */ zval result; int er; @@ -106,7 +106,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; case ZEND_CAST: - if (ZEND_OP1_TYPE(opline) == IS_CONST && + if (opline->op1_type == IS_CONST && opline->extended_value != IS_ARRAY && opline->extended_value != IS_OBJECT && opline->extended_value != IS_RESOURCE && @@ -114,7 +114,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) || Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_ARRAY)) { /* cast of constant operand */ zend_uchar type = opline->result_type; - uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ + uint32_t tv = opline->result.var; /* temporary variable */ zval res; res = ZEND_OP1_LITERAL(opline); zval_copy_ctor(&res); @@ -149,11 +149,11 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_BW_NOT: case ZEND_BOOL_NOT: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { /* unary operation on constant operand */ unary_op_type unary_op = get_unary_op(opline->opcode); zval result; - uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ + uint32_t tv = opline->result.var; /* temporary variable */ int er; er = EG(error_reporting); @@ -188,7 +188,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) } */ while (next_op->opcode == ZEND_ADD_STRING || next_op->opcode == ZEND_ADD_CHAR) { - if (ZEND_RESULT(opline).var != ZEND_RESULT(next_op).var) { + if (opline->result.var != next_op->result.var) { break; } if (next_op->opcode == ZEND_ADD_CHAR) { @@ -237,7 +237,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) /* NOP removal is disabled => insert JMP over NOPs */ if (last_op-opline >= 3) { /* If we have more than 2 NOPS then JMP over them */ (opline + 1)->opcode = ZEND_JMP; - ZEND_OP1(opline + 1).opline_num = last_op - op_array->opcodes; /* that's OK even for ZE2, since opline_num's are resolved in pass 2 later */ + (opline + 1)->op1.opline_num = last_op - op_array->opcodes; /* that's OK even for ZE2, since opline_num's are resolved in pass 2 later */ } } } @@ -245,7 +245,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) #endif case ZEND_FETCH_CONSTANT: - if (ZEND_OP2_TYPE(opline) == IS_CONST && + if (opline->op2_type == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING && Z_STRLEN(ZEND_OP2_LITERAL(opline)) == sizeof("__COMPILER_HALT_OFFSET__") - 1 && memcmp(Z_STRVAL(ZEND_OP2_LITERAL(opline)), "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1) == 0) { @@ -258,7 +258,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) fake_execute_data.func = (zend_function*)op_array; EG(current_execute_data) = &fake_execute_data; if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1)) != NULL) { - uint32_t tv = ZEND_RESULT(opline).var; + uint32_t tv = opline->result.var; if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, offset)) { literal_dtor(&ZEND_OP2_LITERAL(opline)); @@ -269,10 +269,10 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; } - if (ZEND_OP2_TYPE(opline) == IS_CONST && + if (opline->op2_type == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { /* substitute persistent constants */ - uint32_t tv = ZEND_RESULT(opline).var; + uint32_t tv = opline->result.var; zval c; if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &c, 1)) { @@ -291,12 +291,12 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; case ZEND_FETCH_CLASS_CONSTANT: - if (ZEND_OP2_TYPE(opline) == IS_CONST && + if (opline->op2_type == IS_CONST && Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { zend_class_entry *ce = NULL; - if (ZEND_OP1_TYPE(opline) == IS_CONST && + if (opline->op1_type == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { /* for A::B */ if (op_array->scope && @@ -314,22 +314,22 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) } } } else if (op_array->scope && - ZEND_OP1_TYPE(opline) == IS_UNUSED && + opline->op1_type == IS_UNUSED && (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) { /* for self::B */ ce = op_array->scope; } else if (op_array->scope && - ZEND_OP1_TYPE(opline) == IS_VAR && + opline->op1_type == IS_VAR && (opline - 1)->opcode == ZEND_FETCH_CLASS && - (ZEND_OP1_TYPE(opline - 1) == IS_UNUSED && + ((opline - 1)->op1_type == IS_UNUSED && ((opline - 1)->extended_value & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) && - ZEND_RESULT((opline - 1)).var == ZEND_OP1(opline).var) { + (opline - 1)->result.var == opline->op1.var) { /* for self::B */ ce = op_array->scope; } if (ce) { - uint32_t tv = ZEND_RESULT(opline).var; + uint32_t tv = opline->result.var; zend_class_constant *cc; zval *c, t; @@ -351,9 +351,9 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) } if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, &t)) { - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { literal_dtor(&ZEND_OP1_LITERAL(opline)); - } else if (ZEND_OP1_TYPE(opline) == IS_VAR) { + } else if (opline->op1_type == IS_VAR) { MAKE_NOP((opline - 1)); } literal_dtor(&ZEND_OP2_LITERAL(opline)); @@ -373,7 +373,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) send1_opline--; } if (send1_opline->opcode != ZEND_SEND_VAL || - ZEND_OP1_TYPE(send1_opline) != IS_CONST) { + send1_opline->op1_type != IS_CONST) { /* don't colllect constants after unknown function call */ collect_constants = 0; break; @@ -385,7 +385,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) send1_opline--; } if (send1_opline->opcode != ZEND_SEND_VAL || - ZEND_OP1_TYPE(send1_opline) != IS_CONST) { + send1_opline->op1_type != IS_CONST) { /* don't colllect constants after unknown function call */ collect_constants = 0; break; @@ -396,7 +396,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) init_opline--; } if (init_opline->opcode != ZEND_INIT_FCALL || - ZEND_OP2_TYPE(init_opline) != IS_CONST || + init_opline->op2_type != IS_CONST || Z_TYPE(ZEND_OP2_LITERAL(init_opline)) != IS_STRING) { /* don't colllect constants after unknown function call */ collect_constants = 0; @@ -469,7 +469,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) } else { ZVAL_FALSE(&t); } - if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { + if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, opline->result.var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); @@ -509,7 +509,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) } } - if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { + if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, opline->result.var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); @@ -524,7 +524,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) zval t; if (zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(send1_opline)), &t, 1)) { - if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { + if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, opline->result.var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); @@ -545,7 +545,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) zval t; ZVAL_STR(&t, dirname); - if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, ZEND_RESULT(opline).var, &t)) { + if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_VAR, opline->result.var, &t)) { literal_dtor(&ZEND_OP2_LITERAL(init_opline)); MAKE_NOP(init_opline); literal_dtor(&ZEND_OP1_LITERAL(send1_opline)); @@ -563,12 +563,12 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) break; } case ZEND_STRLEN: - if (ZEND_OP1_TYPE(opline) == IS_CONST && + if (opline->op1_type == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { zval t; ZVAL_LONG(&t, Z_STRLEN(ZEND_OP1_LITERAL(opline))); - if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, ZEND_RESULT(opline).var, &t)) { + if (zend_optimizer_replace_by_const(op_array, opline + 1, IS_TMP_VAR, opline->result.var, &t)) { literal_dtor(&ZEND_OP1_LITERAL(opline)); MAKE_NOP(opline); } @@ -577,7 +577,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx) case ZEND_DEFINED: { zval c; - uint32_t tv = ZEND_RESULT(opline).var; + uint32_t tv = opline->result.var; if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &c, 0)) { break; } diff --git a/ext/opcache/Optimizer/pass2.c b/ext/opcache/Optimizer/pass2.c index d592938256..5004368830 100644 --- a/ext/opcache/Optimizer/pass2.c +++ b/ext/opcache/Optimizer/pass2.c @@ -45,7 +45,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) case ZEND_MUL: case ZEND_DIV: case ZEND_POW: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { /* don't optimise if it should produce a runtime numeric string error */ if (is_numeric_string(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), NULL, NULL, 0)) { @@ -63,7 +63,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) /* object tristate op - don't attempt to optimize it! */ break; } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { /* don't optimise if it should produce a runtime numeric string error */ if (is_numeric_string(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), NULL, NULL, 0)) { @@ -76,7 +76,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) case ZEND_MOD: case ZEND_SL: case ZEND_SR: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) { /* don't optimise if it should produce a runtime numeric string error */ if (!(Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING @@ -93,7 +93,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) /* object tristate op - don't attempt to optimize it! */ break; } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) { /* don't optimise if it should produce a runtime numeric string error */ if (!(Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING @@ -106,7 +106,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) case ZEND_CONCAT: case ZEND_FAST_CONCAT: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) { convert_to_string(&ZEND_OP1_LITERAL(opline)); } @@ -117,7 +117,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) /* object tristate op - don't attempt to optimize it! */ break; } - if (ZEND_OP2_TYPE(opline) == IS_CONST) { + if (opline->op2_type == IS_CONST) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) { convert_to_string(&ZEND_OP2_LITERAL(opline)); } @@ -132,16 +132,16 @@ void zend_optimizer_pass2(zend_op_array *op_array) * ZEND_VM_SMART_BRANCH() this may improperly eliminate * assignment to Ti. */ - if (ZEND_OP1_TYPE(opline) == IS_TMP_VAR && - ZEND_RESULT_TYPE(opline) == IS_TMP_VAR && - ZEND_OP1(opline).var == ZEND_RESULT(opline).var) { + if (opline->op1_type == IS_TMP_VAR && + opline->result_type == IS_TMP_VAR && + opline->op1.var == opline->result.var) { opline->opcode -= 3; SET_UNUSED(opline->result); } else #endif /* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C) in case we know it wouldn't jump */ - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline)); if (opline->opcode == ZEND_JMPZ_EX) { should_jmp = !should_jmp; @@ -155,14 +155,14 @@ void zend_optimizer_pass2(zend_op_array *op_array) case ZEND_JMPZ: case ZEND_JMPNZ: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline)); if (opline->opcode == ZEND_JMPZ) { should_jmp = !should_jmp; } literal_dtor(&ZEND_OP1_LITERAL(opline)); - ZEND_OP1_TYPE(opline) = IS_UNUSED; + opline->op1_type = IS_UNUSED; if (should_jmp) { opline->opcode = ZEND_JMP; COPY_NODE(opline->op1, opline->op2); @@ -198,7 +198,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) break; case ZEND_JMPZNZ: - if (ZEND_OP1_TYPE(opline) == IS_CONST) { + if (opline->op1_type == IS_CONST) { zend_op *target_opline; if (zend_is_true(&ZEND_OP1_LITERAL(opline))) { @@ -208,7 +208,7 @@ void zend_optimizer_pass2(zend_op_array *op_array) } literal_dtor(&ZEND_OP1_LITERAL(opline)); ZEND_SET_OP_JMP_ADDR(opline, opline->op1, target_opline); - ZEND_OP1_TYPE(opline) = IS_UNUSED; + opline->op1_type = IS_UNUSED; opline->opcode = ZEND_JMP; } break; diff --git a/ext/opcache/Optimizer/pass3.c b/ext/opcache/Optimizer/pass3.c index dfb3e0dbcd..c572ffc6e9 100644 --- a/ext/opcache/Optimizer/pass3.c +++ b/ext/opcache/Optimizer/pass3.c @@ -93,8 +93,8 @@ void zend_optimizer_pass3(zend_op_array *op_array) break; } - if ((ZEND_OP2_TYPE(opline) & (IS_VAR | IS_CV)) - && ZEND_OP2(opline).var == ZEND_OP1(next_opline).var && + if ((opline->op2_type & (IS_VAR | IS_CV)) + && opline->op2.var == next_opline->op1.var && (opline->opcode == ZEND_ADD || opline->opcode == ZEND_MUL || opline->opcode == ZEND_BW_OR || @@ -107,16 +107,16 @@ void zend_optimizer_pass3(zend_op_array *op_array) znode_op tmp = opline->op1; if (opline->opcode != ZEND_ADD - || (ZEND_OP1_TYPE(opline) == IS_CONST + || (opline->op1_type == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_ARRAY)) { /* protection from array add: $a = array + $a is not commutative! */ COPY_NODE(opline->op1, opline->op2); COPY_NODE(opline->op2, tmp); } } - if ((ZEND_OP1_TYPE(opline) & (IS_VAR | IS_CV)) - && ZEND_OP1(opline).var == ZEND_OP1(next_opline).var - && ZEND_OP1_TYPE(opline) == ZEND_OP1_TYPE(next_opline)) { + if ((opline->op1_type & (IS_VAR | IS_CV)) + && opline->op1.var == next_opline->op1.var + && opline->op1_type == next_opline->op1_type) { switch (opline->opcode) { case ZEND_ADD: opline->opcode = ZEND_ASSIGN_ADD; @@ -258,7 +258,7 @@ void zend_optimizer_pass3(zend_op_array *op_array) /* convert L: T = JMPZ_EX X,L+1 to T = BOOL(X) */ /* convert L: T = JMPZ_EX T,L+1 to NOP */ if (ZEND_OP2_JMP_ADDR(opline) == opline + 1) { - if (ZEND_OP1(opline).var == ZEND_RESULT(opline).var) { + if (opline->op1.var == opline->result.var) { MAKE_NOP(opline); } else { opline->opcode = ZEND_BOOL; @@ -317,8 +317,8 @@ continue_jmp_ex_optimization: { zend_op *op; for(op = opline+1; opresult_type == IS_TMP_VAR && + op->result.var == opline->result.var) { break; /* can pass to part 2 */ } @@ -338,21 +338,21 @@ continue_jmp_ex_optimization: break; } - if(ZEND_OP1_TYPE(op) == IS_TMP_VAR && - ZEND_OP1(op).var == ZEND_RESULT(opline).var) { + if(op->op1_type == IS_TMP_VAR && + op->op1.var == opline->result.var) { goto done_jmp_optimization; } - if(ZEND_OP2_TYPE(op) == IS_TMP_VAR && - ZEND_OP2(op).var == ZEND_RESULT(opline).var) { + if(op->op2_type == IS_TMP_VAR && + op->op2.var == opline->result.var) { goto done_jmp_optimization; } } /* for */ - for(op = &op_array->opcodes[ZEND_OP2(opline).opline_num]; opopcodes[opline->op2.opline_num]; opresult_type == IS_TMP_VAR && + op->result.var == opline->result.var) { break; /* can pass to optimization */ } @@ -372,13 +372,13 @@ continue_jmp_ex_optimization: break; } - if(ZEND_OP1_TYPE(op) == IS_TMP_VAR && - ZEND_OP1(op).var == ZEND_RESULT(opline).var) { + if(op->op1_type == IS_TMP_VAR && + op->op1.var == opline->result.var) { goto done_jmp_optimization; } - if(ZEND_OP2_TYPE(op) == IS_TMP_VAR && - ZEND_OP2(op).var == ZEND_RESULT(opline).var) { + if(op->op2_type == IS_TMP_VAR && + op->op2.var == opline->result.var) { goto done_jmp_optimization; } } @@ -422,10 +422,10 @@ continue_jmpznz_optimization: break; } if (next_op->opcode == ZEND_FREE && - ZEND_OP1(next_op).var == ZEND_RESULT(opline).var) { + next_op->op1.var == opline->result.var) { MAKE_NOP(next_op); opline->opcode -= 2; - ZEND_RESULT_TYPE(opline) = IS_UNUSED; + opline->result_type = IS_UNUSED; } } break; diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c index 750fcb644b..46fa4710af 100644 --- a/ext/opcache/Optimizer/zend_optimizer.c +++ b/ext/opcache/Optimizer/zend_optimizer.c @@ -184,7 +184,7 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array, break; } - ZEND_OP1_TYPE(opline) = IS_CONST; + opline->op1_type = IS_CONST; if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { zend_string_hash_val(Z_STR(ZEND_OP1_LITERAL(opline))); } @@ -327,7 +327,7 @@ int zend_optimizer_update_op2_const(zend_op_array *op_array, break; } - ZEND_OP2_TYPE(opline) = IS_CONST; + opline->op2_type = IS_CONST; if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { zend_string_hash_val(Z_STR(ZEND_OP2_LITERAL(opline))); } @@ -384,8 +384,8 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, zend_op *end = op_array->opcodes + op_array->last; while (opline < end) { - if (ZEND_OP1_TYPE(opline) == type && - ZEND_OP1(opline).var == var) { + if (opline->op1_type == type && + opline->op1.var == var) { switch (opline->opcode) { case ZEND_FETCH_DIM_W: case ZEND_FETCH_DIM_RW: @@ -424,21 +424,21 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, do { if (m->opcode == ZEND_FETCH_LIST && - ZEND_OP1_TYPE(m) == type && - ZEND_OP1(m).var == var) { + m->op1_type == type && + m->op1.var == var) { zval v; ZVAL_COPY_VALUE(&v, val); zval_copy_ctor(&v); if (Z_TYPE(v) == IS_STRING) { zend_string_hash_val(Z_STR(v)); } - ZEND_OP1(m).constant = zend_optimizer_add_literal(op_array, &v); - ZEND_OP1_TYPE(m) = IS_CONST; + m->op1.constant = zend_optimizer_add_literal(op_array, &v); + m->op1_type = IS_CONST; } m++; - } while (m->opcode != ZEND_FREE || ZEND_OP1_TYPE(m) != type || ZEND_OP1(m).var != var); + } while (m->opcode != ZEND_FREE || m->op1_type != type || m->op1.var != var); - ZEND_ASSERT(m->opcode == ZEND_FREE && ZEND_OP1_TYPE(m) == type && ZEND_OP1(m).var == var); + ZEND_ASSERT(m->opcode == ZEND_FREE && m->op1_type == type && m->op1.var == var); MAKE_NOP(m); zval_dtor(val); zend_optimizer_remove_live_range(op_array, var); @@ -476,8 +476,8 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, } while (m < n) { - if (ZEND_OP1_TYPE(m) == type && - ZEND_OP1(m).var == var) { + if (m->op1_type == type && + m->op1.var == var) { if (m->opcode == ZEND_CASE || m->opcode == ZEND_SWITCH_LONG || m->opcode == ZEND_SWITCH_STRING) { @@ -487,8 +487,8 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, if (Z_TYPE(v) == IS_STRING) { zend_string_hash_val(Z_STR(v)); } - ZEND_OP1(m).constant = zend_optimizer_add_literal(op_array, &v); - ZEND_OP1_TYPE(m) = IS_CONST; + m->op1.constant = zend_optimizer_add_literal(op_array, &v); + m->op1_type = IS_CONST; } else if (m->opcode == ZEND_FREE) { MAKE_NOP(m); } else { @@ -516,7 +516,7 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, do { ++opline; } while (opline->opcode != ZEND_RETURN && opline->opcode != ZEND_RETURN_BY_REF); - ZEND_ASSERT(ZEND_OP1(opline).var == var); + ZEND_ASSERT(opline->op1.var == var); break; } @@ -530,8 +530,8 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array, return 0; } - if (ZEND_OP2_TYPE(opline) == type && - ZEND_OP2(opline).var == var) { + if (opline->op2_type == type && + opline->op2.var == var) { if (zend_optimizer_update_op2_const(op_array, opline, val)) { zend_optimizer_remove_live_range(op_array, var); return 1; diff --git a/ext/opcache/Optimizer/zend_optimizer_internal.h b/ext/opcache/Optimizer/zend_optimizer_internal.h index 71a9020d0c..a1876646b3 100644 --- a/ext/opcache/Optimizer/zend_optimizer_internal.h +++ b/ext/opcache/Optimizer/zend_optimizer_internal.h @@ -24,14 +24,8 @@ #include "zend_ssa.h" -#define ZEND_RESULT_TYPE(opline) (opline)->result_type -#define ZEND_RESULT(opline) (opline)->result -#define ZEND_OP1_TYPE(opline) (opline)->op1_type -#define ZEND_OP1(opline) (opline)->op1 #define ZEND_OP1_LITERAL(opline) (op_array)->literals[(opline)->op1.constant] #define ZEND_OP1_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op1) -#define ZEND_OP2_TYPE(opline) (opline)->op2_type -#define ZEND_OP2(opline) (opline)->op2 #define ZEND_OP2_LITERAL(opline) (op_array)->literals[(opline)->op2.constant] #define ZEND_OP2_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op2) -- 2.40.0