From 6475e077a091ea57b7442ed35feaf031728bdeb2 Mon Sep 17 00:00:00 2001 From: David Malcolm Date: Fri, 29 Jun 2018 09:56:40 +0000 Subject: [PATCH] dumpfile.c: add indentation via DUMP_VECT_SCOPE This patch adds a concept of nested "scopes" to dumpfile.c's dump_*_loc calls, and wires it up to the DUMP_VECT_SCOPE macro in tree-vectorizer.h, so that the nested structure is shown in -fopt-info by indentation. For example, this converts -fopt-info-all e.g. from: test.c:8:3: note: === analyzing loop === test.c:8:3: note: === analyze_loop_nest === test.c:8:3: note: === vect_analyze_loop_form === test.c:8:3: note: === get_loop_niters === test.c:8:3: note: symbolic number of iterations is (unsigned int) n_9(D) test.c:8:3: note: not vectorized: loop contains function calls or data references that cannot be analyzed test.c:8:3: note: vectorized 0 loops in function to: test.c:8:3: note: === analyzing loop === test.c:8:3: note: === analyze_loop_nest === test.c:8:3: note: === vect_analyze_loop_form === test.c:8:3: note: === get_loop_niters === test.c:8:3: note: symbolic number of iterations is (unsigned int) n_9(D) test.c:8:3: note: not vectorized: loop contains function calls or data references that cannot be analyzed test.c:8:3: note: vectorized 0 loops in function showing that the "symbolic number of iterations" message is within the "=== analyze_loop_nest ===" (and not within the "=== vect_analyze_loop_form ==="). This is also enabling work for followups involving optimization records (allowing the records to directly capture the nested structure of the dump messages). gcc/ChangeLog: * dumpfile.c (dump_loc): Add indentation based on scope depth. (dump_scope_depth): New variable. (get_dump_scope_depth): New function. (dump_begin_scope): New function. (dump_end_scope): New function. * dumpfile.h (get_dump_scope_depth): New declaration. (dump_begin_scope): New declaration. (dump_end_scope): New declaration. (class auto_dump_scope): New class. (AUTO_DUMP_SCOPE): New macro. * tree-vectorizer.h (DUMP_VECT_SCOPE): Reimplement in terms of AUTO_DUMP_SCOPE. From-SVN: r262246 --- gcc/ChangeLog | 15 +++++++++++++++ gcc/dumpfile.c | 35 +++++++++++++++++++++++++++++++++++ gcc/dumpfile.h | 39 +++++++++++++++++++++++++++++++++++++++ gcc/tree-vectorizer.h | 15 ++++++++------- 4 files changed, 97 insertions(+), 7 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index bc333f2dae6..5c7c5022123 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,18 @@ +2018-06-29 David Malcolm + + * dumpfile.c (dump_loc): Add indentation based on scope depth. + (dump_scope_depth): New variable. + (get_dump_scope_depth): New function. + (dump_begin_scope): New function. + (dump_end_scope): New function. + * dumpfile.h (get_dump_scope_depth): New declaration. + (dump_begin_scope): New declaration. + (dump_end_scope): New declaration. + (class auto_dump_scope): New class. + (AUTO_DUMP_SCOPE): New macro. + * tree-vectorizer.h (DUMP_VECT_SCOPE): Reimplement in terms of + AUTO_DUMP_SCOPE. + 2018-06-29 Richard Biener * tree-vect-data-refs.c (vect_analyze_data_ref_dependences): Assert diff --git a/gcc/dumpfile.c b/gcc/dumpfile.c index 06a6673d646..93bc65148dd 100644 --- a/gcc/dumpfile.c +++ b/gcc/dumpfile.c @@ -453,6 +453,8 @@ dump_loc (dump_flags_t dump_kind, FILE *dfile, source_location loc) DECL_SOURCE_FILE (current_function_decl), DECL_SOURCE_LINE (current_function_decl), DECL_SOURCE_COLUMN (current_function_decl)); + /* Indentation based on scope depth. */ + fprintf (dfile, "%*s", get_dump_scope_depth (), ""); } } @@ -573,6 +575,39 @@ template void dump_dec (dump_flags_t, const poly_uint64 &); template void dump_dec (dump_flags_t, const poly_offset_int &); template void dump_dec (dump_flags_t, const poly_widest_int &); +/* The current dump scope-nesting depth. */ + +static int dump_scope_depth; + +/* Get the current dump scope-nesting depth. + For use by dump_*_loc (for showing nesting via indentation). */ + +unsigned int +get_dump_scope_depth () +{ + return dump_scope_depth; +} + +/* Push a nested dump scope. + Print "=== NAME ===\n" to the dumpfile, if any, and to the -fopt-info + destination, if any. + Increment the scope depth. */ + +void +dump_begin_scope (const char *name, const dump_location_t &loc) +{ + dump_printf_loc (MSG_NOTE, loc, "=== %s ===\n", name); + dump_scope_depth++; +} + +/* Pop a nested dump scope. */ + +void +dump_end_scope () +{ + dump_scope_depth--; +} + /* Start a dump for PHASE. Store user-supplied dump flags in *FLAG_PTR. Return the number of streams opened. Set globals DUMP_FILE, and ALT_DUMP_FILE to point to the opened streams, and diff --git a/gcc/dumpfile.h b/gcc/dumpfile.h index 489f92e6d1a..9828a3f550c 100644 --- a/gcc/dumpfile.h +++ b/gcc/dumpfile.h @@ -459,6 +459,45 @@ dump_enabled_p (void) return dumps_are_enabled; } +/* Managing nested scopes, so that dumps can express the call chain + leading to a dump message. */ + +extern unsigned int get_dump_scope_depth (); +extern void dump_begin_scope (const char *name, const dump_location_t &loc); +extern void dump_end_scope (); + +/* Implementation detail of the AUTO_DUMP_SCOPE macro below. + + A RAII-style class intended to make it easy to emit dump + information about entering and exiting a collection of nested + function calls. */ + +class auto_dump_scope +{ + public: + auto_dump_scope (const char *name, dump_location_t loc) + { + if (dump_enabled_p ()) + dump_begin_scope (name, loc); + } + ~auto_dump_scope () + { + if (dump_enabled_p ()) + dump_end_scope (); + } +}; + +/* A macro for calling: + dump_begin_scope (NAME, LOC); + via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc, + and then calling + dump_end_scope (); + once the object goes out of scope, thus capturing the nesting of + the scopes. */ + +#define AUTO_DUMP_SCOPE(NAME, LOC) \ + auto_dump_scope scope (NAME, LOC) + namespace gcc { class dump_manager diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 94a0f381b00..a8406b3df7a 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -1440,15 +1440,16 @@ vect_get_scalar_dr_size (struct data_reference *dr) /* Source location + hotness information. */ extern dump_user_location_t vect_location; -/* If dumping is enabled, emit a MSG_NOTE at vect_location about - entering MSG within the vectorizer. MSG should be a string literal. */ +/* A macro for calling: + dump_begin_scope (MSG, vect_location); + via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc, + and then calling + dump_end_scope (); + once the object goes out of scope, thus capturing the nesting of + the scopes. */ #define DUMP_VECT_SCOPE(MSG) \ - do { \ - if (dump_enabled_p ()) \ - dump_printf_loc (MSG_NOTE, vect_location, \ - "=== " MSG " ===\n"); \ - } while (0) + AUTO_DUMP_SCOPE (MSG, vect_location) /*-----------------------------------------------------------------*/ /* Function prototypes. */ -- 2.30.2