/* 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);
}
}
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);
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;
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))) {
MAKE_NOP(sv);
MAKE_NOP(fcall);
LITERAL_BOOL(opline->op1, 1);
- ZEND_OP1_TYPE(opline) = IS_CONST;
+ opline->op1_type = IS_CONST;
}
}
}
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));
}
}
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;
}
!(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);
!(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);
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;
}
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;
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)
) {
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) */
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) */
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) */
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) {
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;
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]);
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]);
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));
}
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;
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) */
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) */
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);
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);
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,
}
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;
}
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(
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:
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,
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;
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,
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,
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;
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++;
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);
}
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);
}
}
#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 {
/* 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--;
}
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;
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);
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
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);
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);
}
}
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;
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 &&
|| 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);
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);
}
*/
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) {
/* 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 */
}
}
}
#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) {
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));
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)) {
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 &&
}
}
} 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;
}
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));
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;
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;
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;
} 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));
}
}
- 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));
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));
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));
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);
}
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;
}
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)) {
/* 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)) {
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
/* 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
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));
}
/* 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));
}
* 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;
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);
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))) {
}
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;
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 ||
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;
/* 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;
{
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 */
}
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 */
}
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;
}
}
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;
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)));
}
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)));
}
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:
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);
}
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) {
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 {
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;
}
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;
#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)
projects / php / commitdiff