Make SSA dump format controlled by opcache.jit_debug more readable (always print...

This doesn't affect dumps controlled by opcache.opt_debug_level.

diff --git a/ext/opcache/Optimizer/zend_dump.c b/ext/opcache/Optimizer/zend_dump.c
index 1a18f8727a4c8a22d9435aee965c458f37f0ce70..e14ea642b5696e5c9b8b518a37e54273e62e3528 100644 (file)
--- a/ext/opcache/Optimizer/zend_dump.c
+++ b/ext/opcache/Optimizer/zend_dump.c
@@ -603,10 +603,10 @@ void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *b, cons
        } else {
                uint32_t op1_flags = ZEND_VM_OP1_FLAGS(flags);
                if (ZEND_VM_OP_JMP_ADDR == (op1_flags & ZEND_VM_OP_MASK)) {
-                       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
-                               fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes));
-                       } else if (b) {
+                       if (b) {
                                fprintf(stderr, " BB%d", b->successors[n++]);
+                       } else if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                               fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes));
                        } else {
                                fprintf(stderr, " L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->op1) - op_array->opcodes));
                        }
@@ -628,10 +628,10 @@ void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *b, cons
                                } else {
                                        fprintf(stderr, " " ZEND_LONG_FMT ":", num_key);
                                }
-                               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
-                                       fprintf(stderr, " %04u,", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
-                               } else if (b) {
+                               if (b) {
                                        fprintf(stderr, " BB%d,", b->successors[n++]);
+                               } else if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                                       fprintf(stderr, " %04u,", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
                                } else {
                                        fprintf(stderr, " L%u,", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, Z_LVAL_P(zv)));
                                }
