| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| #include "zend_compile.h" |
| #include "zend_cfg.h" |
| #include "zend_ssa.h" |
| #include "zend_inference.h" |
| #include "zend_func_info.h" |
| #include "zend_call_graph.h" |
| #include "zend_dump.h" |
| #include "zend_smart_str.h" |
|
|
| void zend_dump_ht(HashTable *ht) |
| { |
| zend_ulong index; |
| zend_string *key; |
| zval *val; |
| bool first = 1; |
|
|
| ZEND_HASH_FOREACH_KEY_VAL(ht, index, key, val) { |
| if (first) { |
| first = 0; |
| } else { |
| fprintf(stderr, ", "); |
| } |
| if (key) { |
| fprintf(stderr, "\"%s\"", ZSTR_VAL(key)); |
| } else { |
| fprintf(stderr, ZEND_LONG_FMT, index); |
| } |
| fprintf(stderr, " =>"); |
| zend_dump_const(val); |
| } ZEND_HASH_FOREACH_END(); |
| } |
|
|
| void zend_dump_const(const zval *zv) |
| { |
| switch (Z_TYPE_P(zv)) { |
| case IS_NULL: |
| fprintf(stderr, " null"); |
| break; |
| case IS_FALSE: |
| fprintf(stderr, " bool(false)"); |
| break; |
| case IS_TRUE: |
| fprintf(stderr, " bool(true)"); |
| break; |
| case IS_LONG: |
| fprintf(stderr, " int(" ZEND_LONG_FMT ")", Z_LVAL_P(zv)); |
| break; |
| case IS_DOUBLE: |
| fprintf(stderr, " float(%g)", Z_DVAL_P(zv)); |
| break; |
| case IS_STRING: { |
| smart_str escaped_string = {0}; |
| smart_str_append_escaped(&escaped_string, Z_STRVAL_P(zv), Z_STRLEN_P(zv)); |
| smart_str_0(&escaped_string); |
|
|
| fprintf(stderr, " string(\""); |
|
|
| |
| for (size_t i = 0; i < ZSTR_LEN(escaped_string.s); i++) { |
| if (ZSTR_VAL(escaped_string.s)[i] == '"') { |
| fprintf(stderr, "\\\""); |
| } else { |
| putc(ZSTR_VAL(escaped_string.s)[i], stderr); |
| } |
| } |
|
|
| fprintf(stderr, "\")"); |
|
|
| smart_str_free_ex(&escaped_string, false); |
| break; |
| } |
| case IS_ARRAY: |
| fprintf(stderr, " array(...)"); |
| break; |
| default: |
| fprintf(stderr, " zval(type=%d)", Z_TYPE_P(zv)); |
| break; |
| } |
| } |
|
|
| static void zend_dump_class_fetch_type(uint32_t fetch_type) |
| { |
| switch (fetch_type & ZEND_FETCH_CLASS_MASK) { |
| case ZEND_FETCH_CLASS_SELF: |
| fprintf(stderr, " (self)"); |
| break; |
| case ZEND_FETCH_CLASS_PARENT: |
| fprintf(stderr, " (parent)"); |
| break; |
| case ZEND_FETCH_CLASS_STATIC: |
| fprintf(stderr, " (static)"); |
| break; |
| case ZEND_FETCH_CLASS_AUTO: |
| fprintf(stderr, " (auto)"); |
| break; |
| case ZEND_FETCH_CLASS_INTERFACE: |
| fprintf(stderr, " (interface)"); |
| break; |
| case ZEND_FETCH_CLASS_TRAIT: |
| fprintf(stderr, " (trait)"); |
| break; |
| } |
| if (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) { |
| fprintf(stderr, " (no-autoload)"); |
| } |
| if (fetch_type & ZEND_FETCH_CLASS_SILENT) { |
| fprintf(stderr, " (silent)"); |
| } |
| if (fetch_type & ZEND_FETCH_CLASS_EXCEPTION) { |
| fprintf(stderr, " (exception)"); |
| } |
| } |
|
|
| static void zend_dump_unused_op(const zend_op *opline, znode_op op, uint32_t flags) { |
| if (ZEND_VM_OP_NUM == (flags & ZEND_VM_OP_MASK)) { |
| fprintf(stderr, " %u", op.num); |
| } else if (ZEND_VM_OP_TRY_CATCH == (flags & ZEND_VM_OP_MASK)) { |
| if (op.num != (uint32_t)-1) { |
| fprintf(stderr, " try-catch(%u)", op.num); |
| } |
| } else if (ZEND_VM_OP_THIS == (flags & ZEND_VM_OP_MASK)) { |
| fprintf(stderr, " THIS"); |
| } else if (ZEND_VM_OP_NEXT == (flags & ZEND_VM_OP_MASK)) { |
| fprintf(stderr, " NEXT"); |
| } else if (ZEND_VM_OP_CLASS_FETCH == (flags & ZEND_VM_OP_MASK)) { |
| zend_dump_class_fetch_type(op.num); |
| } else if (ZEND_VM_OP_CONSTRUCTOR == (flags & ZEND_VM_OP_MASK)) { |
| fprintf(stderr, " CONSTRUCTOR"); |
| } else if (ZEND_VM_OP_CONST_FETCH == (flags & ZEND_VM_OP_MASK)) { |
| if (op.num & IS_CONSTANT_UNQUALIFIED_IN_NAMESPACE) { |
| fprintf(stderr, " (unqualified-in-namespace)"); |
| } |
| } |
| } |
|
|
| ZEND_API void zend_dump_var(const zend_op_array *op_array, uint8_t var_type, uint32_t var_num) |
| { |
| if (var_type == IS_CV && var_num < op_array->last_var) { |
| fprintf(stderr, "CV%d($%s)", var_num, op_array->vars[var_num]->val); |
| } else if (var_type == IS_VAR) { |
| fprintf(stderr, "V%d", var_num); |
| } else if ((var_type & (IS_VAR|IS_TMP_VAR)) == IS_TMP_VAR) { |
| fprintf(stderr, "T%d", var_num); |
| } else { |
| fprintf(stderr, "X%d", var_num); |
| } |
| } |
|
|
| static void zend_dump_range(const zend_ssa_range *r) |
| { |
| if (r->underflow && r->overflow) { |
| return; |
| } |
| fprintf(stderr, " RANGE["); |
| if (r->underflow) { |
| fprintf(stderr, "--.."); |
| } else if (r->min == ZEND_LONG_MIN) { |
| fprintf(stderr, "MIN.."); |
| } else { |
| fprintf(stderr, ZEND_LONG_FMT "..", r->min); |
| } |
| if (r->overflow) { |
| fprintf(stderr, "++]"); |
| } else if (r->max == ZEND_LONG_MAX) { |
| fprintf(stderr, "MAX]"); |
| } else { |
| fprintf(stderr, ZEND_LONG_FMT "]", r->max); |
| } |
| } |
|
|
| static void zend_dump_type_info(uint32_t info, zend_class_entry *ce, int is_instanceof, uint32_t dump_flags) |
| { |
| bool first = 1; |
|
|
| fprintf(stderr, " ["); |
| if (info & MAY_BE_GUARD) { |
| fprintf(stderr, "!"); |
| } |
| if (info & MAY_BE_UNDEF) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "undef"); |
| } |
| if (info & MAY_BE_INDIRECT) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "ind"); |
| } |
| if (info & MAY_BE_REF) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "ref"); |
| } |
| if (dump_flags & ZEND_DUMP_RC_INFERENCE) { |
| if (info & MAY_BE_RC1) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "rc1"); |
| } |
| if (info & MAY_BE_RCN) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "rcn"); |
| } |
| } |
| if (info & MAY_BE_CLASS) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "class"); |
| if (ce) { |
| if (is_instanceof) { |
| fprintf(stderr, " (instanceof %s)", ce->name->val); |
| } else { |
| fprintf(stderr, " (%s)", ce->name->val); |
| } |
| } |
| } else if ((info & MAY_BE_ANY) == MAY_BE_ANY) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "any"); |
| } else { |
| if (info & MAY_BE_NULL) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "null"); |
| } |
| if ((info & MAY_BE_FALSE) && (info & MAY_BE_TRUE)) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "bool"); |
| } else if (info & MAY_BE_FALSE) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "false"); |
| } else if (info & MAY_BE_TRUE) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "true"); |
| } |
| if (info & MAY_BE_LONG) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "long"); |
| } |
| if (info & MAY_BE_DOUBLE) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "double"); |
| } |
| if (info & MAY_BE_STRING) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "string"); |
| } |
| if (info & MAY_BE_ARRAY) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| if (info & MAY_BE_PACKED_GUARD) { |
| fprintf(stderr, "!"); |
| } |
| if (MAY_BE_EMPTY_ONLY(info)) { |
| fprintf(stderr, "empty "); |
| } else if (MAY_BE_PACKED_ONLY(info)) { |
| fprintf(stderr, "packed "); |
| } else if (MAY_BE_HASH_ONLY(info)) { |
| fprintf(stderr, "hash "); |
| } else if ((info & MAY_BE_ARRAY_KEY_ANY) != MAY_BE_ARRAY_KEY_ANY && (info & MAY_BE_ARRAY_KEY_ANY) != 0) { |
| bool afirst = 1; |
| fprintf(stderr, "["); |
| if (info & MAY_BE_ARRAY_EMPTY) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "empty"); |
| } |
| if (MAY_BE_PACKED(info)) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "packed"); |
| } |
| if (MAY_BE_HASH(info)) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "hash"); |
| } |
| fprintf(stderr, "] "); |
| } |
| fprintf(stderr, "array"); |
| if ((info & (MAY_BE_ARRAY_KEY_LONG|MAY_BE_ARRAY_KEY_STRING)) != 0 && |
| ((info & MAY_BE_ARRAY_KEY_LONG) == 0 || |
| (info & MAY_BE_ARRAY_KEY_STRING) == 0)) { |
| bool afirst = 1; |
| fprintf(stderr, " ["); |
| if (info & MAY_BE_ARRAY_KEY_LONG) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "long"); |
| } |
| if (info & MAY_BE_ARRAY_KEY_STRING) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "string"); |
| } |
| fprintf(stderr, "]"); |
| } |
| if (info & (MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF)) { |
| bool afirst = 1; |
| fprintf(stderr, " of ["); |
| if ((info & MAY_BE_ARRAY_OF_ANY) == MAY_BE_ARRAY_OF_ANY) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "any"); |
| } else { |
| if (info & MAY_BE_ARRAY_OF_NULL) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "null"); |
| } |
| if (info & MAY_BE_ARRAY_OF_FALSE) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "false"); |
| } |
| if (info & MAY_BE_ARRAY_OF_TRUE) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "true"); |
| } |
| if (info & MAY_BE_ARRAY_OF_LONG) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "long"); |
| } |
| if (info & MAY_BE_ARRAY_OF_DOUBLE) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "double"); |
| } |
| if (info & MAY_BE_ARRAY_OF_STRING) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "string"); |
| } |
| if (info & MAY_BE_ARRAY_OF_ARRAY) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "array"); |
| } |
| if (info & MAY_BE_ARRAY_OF_OBJECT) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "object"); |
| } |
| if (info & MAY_BE_ARRAY_OF_RESOURCE) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "resource"); |
| } |
| } |
| if (info & MAY_BE_ARRAY_OF_REF) { |
| if (afirst) afirst = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "ref"); |
| } |
| fprintf(stderr, "]"); |
| } |
| } |
| if (info & MAY_BE_OBJECT) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "object"); |
| if (ce) { |
| if (is_instanceof) { |
| fprintf(stderr, " (instanceof %s)", ce->name->val); |
| } else { |
| fprintf(stderr, " (%s)", ce->name->val); |
| } |
| } |
| } |
| if (info & MAY_BE_RESOURCE) { |
| if (first) first = 0; else fprintf(stderr, ", "); |
| fprintf(stderr, "resource"); |
| } |
| } |
| fprintf(stderr, "]"); |
| } |
|
|
| static void zend_dump_ssa_var_info(const zend_ssa *ssa, int ssa_var_num, uint32_t dump_flags) |
| { |
| zend_dump_type_info( |
| ssa->var_info[ssa_var_num].type, |
| ssa->var_info[ssa_var_num].ce, |
| ssa->var_info[ssa_var_num].ce ? |
| ssa->var_info[ssa_var_num].is_instanceof : 0, |
| dump_flags); |
| } |
|
|
| ZEND_API void zend_dump_ssa_var(const zend_op_array *op_array, const zend_ssa *ssa, int ssa_var_num, uint8_t var_type, uint32_t var_num, uint32_t dump_flags) |
| { |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, "#%d.", ssa_var_num); |
| } else { |
| fprintf(stderr, "#?."); |
| } |
| zend_dump_var(op_array, (var_num < op_array->last_var ? IS_CV : var_type), var_num); |
|
|
| if (ssa_var_num >= 0 && ssa->vars) { |
| if (ssa->vars[ssa_var_num].no_val) { |
| fprintf(stderr, " NOVAL"); |
| } |
| if (ssa->vars[ssa_var_num].escape_state == ESCAPE_STATE_NO_ESCAPE) { |
| fprintf(stderr, " NOESC"); |
| } |
| if (ssa->var_info) { |
| zend_dump_ssa_var_info(ssa, ssa_var_num, dump_flags); |
| if (ssa->var_info[ssa_var_num].has_range) { |
| zend_dump_range(&ssa->var_info[ssa_var_num].range); |
| } |
| } |
| } |
| } |
|
|
| static void zend_dump_type_constraint(const zend_op_array *op_array, const zend_ssa *ssa, const zend_ssa_type_constraint *constraint, uint32_t dump_flags) |
| { |
| fprintf(stderr, " TYPE"); |
| zend_dump_type_info(constraint->type_mask, constraint->ce, 1, dump_flags); |
| } |
|
|
| static void zend_dump_range_constraint(const zend_op_array *op_array, const zend_ssa *ssa, const zend_ssa_range_constraint *r, uint32_t dump_flags) |
| { |
| if (r->range.underflow && r->range.overflow) { |
| return; |
| } |
| fprintf(stderr, " RANGE"); |
| if (r->negative) { |
| fprintf(stderr, "~"); |
| } |
| fprintf(stderr, "["); |
| if (r->range.underflow) { |
| fprintf(stderr, "-- .. "); |
| } else { |
| if (r->min_ssa_var >= 0) { |
| zend_dump_ssa_var(op_array, ssa, r->min_ssa_var, (r->min_var < op_array->last_var ? IS_CV : 0), r->min_var, dump_flags); |
| if (r->range.min > 0) { |
| fprintf(stderr, " + " ZEND_LONG_FMT, r->range.min); |
| } else if (r->range.min < 0) { |
| fprintf(stderr, " - " ZEND_LONG_FMT, -r->range.min); |
| } |
| fprintf(stderr, " .. "); |
| } else { |
| fprintf(stderr, ZEND_LONG_FMT " .. ", r->range.min); |
| } |
| } |
| if (r->range.overflow) { |
| fprintf(stderr, "++]"); |
| } else { |
| if (r->max_ssa_var >= 0) { |
| zend_dump_ssa_var(op_array, ssa, r->max_ssa_var, (r->max_var < op_array->last_var ? IS_CV : 0), r->max_var, dump_flags); |
| if (r->range.max > 0) { |
| fprintf(stderr, " + " ZEND_LONG_FMT, r->range.max); |
| } else if (r->range.max < 0) { |
| fprintf(stderr, " - " ZEND_LONG_FMT, -r->range.max); |
| } |
| fprintf(stderr, "]"); |
| } else { |
| fprintf(stderr, ZEND_LONG_FMT "]", r->range.max); |
| } |
| } |
| } |
|
|
| ZEND_API void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *b, const zend_op *opline, uint32_t dump_flags, const zend_ssa *ssa, const zend_ssa_op *ssa_op) |
| { |
| const char *name = zend_get_opcode_name(opline->opcode); |
| uint32_t flags = zend_get_opcode_flags(opline->opcode); |
| uint32_t n = 0; |
|
|
| if (!ssa_op || ssa_op->result_use < 0) { |
| if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) { |
| if (ssa_op && ssa_op->result_def >= 0) { |
| int ssa_var_num = ssa_op->result_def; |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->result_type, EX_VAR_TO_NUM(opline->result.var), dump_flags); |
| } else { |
| zend_dump_var(op_array, opline->result_type, EX_VAR_TO_NUM(opline->result.var)); |
| } |
| fprintf(stderr, " = "); |
| } |
| } |
|
|
| if (name) { |
| fprintf(stderr, "%s", (name + 5)); |
| } else { |
| fprintf(stderr, "OP_%d", (int)opline->opcode); |
| } |
|
|
| if (ZEND_OP_IS_FRAMELESS_ICALL(opline->opcode)) { |
| zend_function *func = ZEND_FLF_FUNC(opline); |
| fprintf(stderr, "(%s)", ZSTR_VAL(func->common.function_name)); |
| } |
|
|
| if (ZEND_VM_EXT_NUM == (flags & ZEND_VM_EXT_MASK)) { |
| fprintf(stderr, " %u", opline->extended_value); |
| } else if (ZEND_VM_EXT_OP == (flags & ZEND_VM_EXT_MASK)) { |
| fprintf(stderr, " (%s)", zend_get_opcode_name(opline->extended_value) + 5); |
| } else if (ZEND_VM_EXT_TYPE == (flags & ZEND_VM_EXT_MASK)) { |
| switch (opline->extended_value) { |
| case IS_NULL: |
| fprintf(stderr, " (null)"); |
| break; |
| case IS_FALSE: |
| fprintf(stderr, " (false)"); |
| break; |
| case IS_TRUE: |
| fprintf(stderr, " (true)"); |
| break; |
| case IS_LONG: |
| fprintf(stderr, " (long)"); |
| break; |
| case IS_DOUBLE: |
| fprintf(stderr, " (double)"); |
| break; |
| case IS_STRING: |
| fprintf(stderr, " (string)"); |
| break; |
| case IS_ARRAY: |
| fprintf(stderr, " (array)"); |
| break; |
| case IS_OBJECT: |
| fprintf(stderr, " (object)"); |
| break; |
| case IS_RESOURCE: |
| fprintf(stderr, " (resource)"); |
| break; |
| case _IS_BOOL: |
| fprintf(stderr, " (bool)"); |
| break; |
| case IS_CALLABLE: |
| fprintf(stderr, " (callable)"); |
| break; |
| case IS_VOID: |
| fprintf(stderr, " (void)"); |
| break; |
| case IS_NEVER: |
| fprintf(stderr, " (never)"); |
| break; |
| default: |
| fprintf(stderr, " (\?\?\?)"); |
| break; |
| } |
| } else if (ZEND_VM_EXT_TYPE_MASK == (flags & ZEND_VM_EXT_MASK)) { |
| switch (opline->extended_value) { |
| case (1<<IS_NULL): |
| fprintf(stderr, " (null)"); |
| break; |
| case (1<<IS_FALSE): |
| fprintf(stderr, " (false)"); |
| break; |
| case (1<<IS_TRUE): |
| fprintf(stderr, " (true)"); |
| break; |
| case (1<<IS_LONG): |
| fprintf(stderr, " (long)"); |
| break; |
| case (1<<IS_DOUBLE): |
| fprintf(stderr, " (double)"); |
| break; |
| case (1<<IS_STRING): |
| fprintf(stderr, " (string)"); |
| break; |
| case (1<<IS_ARRAY): |
| fprintf(stderr, " (array)"); |
| break; |
| case (1<<IS_OBJECT): |
| fprintf(stderr, " (object)"); |
| break; |
| case (1<<IS_RESOURCE): |
| fprintf(stderr, " (resource)"); |
| break; |
| case ((1<<IS_FALSE)|(1<<IS_TRUE)): |
| fprintf(stderr, " (bool)"); |
| break; |
| default: |
| fprintf(stderr, " TYPE"); |
| zend_dump_type_info(opline->extended_value, NULL, 0, dump_flags); |
| break; |
| } |
| } else if (ZEND_VM_EXT_EVAL == (flags & ZEND_VM_EXT_MASK)) { |
| switch (opline->extended_value) { |
| case ZEND_EVAL: |
| fprintf(stderr, " (eval)"); |
| break; |
| case ZEND_INCLUDE: |
| fprintf(stderr, " (include)"); |
| break; |
| case ZEND_INCLUDE_ONCE: |
| fprintf(stderr, " (include_once)"); |
| break; |
| case ZEND_REQUIRE: |
| fprintf(stderr, " (require)"); |
| break; |
| case ZEND_REQUIRE_ONCE: |
| fprintf(stderr, " (require_once)"); |
| break; |
| default: |
| fprintf(stderr, " (\?\?\?)"); |
| break; |
| } |
| } else if (ZEND_VM_EXT_SRC == (flags & ZEND_VM_EXT_MASK)) { |
| if (opline->extended_value == ZEND_RETURNS_VALUE) { |
| fprintf(stderr, " (value)"); |
| } else if (opline->extended_value & ZEND_RETURNS_FUNCTION) { |
| fprintf(stderr, " (function)"); |
| } |
| } else { |
| if (ZEND_VM_EXT_VAR_FETCH & flags) { |
| if (opline->extended_value & ZEND_FETCH_GLOBAL) { |
| fprintf(stderr, " (global)"); |
| } else if (opline->extended_value & ZEND_FETCH_LOCAL) { |
| fprintf(stderr, " (local)"); |
| } else if (opline->extended_value & ZEND_FETCH_GLOBAL_LOCK) { |
| fprintf(stderr, " (global+lock)"); |
| } |
| } |
| if (ZEND_VM_EXT_ISSET & flags) { |
| if (!(opline->extended_value & ZEND_ISEMPTY)) { |
| fprintf(stderr, " (isset)"); |
| } else { |
| fprintf(stderr, " (empty)"); |
| } |
| } |
| if (ZEND_VM_EXT_ARRAY_INIT & flags) { |
| fprintf(stderr, " %u", opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT); |
| if (!(opline->extended_value & ZEND_ARRAY_NOT_PACKED)) { |
| fprintf(stderr, " (packed)"); |
| } |
| } |
| if (ZEND_VM_EXT_REF & flags) { |
| if (opline->extended_value & ZEND_ARRAY_ELEMENT_REF) { |
| fprintf(stderr, " (ref)"); |
| } |
| } |
| if ((ZEND_VM_EXT_DIM_WRITE|ZEND_VM_EXT_FETCH_REF) & flags) { |
| uint32_t obj_flags = opline->extended_value & ZEND_FETCH_OBJ_FLAGS; |
| if (obj_flags == ZEND_FETCH_REF) { |
| fprintf(stderr, " (ref)"); |
| } else if (obj_flags == ZEND_FETCH_DIM_WRITE) { |
| fprintf(stderr, " (dim write)"); |
| } |
| } |
| } |
|
|
| if (opline->op1_type == IS_CONST) { |
| zend_dump_const(CRT_CONSTANT(opline->op1)); |
| } else if (opline->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) { |
| if (ssa_op) { |
| int ssa_var_num = ssa_op->op1_use; |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, " "); |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->op1_type, EX_VAR_TO_NUM(opline->op1.var), dump_flags); |
| } else if (ssa_op->op1_def < 0) { |
| fprintf(stderr, " "); |
| zend_dump_var(op_array, opline->op1_type, EX_VAR_TO_NUM(opline->op1.var)); |
| } |
| } else { |
| fprintf(stderr, " "); |
| zend_dump_var(op_array, opline->op1_type, EX_VAR_TO_NUM(opline->op1.var)); |
| } |
| if (ssa_op) { |
| int ssa_var_num = ssa_op->op1_def; |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, " -> "); |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->op1_type, EX_VAR_TO_NUM(opline->op1.var), dump_flags); |
| } |
| } |
| } else { |
| uint32_t op1_flags = ZEND_VM_OP1_FLAGS(flags); |
| if (ZEND_VM_OP_JMP_ADDR == (op1_flags & ZEND_VM_OP_MASK)) { |
| if (b) { |
| fprintf(stderr, " BB%d", b->successors[n++]); |
| } else { |
| fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes)); |
| } |
| } else { |
| zend_dump_unused_op(opline, opline->op1, op1_flags); |
| } |
| } |
|
|
| if (opline->op2_type == IS_CONST) { |
| zval *op = CRT_CONSTANT(opline->op2); |
| if ( |
| opline->opcode == ZEND_SWITCH_LONG |
| || opline->opcode == ZEND_SWITCH_STRING |
| || opline->opcode == ZEND_MATCH |
| ) { |
| HashTable *jumptable = Z_ARRVAL_P(op); |
| zend_string *key; |
| zend_ulong num_key; |
| zval *zv; |
| ZEND_HASH_FOREACH_KEY_VAL(jumptable, num_key, key, zv) { |
| if (key) { |
| fprintf(stderr, " \"%s\":", ZSTR_VAL(key)); |
| } else { |
| fprintf(stderr, " " ZEND_LONG_FMT ":", num_key); |
| } |
| if (b) { |
| fprintf(stderr, " BB%d,", b->successors[n++]); |
| } else { |
| fprintf(stderr, " %04u,", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv))); |
| } |
| } ZEND_HASH_FOREACH_END(); |
| fprintf(stderr, " default:"); |
| } else { |
| zend_dump_const(op); |
| } |
| } else if (opline->op2_type & (IS_CV|IS_VAR|IS_TMP_VAR)) { |
| if (ssa_op) { |
| int ssa_var_num = ssa_op->op2_use; |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, " "); |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->op2_type, EX_VAR_TO_NUM(opline->op2.var), dump_flags); |
| } else if (ssa_op->op2_def < 0) { |
| fprintf(stderr, " "); |
| zend_dump_var(op_array, opline->op2_type, EX_VAR_TO_NUM(opline->op2.var)); |
| } |
| } else { |
| fprintf(stderr, " "); |
| zend_dump_var(op_array, opline->op2_type, EX_VAR_TO_NUM(opline->op2.var)); |
| } |
| if (ssa_op) { |
| int ssa_var_num = ssa_op->op2_def; |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, " -> "); |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->op2_type, EX_VAR_TO_NUM(opline->op2.var), dump_flags); |
| } |
| } |
| } else { |
| uint32_t op2_flags = ZEND_VM_OP2_FLAGS(flags); |
| if (ZEND_VM_OP_JMP_ADDR == (op2_flags & ZEND_VM_OP_MASK)) { |
| if (opline->opcode != ZEND_CATCH || !(opline->extended_value & ZEND_LAST_CATCH)) { |
| if (b) { |
| fprintf(stderr, " BB%d", b->successors[n++]); |
| } else { |
| fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes)); |
| } |
| } |
| } else { |
| zend_dump_unused_op(opline, opline->op2, op2_flags); |
| } |
| } |
|
|
| if (ZEND_VM_EXT_JMP_ADDR == (flags & ZEND_VM_EXT_MASK)) { |
| if (b) { |
| fprintf(stderr, " BB%d", b->successors[n++]); |
| } else { |
| fprintf(stderr, " %04u", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value)); |
| } |
| } |
| if (opline->result_type == IS_CONST) { |
| zend_dump_const(CRT_CONSTANT(opline->result)); |
| #if 0 |
| } else if (opline->result_type & IS_SMART_BRANCH_JMPZ) { |
| fprintf(stderr, " jmpz"); |
| } else if (opline->result_type & IS_SMART_BRANCH_JMPNZ) { |
| fprintf(stderr, " jmpnz"); |
| #endif |
| } else if (ssa_op && ssa_op->result_use >= 0) { |
| if (opline->result_type & (IS_CV|IS_VAR|IS_TMP_VAR)) { |
| if (ssa_op) { |
| int ssa_var_num = ssa_op->result_use; |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, " "); |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->result_type, EX_VAR_TO_NUM(opline->result.var), dump_flags); |
| } |
| } else { |
| fprintf(stderr, " "); |
| zend_dump_var(op_array, opline->result_type, EX_VAR_TO_NUM(opline->result.var)); |
| } |
| if (ssa_op) { |
| int ssa_var_num = ssa_op->result_def; |
| if (ssa_var_num >= 0) { |
| fprintf(stderr, " -> "); |
| zend_dump_ssa_var(op_array, ssa, ssa_var_num, opline->result_type, EX_VAR_TO_NUM(opline->result.var), dump_flags); |
| } |
| } |
| } |
| } |
| } |
|
|
| ZEND_API void zend_dump_op_line(const zend_op_array *op_array, const zend_basic_block *b, const zend_op *opline, uint32_t dump_flags, const void *data) |
| { |
| int len = 0; |
| const zend_ssa *ssa = NULL; |
| zend_ssa_op *ssa_op = NULL; |
|
|
| if (dump_flags & ZEND_DUMP_LINE_NUMBERS) { |
| fprintf(stderr, "L%04u ", opline->lineno); |
| } |
|
|
| len = fprintf(stderr, "%04u", (uint32_t)(opline - op_array->opcodes)); |
| fprintf(stderr, "%*c", 5-len, ' '); |
|
|
| if (dump_flags & ZEND_DUMP_SSA) { |
| ssa = (const zend_ssa*)data; |
| if (ssa && ssa->ops) { |
| ssa_op = &ssa->ops[opline - op_array->opcodes]; |
| } |
| } |
|
|
| zend_dump_op(op_array, b, opline, dump_flags, ssa, ssa_op); |
| fprintf(stderr, "\n"); |
| } |
|
|
| static void zend_dump_block_info(const zend_cfg *cfg, int n, uint32_t dump_flags) |
| { |
| zend_basic_block *b = cfg->blocks + n; |
|
|
| if (n > 0) { |
| fprintf(stderr, "\n"); |
| } |
| fprintf(stderr, "BB%d:\n ;", n); |
| if (b->flags & ZEND_BB_START) { |
| fprintf(stderr, " start"); |
| } |
| if (b->flags & ZEND_BB_RECV_ENTRY) { |
| fprintf(stderr, " recv"); |
| } |
| if (b->flags & ZEND_BB_FOLLOW) { |
| fprintf(stderr, " follow"); |
| } |
| if (b->flags & ZEND_BB_TARGET) { |
| fprintf(stderr, " target"); |
| } |
| if (b->flags & ZEND_BB_EXIT) { |
| fprintf(stderr, " exit"); |
| } |
| if (b->flags & (ZEND_BB_ENTRY|ZEND_BB_RECV_ENTRY)) { |
| fprintf(stderr, " entry"); |
| } |
| if (b->flags & ZEND_BB_TRY) { |
| fprintf(stderr, " try"); |
| } |
| if (b->flags & ZEND_BB_CATCH) { |
| fprintf(stderr, " catch"); |
| } |
| if (b->flags & ZEND_BB_FINALLY) { |
| fprintf(stderr, " finally"); |
| } |
| if (b->flags & ZEND_BB_FINALLY_END) { |
| fprintf(stderr, " finally_end"); |
| } |
| if (!(dump_flags & ZEND_DUMP_HIDE_UNREACHABLE) && !(b->flags & ZEND_BB_REACHABLE)) { |
| fprintf(stderr, " unreachable"); |
| } |
| if (b->flags & ZEND_BB_UNREACHABLE_FREE) { |
| fprintf(stderr, " unreachable_free"); |
| } |
| if (b->flags & ZEND_BB_LOOP_HEADER) { |
| fprintf(stderr, " loop_header"); |
| } |
| if (b->flags & ZEND_BB_IRREDUCIBLE_LOOP) { |
| fprintf(stderr, " irreducible"); |
| } |
| if (b->len != 0) { |
| fprintf(stderr, " lines=[%d-%d]", b->start, b->start + b->len - 1); |
| } else { |
| fprintf(stderr, " empty"); |
| } |
| fprintf(stderr, "\n"); |
|
|
| if (b->predecessors_count) { |
| int *p = cfg->predecessors + b->predecessor_offset; |
| int *end = p + b->predecessors_count; |
|
|
| fprintf(stderr, " ; from=(BB%d", *p); |
| for (p++; p < end; p++) { |
| fprintf(stderr, ", BB%d", *p); |
| } |
| fprintf(stderr, ")\n"); |
| } |
|
|
| if (b->successors_count > 0) { |
| int s; |
| fprintf(stderr, " ; to=(BB%d", b->successors[0]); |
| for (s = 1; s < b->successors_count; s++) { |
| fprintf(stderr, ", BB%d", b->successors[s]); |
| } |
| fprintf(stderr, ")\n"); |
| } |
|
|
| if (b->idom >= 0) { |
| fprintf(stderr, " ; idom=BB%d\n", b->idom); |
| } |
| if (b->level >= 0) { |
| fprintf(stderr, " ; level=%d\n", b->level); |
| } |
| if (b->loop_header >= 0) { |
| fprintf(stderr, " ; loop_header=%d\n", b->loop_header); |
| } |
| if (b->children >= 0) { |
| int j = b->children; |
| fprintf(stderr, " ; children=(BB%d", j); |
| j = cfg->blocks[j].next_child; |
| while (j >= 0) { |
| fprintf(stderr, ", BB%d", j); |
| j = cfg->blocks[j].next_child; |
| } |
| fprintf(stderr, ")\n"); |
| } |
| } |
|
|
| static void zend_dump_block_header(const zend_cfg *cfg, const zend_op_array *op_array, const zend_ssa *ssa, int n, uint32_t dump_flags) |
| { |
| zend_dump_block_info(cfg, n, dump_flags); |
| if (ssa && ssa->blocks && ssa->blocks[n].phis) { |
| zend_ssa_phi *p = ssa->blocks[n].phis; |
|
|
| do { |
| int j; |
|
|
| fprintf(stderr, " "); |
| zend_dump_ssa_var(op_array, ssa, p->ssa_var, 0, p->var, dump_flags); |
| if (p->pi < 0) { |
| fprintf(stderr, " = Phi("); |
| for (j = 0; j < cfg->blocks[n].predecessors_count; j++) { |
| if (j > 0) { |
| fprintf(stderr, ", "); |
| } |
| zend_dump_ssa_var(op_array, ssa, p->sources[j], 0, p->var, dump_flags); |
| } |
| fprintf(stderr, ")\n"); |
| } else { |
| fprintf(stderr, " = Pi<BB%d>(", p->pi); |
| zend_dump_ssa_var(op_array, ssa, p->sources[0], 0, p->var, dump_flags); |
| fprintf(stderr, " &"); |
| if (p->has_range_constraint) { |
| zend_dump_range_constraint(op_array, ssa, &p->constraint.range, dump_flags); |
| } else { |
| zend_dump_type_constraint(op_array, ssa, &p->constraint.type, dump_flags); |
| } |
| fprintf(stderr, ")\n"); |
| } |
| p = p->next; |
| } while (p); |
| } |
| } |
|
|
| void zend_dump_op_array_name(const zend_op_array *op_array) |
| { |
| if (op_array->function_name) { |
| if (op_array->scope && op_array->scope->name) { |
| fprintf(stderr, "%s::%s", op_array->scope->name->val, op_array->function_name->val); |
| } else { |
| fprintf(stderr, "%s", op_array->function_name->val); |
| } |
| } else { |
| fprintf(stderr, "%s", "$_main"); |
| } |
| } |
|
|
| ZEND_API void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_flags, const char *msg, const void *data) |
| { |
| const zend_cfg *cfg = NULL; |
| const zend_ssa *ssa = NULL; |
| zend_func_info *func_info = NULL; |
| uint32_t func_flags = 0; |
|
|
| if (dump_flags & (ZEND_DUMP_CFG|ZEND_DUMP_SSA)) { |
| cfg = (const zend_cfg*)data; |
| if (!cfg->blocks) { |
| cfg = data = NULL; |
| } |
| } |
| if (dump_flags & ZEND_DUMP_SSA) { |
| ssa = (const zend_ssa*)data; |
| } |
|
|
| func_info = ZEND_FUNC_INFO(op_array); |
| if (func_info) { |
| func_flags = func_info->flags; |
| } |
|
|
| fprintf(stderr, "\n"); |
| zend_dump_op_array_name(op_array); |
| fprintf(stderr, ":\n ; (lines=%d, args=%d", |
| op_array->last, |
| op_array->num_args); |
| fprintf(stderr, ", vars=%d, tmps=%d", op_array->last_var, op_array->T); |
| if (ssa) { |
| fprintf(stderr, ", ssa_vars=%d", ssa->vars_count); |
| } |
| if (func_flags & ZEND_FUNC_INDIRECT_VAR_ACCESS) { |
| fprintf(stderr, ", dynamic"); |
| } |
| if (func_flags & ZEND_FUNC_RECURSIVE) { |
| fprintf(stderr, ", recursive"); |
| if (func_flags & ZEND_FUNC_RECURSIVE_DIRECTLY) { |
| fprintf(stderr, " directly"); |
| } |
| if (func_flags & ZEND_FUNC_RECURSIVE_INDIRECTLY) { |
| fprintf(stderr, " indirectly"); |
| } |
| } |
| if (func_flags & ZEND_FUNC_IRREDUCIBLE) { |
| fprintf(stderr, ", irreducible"); |
| } |
| if (func_flags & ZEND_FUNC_NO_LOOPS) { |
| fprintf(stderr, ", no_loops"); |
| } |
| if (func_flags & ZEND_FUNC_HAS_EXTENDED_STMT) { |
| fprintf(stderr, ", extended_stmt"); |
| } |
| if (func_flags & ZEND_FUNC_HAS_EXTENDED_FCALL) { |
| fprintf(stderr, ", extended_fcall"); |
| } |
| |
| #if 0 |
| if (info->flags & ZEND_JIT_FUNC_NO_IN_MEM_CVS) { |
| fprintf(stderr, ", no_in_mem_cvs"); |
| } |
| if (info->flags & ZEND_JIT_FUNC_NO_USED_ARGS) { |
| fprintf(stderr, ", no_used_args"); |
| } |
| if (info->flags & ZEND_JIT_FUNC_NO_SYMTAB) { |
| fprintf(stderr, ", no_symtab"); |
| } |
| if (info->flags & ZEND_JIT_FUNC_NO_FRAME) { |
| fprintf(stderr, ", no_frame"); |
| } |
| if (info->flags & ZEND_JIT_FUNC_INLINE) { |
| fprintf(stderr, ", inline"); |
| } |
| #endif |
| fprintf(stderr, ")\n"); |
| if (msg) { |
| fprintf(stderr, " ; (%s)\n", msg); |
| } |
| fprintf(stderr, " ; %s:%u-%u\n", op_array->filename->val, op_array->line_start, op_array->line_end); |
|
|
| if (func_info) { |
| fprintf(stderr, " ; return "); |
| zend_dump_type_info(func_info->return_info.type, func_info->return_info.ce, func_info->return_info.is_instanceof, dump_flags); |
| zend_dump_range(&func_info->return_info.range); |
| fprintf(stderr, "\n"); |
| } |
|
|
| if (ssa && ssa->var_info) { |
| for (uint32_t i = 0; i < op_array->last_var; i++) { |
| fprintf(stderr, " ; "); |
| zend_dump_ssa_var(op_array, ssa, i, IS_CV, i, dump_flags); |
| fprintf(stderr, "\n"); |
| } |
| } |
|
|
| if (cfg) { |
| int n; |
| zend_basic_block *b; |
|
|
| for (n = 0; n < cfg->blocks_count; n++) { |
| b = cfg->blocks + n; |
| if (!(dump_flags & ZEND_DUMP_HIDE_UNREACHABLE) || (b->flags & ZEND_BB_REACHABLE)) { |
| const zend_op *opline; |
| const zend_op *end; |
|
|
| zend_dump_block_header(cfg, op_array, ssa, n, dump_flags); |
| opline = op_array->opcodes + b->start; |
| end = opline + b->len; |
| while (opline < end) { |
| zend_dump_op_line(op_array, b, opline, dump_flags, data); |
| opline++; |
| } |
| } |
| } |
| if (op_array->last_live_range && (dump_flags & ZEND_DUMP_LIVE_RANGES)) { |
| fprintf(stderr, "LIVE RANGES:\n"); |
| for (int i = 0; i < op_array->last_live_range; i++) { |
| fprintf(stderr, |
| " %u: %04u - %04u ", |
| EX_VAR_TO_NUM(op_array->live_range[i].var & ~ZEND_LIVE_MASK), |
| op_array->live_range[i].start, |
| op_array->live_range[i].end); |
| switch (op_array->live_range[i].var & ZEND_LIVE_MASK) { |
| case ZEND_LIVE_TMPVAR: |
| fprintf(stderr, "(tmp/var)\n"); |
| break; |
| case ZEND_LIVE_LOOP: |
| fprintf(stderr, "(loop)\n"); |
| break; |
| case ZEND_LIVE_SILENCE: |
| fprintf(stderr, "(silence)\n"); |
| break; |
| case ZEND_LIVE_ROPE: |
| fprintf(stderr, "(rope)\n"); |
| break; |
| case ZEND_LIVE_NEW: |
| fprintf(stderr, "(new)\n"); |
| break; |
| } |
| } |
| } |
| if (op_array->last_try_catch) { |
| fprintf(stderr, "EXCEPTION TABLE:\n"); |
| for (int i = 0; i < op_array->last_try_catch; i++) { |
| fprintf(stderr, " BB%u", |
| cfg->map[op_array->try_catch_array[i].try_op]); |
| if (op_array->try_catch_array[i].catch_op) { |
| fprintf(stderr, ", BB%u", |
| cfg->map[op_array->try_catch_array[i].catch_op]); |
| } else { |
| fprintf(stderr, ", -"); |
| } |
| if (op_array->try_catch_array[i].finally_op) { |
| fprintf(stderr, ", BB%u", |
| cfg->map[op_array->try_catch_array[i].finally_op]); |
| } else { |
| fprintf(stderr, ", -"); |
| } |
| if (op_array->try_catch_array[i].finally_end) { |
| fprintf(stderr, ", BB%u\n", |
| cfg->map[op_array->try_catch_array[i].finally_end]); |
| } else { |
| fprintf(stderr, ", -\n"); |
| } |
| } |
| } |
| } else { |
| const zend_op *opline = op_array->opcodes; |
| const zend_op *end = opline + op_array->last; |
|
|
| while (opline < end) { |
| zend_dump_op_line(op_array, NULL, opline, dump_flags, data); |
| opline++; |
| } |
| if (op_array->last_live_range && (dump_flags & ZEND_DUMP_LIVE_RANGES)) { |
| fprintf(stderr, "LIVE RANGES:\n"); |
| for (int i = 0; i < op_array->last_live_range; i++) { |
| fprintf(stderr, |
| " %u: %04u - %04u ", |
| EX_VAR_TO_NUM(op_array->live_range[i].var & ~ZEND_LIVE_MASK), |
| op_array->live_range[i].start, |
| op_array->live_range[i].end); |
| switch (op_array->live_range[i].var & ZEND_LIVE_MASK) { |
| case ZEND_LIVE_TMPVAR: |
| fprintf(stderr, "(tmp/var)\n"); |
| break; |
| case ZEND_LIVE_LOOP: |
| fprintf(stderr, "(loop)\n"); |
| break; |
| case ZEND_LIVE_SILENCE: |
| fprintf(stderr, "(silence)\n"); |
| break; |
| case ZEND_LIVE_ROPE: |
| fprintf(stderr, "(rope)\n"); |
| break; |
| case ZEND_LIVE_NEW: |
| fprintf(stderr, "(new)\n"); |
| break; |
| } |
| } |
| } |
| if (op_array->last_try_catch) { |
| fprintf(stderr, "EXCEPTION TABLE:\n"); |
| for (int i = 0; i < op_array->last_try_catch; i++) { |
| fprintf(stderr, |
| " %04u", |
| op_array->try_catch_array[i].try_op); |
|
|
| if (op_array->try_catch_array[i].catch_op) { |
| fprintf(stderr, |
| ", %04u", |
| op_array->try_catch_array[i].catch_op); |
| } else { |
| fprintf(stderr, ", -"); |
| } |
| if (op_array->try_catch_array[i].finally_op) { |
| fprintf(stderr, |
| ", %04u", |
| op_array->try_catch_array[i].finally_op); |
| } else { |
| fprintf(stderr, ", -"); |
| } |
| if (op_array->try_catch_array[i].finally_end) { |
| fprintf(stderr, |
| ", %04u", |
| op_array->try_catch_array[i].finally_end); |
| } else { |
| fprintf(stderr, ", -\n"); |
| } |
| } |
| } |
| } |
| } |
|
|
| void zend_dump_dominators(const zend_op_array *op_array, const zend_cfg *cfg) |
| { |
| int j; |
|
|
| fprintf(stderr, "\nDOMINATORS-TREE for \""); |
| zend_dump_op_array_name(op_array); |
| fprintf(stderr, "\"\n"); |
| for (j = 0; j < cfg->blocks_count; j++) { |
| zend_basic_block *b = cfg->blocks + j; |
| if (b->flags & ZEND_BB_REACHABLE) { |
| zend_dump_block_info(cfg, j, 0); |
| } |
| } |
| } |
|
|
| void zend_dump_ssa_variables(const zend_op_array *op_array, const zend_ssa *ssa, uint32_t dump_flags) |
| { |
| int j; |
|
|
| if (ssa->vars) { |
| fprintf(stderr, "\nSSA Variable for \""); |
| zend_dump_op_array_name(op_array); |
| fprintf(stderr, "\"\n"); |
|
|
| for (j = 0; j < ssa->vars_count; j++) { |
| fprintf(stderr, " "); |
| zend_dump_ssa_var(op_array, ssa, j, IS_CV, ssa->vars[j].var, dump_flags); |
| if (ssa->vars[j].scc >= 0) { |
| if (ssa->vars[j].scc_entry) { |
| fprintf(stderr, " *"); |
| } else { |
| fprintf(stderr, " "); |
| } |
| fprintf(stderr, "SCC=%d", ssa->vars[j].scc); |
| } |
| fprintf(stderr, "\n"); |
| } |
| } |
| } |
|
|
| static void zend_dump_var_set(const zend_op_array *op_array, const char *name, zend_bitset set) |
| { |
| bool first = 1; |
| uint32_t i; |
|
|
| fprintf(stderr, " ; %s = {", name); |
| for (i = 0; i < op_array->last_var + op_array->T; i++) { |
| if (zend_bitset_in(set, i)) { |
| if (first) { |
| first = 0; |
| } else { |
| fprintf(stderr, ", "); |
| } |
| zend_dump_var(op_array, IS_CV, i); |
| } |
| } |
| fprintf(stderr, "}\n"); |
| } |
|
|
| void zend_dump_dfg(const zend_op_array *op_array, const zend_cfg *cfg, const zend_dfg *dfg) |
| { |
| int j; |
| fprintf(stderr, "\nVariable Liveness for \""); |
| zend_dump_op_array_name(op_array); |
| fprintf(stderr, "\"\n"); |
|
|
| for (j = 0; j < cfg->blocks_count; j++) { |
| fprintf(stderr, " BB%d:\n", j); |
| zend_dump_var_set(op_array, "def", DFG_BITSET(dfg->def, dfg->size, j)); |
| zend_dump_var_set(op_array, "use", DFG_BITSET(dfg->use, dfg->size, j)); |
| zend_dump_var_set(op_array, "in ", DFG_BITSET(dfg->in, dfg->size, j)); |
| zend_dump_var_set(op_array, "out", DFG_BITSET(dfg->out, dfg->size, j)); |
| } |
| } |
|
|
| void zend_dump_phi_placement(const zend_op_array *op_array, const zend_ssa *ssa) |
| { |
| int j; |
| zend_ssa_block *ssa_blocks = ssa->blocks; |
| int blocks_count = ssa->cfg.blocks_count; |
|
|
| fprintf(stderr, "\nSSA Phi() Placement for \""); |
| zend_dump_op_array_name(op_array); |
| fprintf(stderr, "\"\n"); |
| for (j = 0; j < blocks_count; j++) { |
| if (ssa_blocks && ssa_blocks[j].phis) { |
| zend_ssa_phi *p = ssa_blocks[j].phis; |
| int first = 1; |
|
|
| fprintf(stderr, " BB%d:\n", j); |
| if (p->pi >= 0) { |
| fprintf(stderr, " ; pi={"); |
| } else { |
| fprintf(stderr, " ; phi={"); |
| } |
| do { |
| if (first) { |
| first = 0; |
| } else { |
| fprintf(stderr, ", "); |
| } |
| zend_dump_var(op_array, IS_CV, p->var); |
| p = p->next; |
| } while (p); |
| fprintf(stderr, "}\n"); |
| } |
| } |
| } |
|
|
