archive/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2025-08-19 08:49:28 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Get rid of old compatibility macros

Browse source
This commit is contained in:
Dmitry Stogov 2017-07-04 09:50:57 +03:00
parent bfa24e3488
commit b685991b44
11 changed files with 167 additions and 173 deletions
Download patch file Download diff file Expand all files Collapse all files

96
ext/opcache/Optimizer/block_pass.c
View file

@ -299,7 +299,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array
/* mark as removed (empty live range) */ /* mark as removed (empty live range) */
op_array->live_range[opline->op2.num].var = (uint32_t)-1; 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); MAKE_NOP(opline);
} }
} }
@ -312,13 +312,13 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array
extension_loaded(x) extension_loaded(x)
BAD: interacts badly with Accelerator 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) && VAR_SOURCE(opline->op1)->opcode == ZEND_DO_CF_FCALL &&
VAR_SOURCE(opline->op1)->extended_value == 1) { VAR_SOURCE(opline->op1)->extended_value == 1) {
zend_op *fcall = VAR_SOURCE(opline->op1); zend_op *fcall = VAR_SOURCE(opline->op1);
zend_op *sv = fcall-1; zend_op *sv = fcall-1;
if(sv >= block->start_opline && sv->opcode == ZEND_SEND_VAL && 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 Z_LVAL(OPLINE_OP2_LITERAL(sv)) == 1
) { ) {
zval *arg = &OPLINE_OP1_LITERAL(sv); 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(sv);
MAKE_NOP(fcall); MAKE_NOP(fcall);
LITERAL_BOOL(opline->op1, 1); 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) { } else if(flen == sizeof("constant")-1 && zend_binary_strcasecmp(fname, flen, "constant", sizeof("constant")-1) == 0) {
zval c; zval c;
@ -343,7 +343,7 @@ static void zend_optimize_block(zend_basic_block *block, zend_op_array *op_array
MAKE_NOP(fcall); MAKE_NOP(fcall);
ZEND_OP1_LITERAL(opline) = zend_optimizer_add_literal(op_array, &c); ZEND_OP1_LITERAL(opline) = zend_optimizer_add_literal(op_array, &c);
/* no copy ctor - get already copied it */ /* 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) { } 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))) { 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(sv);
MAKE_NOP(fcall); MAKE_NOP(fcall);
LITERAL_BOOL(opline->op1, 1); 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 *op = op_array->opcodes + b->start;
zend_op *end = op + b->len; zend_op *end = op + b->len;
for (; op < end; op++) { for (; op < end; op++) {
if (ZEND_OP1_TYPE(op) == IS_CONST) { if (op->op1_type == IS_CONST) {
literal_dtor(&ZEND_OP1_LITERAL(op)); 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)); 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) { while (opline < end) {
if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) { if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) {
*opline_num = opline - op_array->opcodes; *opline_num = opline - op_array->opcodes;
opline_num = &ZEND_RESULT(opline).opline_num; opline_num = &opline->result.opline_num;
} }
++opline; ++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)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* JMP L, L: JMPZNZ L1,L2 -> JMPZNZ L1,L2 */ /* JMP L, L: JMPZNZ L1,L2 -> JMPZNZ L1,L2 */
*last_op = *target; *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 zv = ZEND_OP1_LITERAL(last_op);
zval_copy_ctor(&zv); zval_copy_ctor(&zv);
last_op->op1.constant = zend_optimizer_add_literal(op_array, &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)) { !(op_array->fn_flags & ZEND_ACC_HAS_FINALLY_BLOCK)) {
/* JMP L, L: RETURN to immediate RETURN */ /* JMP L, L: RETURN to immediate RETURN */
*last_op = *target; *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 zv = ZEND_OP1_LITERAL(last_op);
zval_copy_ctor(&zv); zval_copy_ctor(&zv);
last_op->op1.constant = zend_optimizer_add_literal(op_array, &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_JMPZ:
case ZEND_JMPNZ: case ZEND_JMPNZ:
/* constant conditional JMPs */ /* 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)); int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(last_op));
if (last_op->opcode == ZEND_JMPZ) { if (last_op->opcode == ZEND_JMPZ) {
should_jmp = !should_jmp; should_jmp = !should_jmp;
} }
literal_dtor(&ZEND_OP1_LITERAL(last_op)); literal_dtor(&ZEND_OP1_LITERAL(last_op));
ZEND_OP1_TYPE(last_op) = IS_UNUSED; last_op->op1_type = IS_UNUSED;
if (should_jmp) { if (should_jmp) {
/* JMPNZ(true) -> JMP */ /* JMPNZ(true) -> JMP */
last_op->opcode = ZEND_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) { 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); uint32_t same_var = VAR_NUM_EX(last_op->op1);
zend_op *target; zend_op *target;
zend_op *target_end; zend_op *target_end;
@ -1255,8 +1255,8 @@ next_target:
goto next_target; goto next_target;
} else if (target->opcode == INV_COND(last_op->opcode) && } else if (target->opcode == INV_COND(last_op->opcode) &&
/* JMPZ(X, L), L: JMPNZ(X, L2) -> JMPZ(X, L+1) */ /* JMPZ(X, L), L: JMPNZ(X, L2) -> JMPZ(X, L+1) */
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
same_type == ZEND_OP1_TYPE(target) && same_type == target->op1_type &&
same_var == VAR_NUM_EX(target->op1) && same_var == VAR_NUM_EX(target->op1) &&
!(target_block->flags & ZEND_BB_PROTECTED) !(target_block->flags & ZEND_BB_PROTECTED)
) { ) {
@ -1264,8 +1264,8 @@ next_target:
block->successors[0] = target_block->successors[1]; block->successors[0] = target_block->successors[1];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == INV_COND_EX(last_op->opcode) && } else if (target->opcode == INV_COND_EX(last_op->opcode) &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
same_type == ZEND_OP1_TYPE(target) && same_type == target->op1_type &&
same_var == VAR_NUM_EX(target->op1) && same_var == VAR_NUM_EX(target->op1) &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* JMPZ(X, L), L: T = JMPNZ_EX(X, L2) -> T = JMPZ_EX(X, L+1) */ /* 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]; block->successors[0] = target_block->successors[1];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == last_op->opcode && } else if (target->opcode == last_op->opcode &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
same_type == ZEND_OP1_TYPE(target) && same_type == target->op1_type &&
same_var == VAR_NUM_EX(target->op1) && same_var == VAR_NUM_EX(target->op1) &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* JMPZ(X, L), L: JMPZ(X, L2) -> JMPZ(X, L2) */ /* JMPZ(X, L), L: JMPZ(X, L2) -> JMPZ(X, L2) */
@ -1290,8 +1290,8 @@ next_target:
block->successors[0] = target_block->successors[0]; block->successors[0] = target_block->successors[0];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == ZEND_JMPZNZ && } else if (target->opcode == ZEND_JMPZNZ &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
same_type == ZEND_OP1_TYPE(target) && same_type == target->op1_type &&
same_var == VAR_NUM_EX(target->op1) && same_var == VAR_NUM_EX(target->op1) &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* JMPZ(X, L), L: JMPZNZ(X, L2, L3) -> JMPZ(X, L2) */ /* JMPZ(X, L), L: JMPZNZ(X, L2, L3) -> JMPZ(X, L2) */
@ -1347,7 +1347,7 @@ next_target:
case ZEND_JMPNZ_EX: case ZEND_JMPNZ_EX:
case ZEND_JMPZ_EX: case ZEND_JMPZ_EX:
/* constant conditional JMPs */ /* 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)); int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(last_op));
if (last_op->opcode == ZEND_JMPZ_EX) { if (last_op->opcode == ZEND_JMPZ_EX) {
@ -1375,8 +1375,8 @@ next_target:
return; return;
} }
memset(same_t, 0, var_num); 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->op1)] |= last_op->op1_type;
same_t[VAR_NUM_EX(last_op->result)] |= ZEND_RESULT_TYPE(last_op); same_t[VAR_NUM_EX(last_op->result)] |= last_op->result_type;
target_block = blocks + block->successors[0]; target_block = blocks + block->successors[0];
next_target_ex: next_target_ex:
target = op_array->opcodes + target_block->start; target = op_array->opcodes + target_block->start;
@ -1389,34 +1389,34 @@ next_target_ex:
target_block = blocks + target_block->successors[0]; target_block = blocks + target_block->successors[0];
goto next_target_ex; goto next_target_ex;
} else if (target->opcode == last_op->opcode-3 && } else if (target->opcode == last_op->opcode-3 &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
(same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* T = JMPZ_EX(X, L1), L1: JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */ /* T = JMPZ_EX(X, L1), L1: JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */
DEL_SOURCE(block, block->successors[0]); DEL_SOURCE(block, block->successors[0]);
block->successors[0] = target_block->successors[0]; block->successors[0] = target_block->successors[0];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == INV_EX_COND(last_op->opcode) && } else if (target->opcode == INV_EX_COND(last_op->opcode) &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
(same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* T = JMPZ_EX(X, L1), L1: JMPNZ({X|T1}, L2) -> T = JMPZ_EX(X, L1+1) */ /* T = JMPZ_EX(X, L1), L1: JMPNZ({X|T1}, L2) -> T = JMPZ_EX(X, L1+1) */
DEL_SOURCE(block, block->successors[0]); DEL_SOURCE(block, block->successors[0]);
block->successors[0] = target_block->successors[1]; block->successors[0] = target_block->successors[1];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == INV_EX_COND_EX(last_op->opcode) && } else if (target->opcode == INV_EX_COND_EX(last_op->opcode) &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
(same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 &&
(same_t[VAR_NUM_EX(target->result)] & ZEND_RESULT_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->result)] & target->result_type) != 0 &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* T = JMPZ_EX(X, L1), L1: T = JMPNZ_EX(T, L2) -> T = JMPZ_EX(X, L1+1) */ /* T = JMPZ_EX(X, L1), L1: T = JMPNZ_EX(T, L2) -> T = JMPZ_EX(X, L1+1) */
DEL_SOURCE(block, block->successors[0]); DEL_SOURCE(block, block->successors[0]);
block->successors[0] = target_block->successors[1]; block->successors[0] = target_block->successors[1];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == last_op->opcode && } else if (target->opcode == last_op->opcode &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
(same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 &&
(same_t[VAR_NUM_EX(target->result)] & ZEND_RESULT_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->result)] & target->result_type) != 0 &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* T = JMPZ_EX(X, L1), L1: T = JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */ /* T = JMPZ_EX(X, L1), L1: T = JMPZ({X|T}, L2) -> T = JMPZ_EX(X, L2) */
DEL_SOURCE(block, block->successors[0]); DEL_SOURCE(block, block->successors[0]);
@ -1429,8 +1429,8 @@ next_target_ex:
block->successors[0] = target_block->successors[0]; block->successors[0] = target_block->successors[0];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == ZEND_JMPZNZ && } else if (target->opcode == ZEND_JMPZNZ &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
(same_t[VAR_NUM_EX(target->op1)] & ZEND_OP1_TYPE(target)) != 0 && (same_t[VAR_NUM_EX(target->op1)] & target->op1_type) != 0 &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* T = JMPZ_EX(X, L), L: JMPZNZ({X|T}, L2, L3) -> T = JMPZ_EX(X, L2) */ /* T = JMPZ_EX(X, L), L: JMPZNZ({X|T}, L2, L3) -> T = JMPZ_EX(X, L2) */
DEL_SOURCE(block, block->successors[0]); DEL_SOURCE(block, block->successors[0]);
@ -1452,7 +1452,7 @@ next_target_ex:
next++; 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))) { if (!zend_is_true(&ZEND_OP1_LITERAL(last_op))) {
/* JMPZNZ(false,L1,L2) -> JMP(L1) */ /* JMPZNZ(false,L1,L2) -> JMP(L1) */
literal_dtor(&ZEND_OP1_LITERAL(last_op)); literal_dtor(&ZEND_OP1_LITERAL(last_op));
@ -1495,7 +1495,7 @@ next_target_ex:
} }
if (last_op->opcode == ZEND_JMPZNZ) { 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_uchar same_var = VAR_NUM_EX(last_op->op1);
zend_op *target; zend_op *target;
zend_op *target_end; zend_op *target_end;
@ -1512,8 +1512,8 @@ next_target_znz:
target_block = blocks + target_block->successors[0]; target_block = blocks + target_block->successors[0];
goto next_target_znz; goto next_target_znz;
} else if ((target->opcode == ZEND_JMPZ || target->opcode == ZEND_JMPZNZ) && } else if ((target->opcode == ZEND_JMPZ || target->opcode == ZEND_JMPZNZ) &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
same_type == ZEND_OP1_TYPE(target) && same_type == target->op1_type &&
same_var == VAR_NUM_EX(target->op1) && same_var == VAR_NUM_EX(target->op1) &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* JMPZNZ(X, L1, L2), L1: JMPZ(X, L3) -> JMPZNZ(X, L3, L2) */ /* 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]; block->successors[0] = target_block->successors[0];
ADD_SOURCE(block, block->successors[0]); ADD_SOURCE(block, block->successors[0]);
} else if (target->opcode == ZEND_JMPNZ && } else if (target->opcode == ZEND_JMPNZ &&
(ZEND_OP1_TYPE(target) & (IS_TMP_VAR|IS_CV)) && (target->op1_type & (IS_TMP_VAR|IS_CV)) &&
same_type == ZEND_OP1_TYPE(target) && same_type == target->op1_type &&
same_var == VAR_NUM_EX(target->op1) && same_var == VAR_NUM_EX(target->op1) &&
!(target_block->flags & ZEND_BB_PROTECTED)) { !(target_block->flags & ZEND_BB_PROTECTED)) {
/* JMPZNZ(X, L1, L2), L1: X = JMPNZ(X, L3) -> JMPZNZ(X, L1+1, L2) */ /* 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_QM_ASSIGN:
case ZEND_BOOL: case ZEND_BOOL:
case ZEND_BOOL_NOT: case ZEND_BOOL_NOT:
if (ZEND_OP1_TYPE(opline) == IS_CV) { if (opline->op1_type == IS_CV) {
opline->opcode = ZEND_CHECK_VAR; opline->opcode = ZEND_CHECK_VAR;
SET_UNUSED(opline->result); 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; opline->opcode = ZEND_FREE;
SET_UNUSED(opline->result); SET_UNUSED(opline->result);
} else { } else {
if (ZEND_OP1_TYPE(opline) == IS_CONST) { if (opline->op1_type == IS_CONST) {
literal_dtor(&ZEND_OP1_LITERAL(opline)); literal_dtor(&ZEND_OP1_LITERAL(opline));
} }
MAKE_NOP(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 *op = op_array->opcodes + bb->start;
zend_op *end = op + bb->len; zend_op *end = op + bb->len;
while (op < end) { while (op < end) {
if (ZEND_OP1_TYPE(op) == IS_CONST) { if (op->op1_type == IS_CONST) {
literal_dtor(&ZEND_OP1_LITERAL(op)); 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)); literal_dtor(&ZEND_OP2_LITERAL(op));
} }
MAKE_NOP(op); MAKE_NOP(op);

34
ext/opcache/Optimizer/compact_literals.c
View file

@ -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); LITERAL_INFO(opline->op2.constant, LITERAL_FUNC, 1, 1, 3);
break; break;
case ZEND_INIT_METHOD_CALL: 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); 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( optimizer_literal_obj_info(
info, info,
opline->op1_type, opline->op1_type,
@ -161,16 +161,16 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
} }
break; break;
case ZEND_INIT_STATIC_METHOD_CALL: 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); 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( optimizer_literal_class_info(
info, info,
opline->op1_type, opline->op1_type,
opline->op1, opline->op1,
opline->op2.constant, 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); op_array);
} }
break; break;
@ -188,7 +188,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
} }
break; break;
case ZEND_FETCH_CLASS_CONSTANT: 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); LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2);
} }
optimizer_literal_class_info( 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_type,
opline->op1, opline->op1,
opline->op2.constant, 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); op_array);
break; break;
case ZEND_FETCH_STATIC_PROP_R: 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_FETCH_STATIC_PROP_FUNC_ARG:
case ZEND_UNSET_STATIC_PROP: case ZEND_UNSET_STATIC_PROP:
case ZEND_ISSET_ISEMPTY_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); 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( optimizer_literal_class_info(
info, info,
opline->op2_type, 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_INTERFACE:
case ZEND_ADD_TRAIT: case ZEND_ADD_TRAIT:
case ZEND_INSTANCEOF: 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); LITERAL_INFO(opline->op2.constant, LITERAL_CLASS, 1, 1, 2);
} }
break; break;
case ZEND_NEW: 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); LITERAL_INFO(opline->op1.constant, LITERAL_CLASS, 1, 1, 2);
} }
break; 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_INC_OBJ:
case ZEND_POST_DEC_OBJ: case ZEND_POST_DEC_OBJ:
case ZEND_ISSET_ISEMPTY_PROP_OBJ: case ZEND_ISSET_ISEMPTY_PROP_OBJ:
if (ZEND_OP2_TYPE(opline) == IS_CONST) { if (opline->op2_type == IS_CONST) {
optimizer_literal_obj_info( optimizer_literal_obj_info(
info, info,
opline->op1_type, 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_OR:
case ZEND_ASSIGN_BW_AND: case ZEND_ASSIGN_BW_AND:
case ZEND_ASSIGN_BW_XOR: 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) { if (opline->extended_value == ZEND_ASSIGN_OBJ) {
optimizer_literal_obj_info( optimizer_literal_obj_info(
info, info,
@ -306,10 +306,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
cache_size += sizeof(void *); cache_size += sizeof(void *);
} }
default: default:
if (ZEND_OP1_TYPE(opline) == IS_CONST) { if (opline->op1_type == IS_CONST) {
LITERAL_INFO(opline->op1.constant, LITERAL_VALUE, 1, 0, 1); 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); LITERAL_INFO(opline->op2.constant, LITERAL_VALUE, 1, 0, 1);
} }
break; break;
@ -520,10 +520,10 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx
opline = op_array->opcodes; opline = op_array->opcodes;
end = opline + op_array->last; end = opline + op_array->last;
while (opline < end) { while (opline < end) {
if (ZEND_OP1_TYPE(opline) == IS_CONST) { if (opline->op1_type == IS_CONST) {
opline->op1.constant = map[opline->op1.constant]; 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->op2.constant = map[opline->op2.constant];
} }
opline++; opline++;

2
ext/opcache/Optimizer/dfa_pass.c
View file

@ -231,7 +231,7 @@ static void zend_ssa_remove_nops(zend_op_array *op_array, zend_ssa *ssa)
do { do {
*opline_num -= shiftlist[*opline_num]; *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); } while (*opline_num != (uint32_t)-1);
} }

2
ext/opcache/Optimizer/nop_removal.c
View file

@ -103,7 +103,7 @@ void zend_optimizer_nop_removal(zend_op_array *op_array)
do { do {
*opline_num -= shiftlist[*opline_num]; *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); } while (*opline_num != (uint32_t)-1);
} }
} }

4
ext/opcache/Optimizer/optimize_func_calls.c
View file

@ -30,10 +30,10 @@
#include "zend_vm.h" #include "zend_vm.h"
#define ZEND_OP1_IS_CONST_STRING(opline) \ #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) Z_TYPE(op_array->literals[(opline)->op1.constant]) == IS_STRING)
#define ZEND_OP2_IS_CONST_STRING(opline) \ #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) Z_TYPE(op_array->literals[(opline)->op2.constant]) == IS_STRING)
typedef struct _optimizer_call_info { typedef struct _optimizer_call_info {

26
ext/opcache/Optimizer/optimize_temp_vars_5.c
View file

@ -66,8 +66,8 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c
/* Find T definition points */ /* Find T definition points */
while (opline >= end) { while (opline >= end) {
if (ZEND_RESULT_TYPE(opline) & (IS_VAR | IS_TMP_VAR)) { if (opline->result_type & (IS_VAR | IS_TMP_VAR)) {
start_of_T[VAR_NUM(ZEND_RESULT(opline).var) - offset] = opline; start_of_T[VAR_NUM(opline->result.var) - offset] = opline;
} }
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]; opline = &op_array->opcodes[op_array->last - 1];
while (opline >= end) { while (opline >= end) {
if ((ZEND_OP1_TYPE(opline) & (IS_VAR | IS_TMP_VAR))) { if ((opline->op1_type & (IS_VAR | IS_TMP_VAR))) {
currT = VAR_NUM(ZEND_OP1(opline).var) - offset; currT = VAR_NUM(opline->op1.var) - offset;
if (opline->opcode == ZEND_ROPE_END) { if (opline->opcode == ZEND_ROPE_END) {
int num = (((opline->extended_value + 1) * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval); int num = (((opline->extended_value + 1) * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval);
int var; int var;
@ -94,7 +94,7 @@ void zend_optimize_temporary_variables(zend_op_array *op_array, zend_optimizer_c
map_T[currT] = var; map_T[currT] = var;
zend_bitset_incl(valid_T, currT); zend_bitset_incl(valid_T, currT);
zend_bitset_incl(taken_T, var); zend_bitset_incl(taken_T, var);
ZEND_OP1(opline).var = NUM_VAR(var + offset); opline->op1.var = NUM_VAR(var + offset);
while (num > 1) { while (num > 1) {
num--; num--;
zend_bitset_incl(taken_T, var + 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; map_T[currT] = i;
zend_bitset_incl(valid_T, currT); 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))) { if ((opline->op2_type & (IS_VAR | IS_TMP_VAR))) {
currT = VAR_NUM(ZEND_OP2(opline).var) - offset; currT = VAR_NUM(opline->op2.var) - offset;
if (!zend_bitset_in(valid_T, currT)) { if (!zend_bitset_in(valid_T, currT)) {
GET_AVAILABLE_T(); GET_AVAILABLE_T();
map_T[currT] = i; map_T[currT] = i;
zend_bitset_incl(valid_T, currT); 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)) { if (opline->result_type & (IS_VAR | IS_TMP_VAR)) {
currT = VAR_NUM(ZEND_RESULT(opline).var) - offset; currT = VAR_NUM(opline->result.var) - offset;
if (zend_bitset_in(valid_T, currT)) { if (zend_bitset_in(valid_T, currT)) {
if (start_of_T[currT] == opline) { if (start_of_T[currT] == opline) {
/* ZEND_FAST_CALL can not share temporary var with others /* 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_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 (opline->opcode == ZEND_ROPE_INIT) {
if (start_of_T[currT] == opline) { if (start_of_T[currT] == opline) {
uint32_t num = ((opline->extended_value * sizeof(zend_string*)) + (sizeof(zval) - 1)) / sizeof(zval); 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(); GET_AVAILABLE_T();
map_T[currT] = i; map_T[currT] = i;
zend_bitset_incl(valid_T, currT); zend_bitset_incl(valid_T, currT);
ZEND_RESULT(opline).var = NUM_VAR(i + offset); opline->result.var = NUM_VAR(i + offset);
} }
} }

64
ext/opcache/Optimizer/pass1_5.c
View file

@ -68,11 +68,11 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
case ZEND_BW_XOR: case ZEND_BW_XOR:
case ZEND_BOOL_XOR: case ZEND_BOOL_XOR:
case ZEND_SPACESHIP: case ZEND_SPACESHIP:
if (ZEND_OP1_TYPE(opline) == IS_CONST && if (opline->op1_type == IS_CONST &&
ZEND_OP2_TYPE(opline) == IS_CONST) { opline->op2_type == IS_CONST) {
/* binary operation with constant operands */ /* binary operation with constant operands */
binary_op_type binary_op = get_binary_op(opline->opcode); 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; zval result;
int er; int er;
@ -106,7 +106,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
break; break;
case ZEND_CAST: 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_ARRAY &&
opline->extended_value != IS_OBJECT && opline->extended_value != IS_OBJECT &&
opline->extended_value != IS_RESOURCE && 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)) { || Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_ARRAY)) {
/* cast of constant operand */ /* cast of constant operand */
zend_uchar type = opline->result_type; 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; zval res;
res = ZEND_OP1_LITERAL(opline); res = ZEND_OP1_LITERAL(opline);
zval_copy_ctor(&res); 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_BW_NOT:
case ZEND_BOOL_NOT: case ZEND_BOOL_NOT:
if (ZEND_OP1_TYPE(opline) == IS_CONST) { if (opline->op1_type == IS_CONST) {
/* unary operation on constant operand */ /* unary operation on constant operand */
unary_op_type unary_op = get_unary_op(opline->opcode); unary_op_type unary_op = get_unary_op(opline->opcode);
zval result; zval result;
uint32_t tv = ZEND_RESULT(opline).var; /* temporary variable */ uint32_t tv = opline->result.var; /* temporary variable */
int er; int er;
er = EG(error_reporting); 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) { 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; break;
} }
if (next_op->opcode == ZEND_ADD_CHAR) { 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 */ /* NOP removal is disabled => insert JMP over NOPs */
if (last_op-opline >= 3) { /* If we have more than 2 NOPS then JMP over them */ if (last_op-opline >= 3) { /* If we have more than 2 NOPS then JMP over them */
(opline + 1)->opcode = ZEND_JMP; (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 #endif
case ZEND_FETCH_CONSTANT: 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_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING &&
Z_STRLEN(ZEND_OP2_LITERAL(opline)) == sizeof("__COMPILER_HALT_OFFSET__") - 1 && 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) { 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; fake_execute_data.func = (zend_function*)op_array;
EG(current_execute_data) = &fake_execute_data; EG(current_execute_data) = &fake_execute_data;
if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1)) != NULL) { 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)) { if (zend_optimizer_replace_by_const(op_array, opline, IS_TMP_VAR, tv, offset)) {
literal_dtor(&ZEND_OP2_LITERAL(opline)); literal_dtor(&ZEND_OP2_LITERAL(opline));
@ -269,10 +269,10 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
break; break;
} }
if (ZEND_OP2_TYPE(opline) == IS_CONST && if (opline->op2_type == IS_CONST &&
Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
/* substitute persistent constants */ /* substitute persistent constants */
uint32_t tv = ZEND_RESULT(opline).var; uint32_t tv = opline->result.var;
zval c; zval c;
if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &c, 1)) { 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; break;
case ZEND_FETCH_CLASS_CONSTANT: 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) { Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
zend_class_entry *ce = NULL; 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) { Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
/* for A::B */ /* for A::B */
if (op_array->scope && 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 && } 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) { (opline->op1.num & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_SELF) {
/* for self::B */ /* for self::B */
ce = op_array->scope; ce = op_array->scope;
} else if (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 && (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) && ((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 */ /* for self::B */
ce = op_array->scope; ce = op_array->scope;
} }
if (ce) { if (ce) {
uint32_t tv = ZEND_RESULT(opline).var; uint32_t tv = opline->result.var;
zend_class_constant *cc; zend_class_constant *cc;
zval *c, t; 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_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)); 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)); MAKE_NOP((opline - 1));
} }
literal_dtor(&ZEND_OP2_LITERAL(opline)); 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--; send1_opline--;
} }
if (send1_opline->opcode != ZEND_SEND_VAL || 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 */ /* don't colllect constants after unknown function call */
collect_constants = 0; collect_constants = 0;
break; break;
@ -385,7 +385,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
send1_opline--; send1_opline--;
} }
if (send1_opline->opcode != ZEND_SEND_VAL || 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 */ /* don't colllect constants after unknown function call */
collect_constants = 0; collect_constants = 0;
break; break;
@ -396,7 +396,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
init_opline--; init_opline--;
} }
if (init_opline->opcode != ZEND_INIT_FCALL || 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) { Z_TYPE(ZEND_OP2_LITERAL(init_opline)) != IS_STRING) {
/* don't colllect constants after unknown function call */ /* don't colllect constants after unknown function call */
collect_constants = 0; collect_constants = 0;
@ -469,7 +469,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
} else { } else {
ZVAL_FALSE(&t); 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)); literal_dtor(&ZEND_OP2_LITERAL(init_opline));
MAKE_NOP(init_opline); MAKE_NOP(init_opline);
literal_dtor(&ZEND_OP1_LITERAL(send1_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)); literal_dtor(&ZEND_OP2_LITERAL(init_opline));
MAKE_NOP(init_opline); MAKE_NOP(init_opline);
literal_dtor(&ZEND_OP1_LITERAL(send1_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; zval t;
if (zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(send1_opline)), &t, 1)) { 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)); literal_dtor(&ZEND_OP2_LITERAL(init_opline));
MAKE_NOP(init_opline); MAKE_NOP(init_opline);
literal_dtor(&ZEND_OP1_LITERAL(send1_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 t;
ZVAL_STR(&t, dirname); 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)); literal_dtor(&ZEND_OP2_LITERAL(init_opline));
MAKE_NOP(init_opline); MAKE_NOP(init_opline);
literal_dtor(&ZEND_OP1_LITERAL(send1_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; break;
} }
case ZEND_STRLEN: case ZEND_STRLEN:
if (ZEND_OP1_TYPE(opline) == IS_CONST && if (opline->op1_type == IS_CONST &&
Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
zval t; zval t;
ZVAL_LONG(&t, Z_STRLEN(ZEND_OP1_LITERAL(opline))); 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)); literal_dtor(&ZEND_OP1_LITERAL(opline));
MAKE_NOP(opline); MAKE_NOP(opline);
} }
@ -577,7 +577,7 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
case ZEND_DEFINED: case ZEND_DEFINED:
{ {
zval c; 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)) { if (!zend_optimizer_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline)), &c, 0)) {
break; break;
} }

28
ext/opcache/Optimizer/pass2.c
View file

@ -45,7 +45,7 @@ void zend_optimizer_pass2(zend_op_array *op_array)
case ZEND_MUL: case ZEND_MUL:
case ZEND_DIV: case ZEND_DIV:
case ZEND_POW: 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) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
/* don't optimise if it should produce a runtime numeric string error */ /* 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)) { 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! */ /* object tristate op - don't attempt to optimize it! */
break; break;
} }
if (ZEND_OP2_TYPE(opline) == IS_CONST) { if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
/* don't optimise if it should produce a runtime numeric string error */ /* 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)) { 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_MOD:
case ZEND_SL: case ZEND_SL:
case ZEND_SR: 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) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) {
/* don't optimise if it should produce a runtime numeric string error */ /* don't optimise if it should produce a runtime numeric string error */
if (!(Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING 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! */ /* object tristate op - don't attempt to optimize it! */
break; break;
} }
if (ZEND_OP2_TYPE(opline) == IS_CONST) { if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
/* don't optimise if it should produce a runtime numeric string error */ /* don't optimise if it should produce a runtime numeric string error */
if (!(Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING 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_CONCAT:
case ZEND_FAST_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) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP1_LITERAL(opline)); 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! */ /* object tristate op - don't attempt to optimize it! */
break; break;
} }
if (ZEND_OP2_TYPE(opline) == IS_CONST) { if (opline->op2_type == IS_CONST) {
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
convert_to_string(&ZEND_OP2_LITERAL(opline)); 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 * ZEND_VM_SMART_BRANCH() this may improperly eliminate
* assignment to Ti. * assignment to Ti.
*/ */
if (ZEND_OP1_TYPE(opline) == IS_TMP_VAR && if (opline->op1_type == IS_TMP_VAR &&
ZEND_RESULT_TYPE(opline) == IS_TMP_VAR && opline->result_type == IS_TMP_VAR &&
ZEND_OP1(opline).var == ZEND_RESULT(opline).var) { opline->op1.var == opline->result.var) {
opline->opcode -= 3; opline->opcode -= 3;
SET_UNUSED(opline->result); SET_UNUSED(opline->result);
} else } else
#endif #endif
/* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C) /* convert Ti = JMPZ_EX(C, L) => Ti = QM_ASSIGN(C)
in case we know it wouldn't jump */ 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)); int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ_EX) { if (opline->opcode == ZEND_JMPZ_EX) {
should_jmp = !should_jmp; should_jmp = !should_jmp;
@ -155,14 +155,14 @@ void zend_optimizer_pass2(zend_op_array *op_array)
case ZEND_JMPZ: case ZEND_JMPZ:
case ZEND_JMPNZ: 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)); int should_jmp = zend_is_true(&ZEND_OP1_LITERAL(opline));
if (opline->opcode == ZEND_JMPZ) { if (opline->opcode == ZEND_JMPZ) {
should_jmp = !should_jmp; should_jmp = !should_jmp;
} }
literal_dtor(&ZEND_OP1_LITERAL(opline)); literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_OP1_TYPE(opline) = IS_UNUSED; opline->op1_type = IS_UNUSED;
if (should_jmp) { if (should_jmp) {
opline->opcode = ZEND_JMP; opline->opcode = ZEND_JMP;
COPY_NODE(opline->op1, opline->op2); COPY_NODE(opline->op1, opline->op2);
@ -198,7 +198,7 @@ void zend_optimizer_pass2(zend_op_array *op_array)
break; break;
case ZEND_JMPZNZ: case ZEND_JMPZNZ:
if (ZEND_OP1_TYPE(opline) == IS_CONST) { if (opline->op1_type == IS_CONST) {
zend_op *target_opline; zend_op *target_opline;
if (zend_is_true(&ZEND_OP1_LITERAL(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)); literal_dtor(&ZEND_OP1_LITERAL(opline));
ZEND_SET_OP_JMP_ADDR(opline, opline->op1, target_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; opline->opcode = ZEND_JMP;
} }
break; break;

44
ext/opcache/Optimizer/pass3.c
View file

@ -93,8 +93,8 @@ void zend_optimizer_pass3(zend_op_array *op_array)
break; break;
} }
if ((ZEND_OP2_TYPE(opline) & (IS_VAR | IS_CV)) if ((opline->op2_type & (IS_VAR | IS_CV))
&& ZEND_OP2(opline).var == ZEND_OP1(next_opline).var && && opline->op2.var == next_opline->op1.var &&
(opline->opcode == ZEND_ADD || (opline->opcode == ZEND_ADD ||
opline->opcode == ZEND_MUL || opline->opcode == ZEND_MUL ||
opline->opcode == ZEND_BW_OR || opline->opcode == ZEND_BW_OR ||
@ -107,16 +107,16 @@ void zend_optimizer_pass3(zend_op_array *op_array)
znode_op tmp = opline->op1; znode_op tmp = opline->op1;
if (opline->opcode != ZEND_ADD if (opline->opcode != ZEND_ADD
|| (ZEND_OP1_TYPE(opline) == IS_CONST || (opline->op1_type == IS_CONST
&& Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_ARRAY)) { && Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_ARRAY)) {
/* protection from array add: $a = array + $a is not commutative! */ /* protection from array add: $a = array + $a is not commutative! */
COPY_NODE(opline->op1, opline->op2); COPY_NODE(opline->op1, opline->op2);
COPY_NODE(opline->op2, tmp); COPY_NODE(opline->op2, tmp);
} }
} }
if ((ZEND_OP1_TYPE(opline) & (IS_VAR | IS_CV)) if ((opline->op1_type & (IS_VAR | IS_CV))
&& ZEND_OP1(opline).var == ZEND_OP1(next_opline).var && opline->op1.var == next_opline->op1.var
&& ZEND_OP1_TYPE(opline) == ZEND_OP1_TYPE(next_opline)) { && opline->op1_type == next_opline->op1_type) {
switch (opline->opcode) { switch (opline->opcode) {
case ZEND_ADD: case ZEND_ADD:
opline->opcode = ZEND_ASSIGN_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 X,L+1 to T = BOOL(X) */
/* convert L: T = JMPZ_EX T,L+1 to NOP */ /* convert L: T = JMPZ_EX T,L+1 to NOP */
if (ZEND_OP2_JMP_ADDR(opline) == opline + 1) { 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); MAKE_NOP(opline);
} else { } else {
opline->opcode = ZEND_BOOL; opline->opcode = ZEND_BOOL;
@ -317,8 +317,8 @@ continue_jmp_ex_optimization:
{ {
zend_op *op; zend_op *op;
for(op = opline+1; op<end; op++) { for(op = opline+1; op<end; op++) {
if(ZEND_RESULT_TYPE(op) == IS_TMP_VAR && if(op->result_type == IS_TMP_VAR &&
ZEND_RESULT(op).var == ZEND_RESULT(opline).var) { op->result.var == opline->result.var) {
break; /* can pass to part 2 */ break; /* can pass to part 2 */
} }
@ -338,21 +338,21 @@ continue_jmp_ex_optimization:
break; break;
} }
if(ZEND_OP1_TYPE(op) == IS_TMP_VAR && if(op->op1_type == IS_TMP_VAR &&
ZEND_OP1(op).var == ZEND_RESULT(opline).var) { op->op1.var == opline->result.var) {
goto done_jmp_optimization; goto done_jmp_optimization;
} }
if(ZEND_OP2_TYPE(op) == IS_TMP_VAR && if(op->op2_type == IS_TMP_VAR &&
ZEND_OP2(op).var == ZEND_RESULT(opline).var) { op->op2.var == opline->result.var) {
goto done_jmp_optimization; goto done_jmp_optimization;
} }
} /* for */ } /* for */
for(op = &op_array->opcodes[ZEND_OP2(opline).opline_num]; op<end; op++) { for(op = &op_array->opcodes[opline->op2.opline_num]; op<end; op++) {
if(ZEND_RESULT_TYPE(op) == IS_TMP_VAR && if(op->result_type == IS_TMP_VAR &&
ZEND_RESULT(op).var == ZEND_RESULT(opline).var) { op->result.var == opline->result.var) {
break; /* can pass to optimization */ break; /* can pass to optimization */
} }
@ -372,13 +372,13 @@ continue_jmp_ex_optimization:
break; break;
} }
if(ZEND_OP1_TYPE(op) == IS_TMP_VAR && if(op->op1_type == IS_TMP_VAR &&
ZEND_OP1(op).var == ZEND_RESULT(opline).var) { op->op1.var == opline->result.var) {
goto done_jmp_optimization; goto done_jmp_optimization;
} }
if(ZEND_OP2_TYPE(op) == IS_TMP_VAR && if(op->op2_type == IS_TMP_VAR &&
ZEND_OP2(op).var == ZEND_RESULT(opline).var) { op->op2.var == opline->result.var) {
goto done_jmp_optimization; goto done_jmp_optimization;
} }
} }
@ -422,10 +422,10 @@ continue_jmpznz_optimization:
break; break;
} }
if (next_op->opcode == ZEND_FREE && 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); MAKE_NOP(next_op);
opline->opcode -= 2; opline->opcode -= 2;
ZEND_RESULT_TYPE(opline) = IS_UNUSED; opline->result_type = IS_UNUSED;
} }
} }
break; break;

