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) */
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);

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);
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++;

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 {
*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);
}

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

@ -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);
}
}

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

@ -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 {

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 */
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);
}
}

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_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;
}

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_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;

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

@ -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; op<end; op++) {
if(ZEND_RESULT_TYPE(op) == IS_TMP_VAR &&
ZEND_RESULT(op).var == ZEND_RESULT(opline).var) {
if(op->result_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]; op<end; op++) {
for(op = &op_array->opcodes[opline->op2.opline_num]; op<end; op++) {
if(ZEND_RESULT_TYPE(op) == IS_TMP_VAR &&
ZEND_RESULT(op).var == ZEND_RESULT(opline).var) {
if(op->result_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;

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;
}
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;

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

@ -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)