@@ -665,10 +665,10 @@ void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *b, cons
                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 (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
-                                       fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes));
-                               } else if (b) {
+                               if (b) {
                                        fprintf(stderr, " BB%d", b->successors[n++]);
+                               } else if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                                       fprintf(stderr, " %04u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes));
                                } else {
                                        fprintf(stderr, " L%u", (uint32_t)(OP_JMP_ADDR(opline, opline->op2) - op_array->opcodes));
                                }
@@ -679,10 +679,10 @@ void zend_dump_op(const zend_op_array *op_array, const zend_basic_block *b, cons
        }
 
        if (ZEND_VM_EXT_JMP_ADDR == (flags & ZEND_VM_EXT_MASK)) {
-               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
-                       fprintf(stderr, " %04u", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
-               } else if (b) {
+               if (b) {
                        fprintf(stderr, " BB%d", b->successors[n++]);
+               } else if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " %04u", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
                } else {
                        fprintf(stderr, " L%u", (uint32_t)ZEND_OFFSET_TO_OPLINE_NUM(op_array, opline, opline->extended_value));
                }
@@ -725,11 +725,14 @@ static void zend_dump_op_line(const zend_op_array *op_array, const zend_basic_bl
        zend_ssa_op *ssa_op = NULL;
 
        if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
-               len = fprintf(stderr, "%04u:", (uint32_t)(opline - op_array->opcodes));
+               len = fprintf(stderr, "%04u", (uint32_t)(opline - op_array->opcodes));
+               fprintf(stderr, "%*c", 5-len, ' ');
        } else if (!b) {
                len = fprintf(stderr, "L%u (%u):", (uint32_t)(opline - op_array->opcodes), opline->lineno);
+               fprintf(stderr, "%*c", 12-len, ' ');
+       } else {
+               fprintf(stderr, "%*c", 12-len, ' ');
        }
-       fprintf(stderr, "%*c", 12-len, ' ');
 
        if (dump_flags & ZEND_DUMP_SSA) {
                ssa = (const zend_ssa*)data;
@@ -747,6 +750,9 @@ static void zend_dump_block_info(const zend_cfg *cfg, int n, uint32_t dump_flags
        zend_basic_block *b = cfg->blocks + n;
 
        fprintf(stderr, "BB%d:", n);
+       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+               fprintf(stderr, "\n     ;");
+       }
        if (b->flags & ZEND_BB_START) {
                fprintf(stderr, " start");
        }
@@ -800,6 +806,9 @@ static void zend_dump_block_info(const zend_cfg *cfg, int n, uint32_t dump_flags
                int *p = cfg->predecessors + b->predecessor_offset;
                int *end = p + b->predecessors_count;
 
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; from=(BB%d", *p);
                for (p++; p < end; p++) {
                        fprintf(stderr, ", BB%d", *p);
@@ -809,6 +818,9 @@ static void zend_dump_block_info(const zend_cfg *cfg, int n, uint32_t dump_flags
 
        if (b->successors_count > 0) {
                int s;
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; to=(BB%d", b->successors[0]);
                for (s = 1; s < b->successors_count; s++) {
                        fprintf(stderr, ", BB%d", b->successors[s]);
@@ -817,16 +829,28 @@ static void zend_dump_block_info(const zend_cfg *cfg, int n, uint32_t dump_flags
        }
 
        if (b->idom >= 0) {
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; idom=BB%d\n", b->idom);
        }
        if (b->level >= 0) {
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; level=%d\n", b->level);
        }
        if (b->loop_header >= 0) {
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; loop_header=%d\n", b->loop_header);
        }
        if (b->children >= 0) {
                int j = b->children;
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; children=(BB%d", j);
                j = cfg->blocks[j].next_child;
                while (j >= 0) {
@@ -846,7 +870,11 @@ static void zend_dump_block_header(const zend_cfg *cfg, const zend_op_array *op_
                do {
                        int j;
 
-                       fprintf(stderr, "        ");
+                       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                               fprintf(stderr, "     ");
+                       } else {
+                               fprintf(stderr, "        ");
+                       }
                        zend_dump_ssa_var(op_array, ssa, p->ssa_var, 0, p->var, dump_flags);
                        if (p->pi < 0) {
                                fprintf(stderr, " = Phi(");
@@ -917,7 +945,11 @@ void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_flags, cons
 
        fprintf(stderr, "\n");
        zend_dump_op_array_name(op_array);
-       fprintf(stderr, ": ; (lines=%d, args=%d",
+       fprintf(stderr, ":");
+       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+               fprintf(stderr, "\n    ");
+       }
+       fprintf(stderr, " ; (lines=%d, args=%d",
                op_array->last,
                op_array->num_args);
        if (func_info && func_info->num_args >= 0) {
@@ -976,14 +1008,23 @@ void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_flags, cons
        }
        fprintf(stderr, ")\n");
        if (msg) {
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                fprintf(stderr, "    ; (%s)\n", msg);
        }
+       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+               fprintf(stderr, " ");
+       }
        fprintf(stderr, "    ; %s:%u-%u\n", op_array->filename->val, op_array->line_start, op_array->line_end);
 
        if (func_info && func_info->num_args > 0) {
                uint32_t j;
 
                for (j = 0; j < MIN(op_array->num_args, func_info->num_args ); j++) {
+                       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                               fprintf(stderr, " ");
+                       }
                        fprintf(stderr, "    ; arg %d ", j);
                        zend_dump_type_info(func_info->arg_info[j].info.type, func_info->arg_info[j].info.ce, func_info->arg_info[j].info.is_instanceof, dump_flags);
                        zend_dump_range(&func_info->arg_info[j].info.range);
@@ -992,6 +1033,9 @@ void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_flags, cons
        }
 
        if (func_info) {
+               if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                       fprintf(stderr, " ");
+               }
                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);
@@ -1000,6 +1044,9 @@ void zend_dump_op_array(const zend_op_array *op_array, uint32_t dump_flags, cons
 
        if (ssa && ssa->var_info) {
                for (i = 0; i < op_array->last_var; i++) {
+                       if (dump_flags & ZEND_DUMP_NUMERIC_OPLINES) {
+                               fprintf(stderr, " ");
+                       }
                        fprintf(stderr, "    ; ");
                        zend_dump_ssa_var(op_array, ssa, i, IS_CV, i, dump_flags);
                        fprintf(stderr, "\n");

diff --git a/ext/opcache/jit/zend_jit.c b/ext/opcache/jit/zend_jit.c
index 70c60e7bff6d42832712890f42a9da37053df0ce..6f03d0fa5a005e83df9619867035dcbb24610f94 100644 (file)
--- a/ext/opcache/jit/zend_jit.c
+++ b/ext/opcache/jit/zend_jit.c
@@ -3066,7 +3066,7 @@ static int zend_real_jit_func(zend_op_array *op_array, zend_script *script, cons
        }
 
        if (ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_SSA) {
-               zend_dump_op_array(op_array, ZEND_DUMP_HIDE_UNREACHABLE|ZEND_DUMP_RC_INFERENCE|ZEND_DUMP_SSA, "JIT", &ssa);
+               zend_dump_op_array(op_array, ZEND_DUMP_NUMERIC_OPLINES|ZEND_DUMP_HIDE_UNREACHABLE|ZEND_DUMP_RC_INFERENCE|ZEND_DUMP_SSA, "JIT", &ssa);
        }
 
        if (zend_jit(op_array, &ssa, rt_opline) != SUCCESS) {
@@ -3380,7 +3380,7 @@ ZEND_EXT_API int zend_jit_script(zend_script *script)
                                }
                                info = ZEND_FUNC_INFO(call_graph.op_arrays[i]);
                                if (info) {
-                                       zend_dump_op_array(call_graph.op_arrays[i], ZEND_DUMP_HIDE_UNREACHABLE|ZEND_DUMP_RC_INFERENCE|ZEND_DUMP_SSA, "JIT", &info->ssa);
+                                       zend_dump_op_array(call_graph.op_arrays[i], ZEND_DUMP_NUMERIC_OPLINES|ZEND_DUMP_HIDE_UNREACHABLE|ZEND_DUMP_RC_INFERENCE|ZEND_DUMP_SSA, "JIT", &info->ssa);
                                }
                        }
                }

diff --git a/ext/opcache/jit/zend_jit_trace.c b/ext/opcache/jit/zend_jit_trace.c
index 3115694f84a33425e2b0782a1277125111670227..46b4f3e22cd078ed5ee86b73ee60396dd62f0938 100644 (file)
--- a/ext/opcache/jit/zend_jit_trace.c
+++ b/ext/opcache/jit/zend_jit_trace.c
@@ -24,6 +24,27 @@ static const void **zend_jit_exit_groups = NULL;
 #define ZEND_JIT_EXIT_NUM      zend_jit_traces[0].exit_count
 #define ZEND_JIT_EXIT_COUNTERS zend_jit_traces[0].exit_counters
 
+#define ZEND_JIT_TRACE_STOP_DESCRIPTION(name, description) \
+       description,
+
+static const char * zend_jit_trace_stop_description[] = {
+       ZEND_JIT_TRACE_STOP(ZEND_JIT_TRACE_STOP_DESCRIPTION)
+};
+
+static zend_always_inline const char *zend_jit_trace_star_desc(uint8_t trace_flags)
+{
+       if (trace_flags & ZEND_JIT_TRACE_START_LOOP) {
+               return "loop";
+       } else if (trace_flags & ZEND_JIT_TRACE_START_ENTER) {
+               return "enter";
+       } else if (trace_flags & ZEND_JIT_TRACE_START_RETURN) {
+               return "return";
+       } else {
+               ZEND_ASSERT(0);
+               return "???";
+       }
+}
+
 static int zend_jit_trace_startup(void)
 {
        zend_jit_traces = (zend_jit_trace_info*)zend_shared_alloc(sizeof(zend_jit_trace_info) * ZEND_JIT_TRACE_MAX_TRACES);
@@ -424,7 +445,7 @@ static zend_ssa *zend_jit_trace_build_ssa(const zend_op_array *op_array, zend_sc
                        }
 
                        if (ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_SSA) {
-                               zend_dump_op_array(op_array, ZEND_DUMP_HIDE_UNREACHABLE|ZEND_DUMP_RC_INFERENCE|ZEND_DUMP_SSA, "JIT", ssa);
+                               zend_dump_op_array(op_array, ZEND_DUMP_NUMERIC_OPLINES|ZEND_DUMP_HIDE_UNREACHABLE|ZEND_DUMP_RC_INFERENCE|ZEND_DUMP_SSA, "JIT", ssa);
                        }
                        return ssa;
                } while (0);
@@ -1620,8 +1641,24 @@ static zend_ssa *zend_jit_trace_build_tssa(zend_jit_trace_rec *trace_buffer, uin
        }
 
        if (UNEXPECTED(ZCG(accel_directives).jit_debug & ZEND_JIT_DEBUG_TRACE_TSSA)) {
+               fprintf(stderr, "---- TRACE %d TSSA start (%s) %s() %s:%d\n",
+                       ZEND_JIT_TRACE_NUM,
+                       zend_jit_trace_star_desc(trace_buffer->start),
+                       trace_buffer->op_array->function_name ?
+                               ZSTR_VAL(trace_buffer->op_array->function_name) : "$main",
+                       ZSTR_VAL(trace_buffer->op_array->filename),
+                       ((zend_jit_trace_start_rec*)trace_buffer)->opline->lineno);
                zend_jit_dump_trace(trace_buffer, tssa);
-               fprintf(stderr, "---- TRACE analysed\n");
+               if (trace_buffer->stop == ZEND_JIT_TRACE_STOP_LINK) {
+                       uint32_t link_to = zend_jit_find_trace(EG(current_execute_data)->opline->handler);;
+                       fprintf(stderr, "---- TRACE %d TSSA stop (link to %d)\n",
+                               ZEND_JIT_TRACE_NUM,
+                               link_to);
+               } else {
+                       fprintf(stderr, "---- TRACE %d TSSA stop (%s)\n",
+                               ZEND_JIT_TRACE_NUM,
+                               zend_jit_trace_stop_description[trace_buffer->stop]);
+               }
        }
 
        return tssa;
@@ -3267,13 +3304,6 @@ static zend_bool zend_jit_trace_is_bad_root(const zend_op *opline, zend_jit_trac
        return 0;
 }
 
-#define ZEND_JIT_TRACE_STOP_DESCRIPTION(name, description) \
-       description,
-
-static const char * zend_jit_trace_stop_description[] = {
-       ZEND_JIT_TRACE_STOP(ZEND_JIT_TRACE_STOP_DESCRIPTION)
-};
-
 static void zend_jit_dump_trace(zend_jit_trace_rec *trace_buffer, zend_ssa *tssa)
 {
        zend_jit_trace_rec *p = trace_buffer;
@@ -3455,20 +3485,6 @@ static void zend_jit_dump_trace(zend_jit_trace_rec *trace_buffer, zend_ssa *tssa
        }
 }
 
-static zend_always_inline const char *zend_jit_trace_star_desc(uint8_t trace_flags)
-{
-       if (trace_flags & ZEND_JIT_TRACE_START_LOOP) {
-               return "loop";
-       } else if (trace_flags & ZEND_JIT_TRACE_START_ENTER) {
-               return "enter";
-       } else if (trace_flags & ZEND_JIT_TRACE_START_RETURN) {
-               return "return";
-       } else {
-               ZEND_ASSERT(0);
-               return "???";
-       }
-}
-
 int ZEND_FASTCALL zend_jit_trace_hot_root(zend_execute_data *execute_data, const zend_op *opline)
 {
        const zend_op *orig_opline;