34
ext/opcache/Optimizer/zend_optimizer.c
View file

@ -184,7 +184,7 @@ int zend_optimizer_update_op1_const(zend_op_array *op_array,
break; break;
} }
ZEND_OP1_TYPE(opline) = IS_CONST; opline->op1_type = IS_CONST;
if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) { if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
zend_string_hash_val(Z_STR(ZEND_OP1_LITERAL(opline))); 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; break;
} }
ZEND_OP2_TYPE(opline) = IS_CONST; opline->op2_type = IS_CONST;
if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) { if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
zend_string_hash_val(Z_STR(ZEND_OP2_LITERAL(opline))); 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; zend_op *end = op_array->opcodes + op_array->last;
while (opline < end) { while (opline < end) {
if (ZEND_OP1_TYPE(opline) == type && if (opline->op1_type == type &&
ZEND_OP1(opline).var == var) { opline->op1.var == var) {
switch (opline->opcode) { switch (opline->opcode) {
case ZEND_FETCH_DIM_W: case ZEND_FETCH_DIM_W:
case ZEND_FETCH_DIM_RW: case ZEND_FETCH_DIM_RW:
@ -424,21 +424,21 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array,
do { do {
if (m->opcode == ZEND_FETCH_LIST && if (m->opcode == ZEND_FETCH_LIST &&
ZEND_OP1_TYPE(m) == type && m->op1_type == type &&
ZEND_OP1(m).var == var) { m->op1.var == var) {
zval v; zval v;
ZVAL_COPY_VALUE(&v, val); ZVAL_COPY_VALUE(&v, val);
zval_copy_ctor(&v); zval_copy_ctor(&v);
if (Z_TYPE(v) == IS_STRING) { if (Z_TYPE(v) == IS_STRING) {
zend_string_hash_val(Z_STR(v)); zend_string_hash_val(Z_STR(v));
} }
ZEND_OP1(m).constant = zend_optimizer_add_literal(op_array, &v); m->op1.constant = zend_optimizer_add_literal(op_array, &v);
ZEND_OP1_TYPE(m) = IS_CONST; m->op1_type = IS_CONST;
} }
m++; 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); MAKE_NOP(m);
zval_dtor(val); zval_dtor(val);
zend_optimizer_remove_live_range(op_array, var); 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) { while (m < n) {
if (ZEND_OP1_TYPE(m) == type && if (m->op1_type == type &&
ZEND_OP1(m).var == var) { m->op1.var == var) {
if (m->opcode == ZEND_CASE if (m->opcode == ZEND_CASE
|| m->opcode == ZEND_SWITCH_LONG || m->opcode == ZEND_SWITCH_LONG
|| m->opcode == ZEND_SWITCH_STRING) { || 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) { if (Z_TYPE(v) == IS_STRING) {
zend_string_hash_val(Z_STR(v)); zend_string_hash_val(Z_STR(v));
} }
ZEND_OP1(m).constant = zend_optimizer_add_literal(op_array, &v); m->op1.constant = zend_optimizer_add_literal(op_array, &v);
ZEND_OP1_TYPE(m) = IS_CONST; m->op1_type = IS_CONST;
} else if (m->opcode == ZEND_FREE) { } else if (m->opcode == ZEND_FREE) {
MAKE_NOP(m); MAKE_NOP(m);
} else { } else {
@ -516,7 +516,7 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array,
do { do {
++opline; ++opline;
} while (opline->opcode != ZEND_RETURN && opline->opcode != ZEND_RETURN_BY_REF); } 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; break;
} }
@ -530,8 +530,8 @@ int zend_optimizer_replace_by_const(zend_op_array *op_array,
return 0; return 0;
} }
if (ZEND_OP2_TYPE(opline) == type && if (opline->op2_type == type &&
ZEND_OP2(opline).var == var) { opline->op2.var == var) {
if (zend_optimizer_update_op2_const(op_array, opline, val)) { if (zend_optimizer_update_op2_const(op_array, opline, val)) {
zend_optimizer_remove_live_range(op_array, var); zend_optimizer_remove_live_range(op_array, var);
return 1; return 1;

6
ext/opcache/Optimizer/zend_optimizer_internal.h
View file

@ -24,14 +24,8 @@
#include "zend_ssa.h" #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_LITERAL(opline) (op_array)->literals[(opline)->op1.constant]
#define ZEND_OP1_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op1) #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_LITERAL(opline) (op_array)->literals[(opline)->op2.constant]
#define ZEND_OP2_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op2) #define ZEND_OP2_JMP_ADDR(opline) OP_JMP_ADDR(opline, (opline)->op2)