From 15ec8d5ab5f21997cfa34cdba9f4b2daea40e710 Mon Sep 17 00:00:00 2001 From: Jan Hubicka Date: Fri, 21 Jul 2023 13:38:29 +0200 Subject: [PATCH] improfe loop dumps we have flow_loop_dump and print_loop. While print_loop was extended to dump stuff from loop structure we added over years (loop info), flow_loop_dump was not. -fdump-tree-all files contains flow_loop_dump which makes it hard to see what metadata we have attached to loop. This patch unifies dumping of these fields from both functions. For example for: int a[100]; main() { for (int i = 0; i < 10; i++) a[i]=i; } we now print: ;; Loop 0 ;; header 0, latch 1 ;; depth 0, outer -1 ;; nodes: 0 1 2 3 4 5 ;; ;; Loop 1 ;; header 4, latch 3 ;; depth 1, outer 0, finite_p ;; upper_bound 10 ;; likely_upper_bound 10 ;; estimate 10 ;; iterations by profile: 10.001101 (unreliable) finite_p, upper_boud, likely_upper_bound estimate and iterations by profile is new. Bootstrap/regtest on x86_64 in progress. OK if it passes? Honza gcc/ChangeLog: * cfgloop.cc (flow_loop_dump): Use print_loop_info. * cfgloop.h (print_loop_info): Declare. * tree-cfg.cc (print_loop_info): Break out from ...; add printing of missing fields and profile (print_loop): ... here. gcc/testsuite/ChangeLog: * gcc.dg/tree-ssa/dce-1.c: Update for new loop dumps. --- gcc/cfgloop.cc | 11 ++--- gcc/cfgloop.h | 1 + gcc/testsuite/gcc.dg/tree-ssa/dce-1.c | 4 +- gcc/tree-cfg.cc | 71 +++++++++++++++++++-------- 4 files changed, 56 insertions(+), 31 deletions(-) diff --git a/gcc/cfgloop.cc b/gcc/cfgloop.cc index 020e5734d95..9ca85e648a7 100644 --- a/gcc/cfgloop.cc +++ b/gcc/cfgloop.cc @@ -135,17 +135,12 @@ flow_loop_dump (const class loop *loop, FILE *file, fprintf (file, "\n"); } - fprintf (file, ";; depth %d, outer %ld\n", + fprintf (file, ";; depth %d, outer %ld", loop_depth (loop), (long) (loop_outer (loop) ? loop_outer (loop)->num : -1)); + print_loop_info (file, loop, ";; "); - bool reliable; - sreal iterations; - if (loop->num && expected_loop_iterations_by_profile (loop, &iterations, &reliable)) - fprintf (file, ";; profile-based iteration count: %f %s\n", - iterations.to_double (), reliable ? "(reliable)" : "(unreliable)"); - - fprintf (file, ";; nodes:"); + fprintf (file, "\n;; nodes:"); bbs = get_loop_body (loop); for (i = 0; i < loop->num_nodes; i++) fprintf (file, " %d", bbs[i]->index); diff --git a/gcc/cfgloop.h b/gcc/cfgloop.h index 4d2fd4b6af5..269694c7962 100644 --- a/gcc/cfgloop.h +++ b/gcc/cfgloop.h @@ -411,6 +411,7 @@ extern unsigned expected_loop_iterations (class loop *); extern rtx doloop_condition_get (rtx_insn *); void mark_loop_for_removal (loop_p); +void print_loop_info (FILE *file, const class loop *loop, const char *); /* Induction variable analysis. */ diff --git a/gcc/testsuite/gcc.dg/tree-ssa/dce-1.c b/gcc/testsuite/gcc.dg/tree-ssa/dce-1.c index 42d9407e290..91c3bcd6c1c 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/dce-1.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/dce-1.c @@ -13,6 +13,6 @@ int foo (int b, int j) } /* Check that empty loop is eliminated in this case. We should no longer have the exit condition after the loop. */ -/* { dg-final { scan-tree-dump-not "999" "cddce1"} } */ -/* { dg-final { scan-tree-dump-not "1000" "cddce1"} } */ +/* { dg-final { scan-tree-dump-not "999)" "cddce1"} } */ +/* { dg-final { scan-tree-dump-not "1000)" "cddce1"} } */ diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc index 7ccc2a5a5a7..a6c97a04662 100644 --- a/gcc/tree-cfg.cc +++ b/gcc/tree-cfg.cc @@ -8479,6 +8479,55 @@ print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity) } } +/* Print loop information. */ + +void +print_loop_info (FILE *file, const class loop *loop, const char *prefix) +{ + if (loop->can_be_parallel) + fprintf (file, ", can_be_parallel"); + if (loop->warned_aggressive_loop_optimizations) + fprintf (file, ", warned_aggressive_loop_optimizations"); + if (loop->dont_vectorize) + fprintf (file, ", dont_vectorize"); + if (loop->force_vectorize) + fprintf (file, ", force_vectorize"); + if (loop->in_oacc_kernels_region) + fprintf (file, ", in_oacc_kernels_region"); + if (loop->finite_p) + fprintf (file, ", finite_p"); + if (loop->unroll) + fprintf (file, "\n%sunroll %d", prefix, loop->unroll); + if (loop->nb_iterations) + { + fprintf (file, "\n%sniter ", prefix); + print_generic_expr (file, loop->nb_iterations); + } + + if (loop->any_upper_bound) + { + fprintf (file, "\n%supper_bound ", prefix); + print_decu (loop->nb_iterations_upper_bound, file); + } + if (loop->any_likely_upper_bound) + { + fprintf (file, "\n%slikely_upper_bound ", prefix); + print_decu (loop->nb_iterations_likely_upper_bound, file); + } + + if (loop->any_estimate) + { + fprintf (file, "\n%sestimate ", prefix); + print_decu (loop->nb_iterations_estimate, file); + } + bool reliable; + sreal iterations; + if (loop->num && expected_loop_iterations_by_profile (loop, &iterations, &reliable)) + fprintf (file, "\n%siterations by profile: %f %s", prefix, + iterations.to_double (), reliable ? "(reliable)" : "(unreliable)"); + +} + static void print_loop_and_siblings (FILE *, class loop *, int, int); /* Pretty print LOOP on FILE, indented INDENT spaces. Following @@ -8511,27 +8560,7 @@ print_loop (FILE *file, class loop *loop, int indent, int verbosity) fprintf (file, ", latch = %d", loop->latch->index); else fprintf (file, ", multiple latches"); - fprintf (file, ", niter = "); - print_generic_expr (file, loop->nb_iterations); - - if (loop->any_upper_bound) - { - fprintf (file, ", upper_bound = "); - print_decu (loop->nb_iterations_upper_bound, file); - } - if (loop->any_likely_upper_bound) - { - fprintf (file, ", likely_upper_bound = "); - print_decu (loop->nb_iterations_likely_upper_bound, file); - } - - if (loop->any_estimate) - { - fprintf (file, ", estimate = "); - print_decu (loop->nb_iterations_estimate, file); - } - if (loop->unroll) - fprintf (file, ", unroll = %d", loop->unroll); + print_loop_info (file, loop, s_indent); fprintf (file, ")\n"); /* Print loop's body. */