On Mon, 2018-07-09 at 15:00 +0200, Richard Biener wrote: > On Mon, Jul 2, 2018 at 10:51 PM David Malcolm <dmalc...@redhat.com> > wrote: > > > > This patch implements a way to consolidate dump_* calls into > > optinfo objects, as enabling work towards being able to write out > > optimization records to a file, or emit them as diagnostic > > "remarks". > > > > The patch adds the support for building optinfo instances from > > dump_* > > calls, but leaves implementing any *users* of them to followup > > patches. > > > > Successfully bootstrapped & regrtested on x86_64-pc-linux-gnu. > > > > OK for trunk? > > Looks good overall, but ... > > To "fix" the GC issue you'd need to capture all possibly interesting > information from tree/gimple while it is still in flight. This _may_ > be > necessary anyway since I remember writing code like > > fprintf (dump_file, "old: "); > print_gimple_stmt (..., stmt); > gimple_set_rhs1 (stmt, op); > fprintf (dump_file, "new: "); > print_gmple_stmt (..., stmt); > fprintf (dump_file, "\n"); > > capturing interesting information means we know all targeted > optinfo channels, right? And the optinfo consumers > need to handle "streams" of input and may not look back.
> I've yet have to look at the 2nd patch but can you comment on > this? How difficult is it to re-wire how the data flows to make > stmt re-use like the above possible? I *think* it's doable: rather than capture, say, a gimple *, the optinfo_item would capture the result of pp_gimple_stmt_1, plus some metadata. In fact, it would probably allow for removing the optinfo_item subclasses, making optinfo_item concrete, containing something like: /* Textual form. */ char *m_text; bool m_ownership_of_text; /* Metadata for optimization records. */ enum optinfo_item_kind m_kind; location_t m_location; or somesuch. I'll have a go at implementing this. Thanks Dave > Thanks, > Richard. > > > gcc/ChangeLog: > > * Makefile.in (OBJS): Add optinfo.o. > > * coretypes.h (class symtab_node): New forward decl. > > (struct cgraph_node): New forward decl. > > (class varpool_node): New forward decl. > > * dump-context.h: New file. > > * dumpfile.c: Include "optinfo.h", "dump-context.h", > > "cgraph.h", > > "tree-pass.h", "optinfo-internal.h". > > (refresh_dumps_are_enabled): Use optinfo_enabled_p. > > (set_dump_file): Call > > dumpfile_ensure_any_optinfo_are_flushed. > > (set_alt_dump_file): Likewise. > > (dump_context::~dump_context): New dtor. > > (dump_gimple_stmt): Move implementation to... > > (dump_context::dump_gimple_stmt): ...this new member > > function. > > Add the stmt to any pending optinfo, creating one if need > > be. > > (dump_gimple_stmt_loc): Move implementation to... > > (dump_context::dump_gimple_stmt_loc): ...this new member > > function. > > Convert param "loc" from location_t to const > > dump_location_t &. > > Start a new optinfo and add the stmt to it. > > (dump_generic_expr): Move implementation to... > > (dump_context::dump_generic_expr): ...this new member > > function. > > Add the tree to any pending optinfo, creating one if need > > be. > > (dump_generic_expr_loc): Move implementation to... > > (dump_context::dump_generic_expr_loc): ...this new member > > function. Add the tree to any pending optinfo, creating > > one if > > need be. > > (dump_printf): Move implementation to... > > (dump_context::dump_printf_va): ...this new member > > function. Add > > the text to any pending optinfo, creating one if need be. > > (dump_printf_loc): Move implementation to... > > (dump_context::dump_printf_loc_va): ...this new member > > function. > > Convert param "loc" from location_t to const > > dump_location_t &. > > Start a new optinfo and add the stmt to it. > > (dump_dec): Move implementation to... > > (dump_context::dump_dec): ...this new member function. Add > > the > > value to any pending optinfo, creating one if need be. > > (dump_context::dump_symtab_node): New member function. > > (dump_context::get_scope_depth): New member function. > > (dump_context::begin_scope): New member function. > > (dump_context::end_scope): New member function. > > (dump_context::ensure_pending_optinfo): New member > > function. > > (dump_context::begin_next_optinfo): New member function. > > (dump_context::end_any_optinfo): New member function. > > (dump_context::s_current): New global. > > (dump_context::s_default): New global. > > (dump_scope_depth): Delete global. > > (dumpfile_ensure_any_optinfo_are_flushed): New function. > > (dump_symtab_node): New function. > > (get_dump_scope_depth): Reimplement in terms of > > dump_context. > > (dump_begin_scope): Likewise. > > (dump_end_scope): Likewise. > > (selftest::temp_dump_context::temp_dump_context): New ctor. > > (selftest::temp_dump_context::~temp_dump_context): New > > dtor. > > (selftest::assert_is_text): New support function. > > (selftest::assert_is_tree): New support function. > > (selftest::assert_is_gimple): New support function. > > (selftest::test_capture_of_dump_calls): New test. > > (selftest::dumpfile_c_tests): Call it. > > * dumpfile.h (dump_printf, dump_printf_loc, > > dump_basic_block, > > dump_generic_expr_loc, dump_generic_expr, > > dump_gimple_stmt_loc, > > dump_gimple_stmt, dump_dec): Gather these related decls and > > add a > > descriptive comment. > > (dump_function, print_combine_total_stats, > > enable_rtl_dump_file, > > dump_node, dump_bb): Move these unrelated decls. > > (class dump_manager): Add leading comment. > > * ggc-page.c (ggc_collect): Call > > dumpfile_ensure_any_optinfo_are_flushed. > > * optinfo-internal.h: New file. > > * optinfo.cc: New file. > > * optinfo.h: New file. > > * selftest-run-tests.c (selftest::run_tests): Call > > selftest::optinfo_cc_tests. > > * selftest.h (selftest::optinfo_cc_tests): New decl. > > --- > > gcc/Makefile.in | 1 + > > gcc/coretypes.h | 7 + > > gcc/dump-context.h | 128 ++++++++++++ > > gcc/dumpfile.c | 498 > > +++++++++++++++++++++++++++++++++++++++++++---- > > gcc/dumpfile.h | 82 +++++--- > > gcc/ggc-page.c | 2 + > > gcc/optinfo-internal.h | 148 ++++++++++++++ > > gcc/optinfo.cc | 251 ++++++++++++++++++++++++ > > gcc/optinfo.h | 175 +++++++++++++++++ > > gcc/selftest-run-tests.c | 1 + > > gcc/selftest.h | 1 + > > 11 files changed, 1233 insertions(+), 61 deletions(-) > > create mode 100644 gcc/dump-context.h > > create mode 100644 gcc/optinfo-internal.h > > create mode 100644 gcc/optinfo.cc > > create mode 100644 gcc/optinfo.h > > > > diff --git a/gcc/Makefile.in b/gcc/Makefile.in > > index 66c8b6e..7d36a77 100644 > > --- a/gcc/Makefile.in > > +++ b/gcc/Makefile.in > > @@ -1426,6 +1426,7 @@ OBJS = \ > > optabs-libfuncs.o \ > > optabs-query.o \ > > optabs-tree.o \ > > + optinfo.o \ > > options-save.o \ > > opts-global.o \ > > passes.o \ > > diff --git a/gcc/coretypes.h b/gcc/coretypes.h > > index 283b4eb..ed0e825 100644 > > --- a/gcc/coretypes.h > > +++ b/gcc/coretypes.h > > @@ -134,6 +134,13 @@ struct gomp_single; > > struct gomp_target; > > struct gomp_teams; > > > > +/* Subclasses of symtab_node, using indentation to show the class > > + hierarchy. */ > > + > > +class symtab_node; > > + struct cgraph_node; > > + class varpool_node; > > + > > union section; > > typedef union section section; > > struct gcc_options; > > diff --git a/gcc/dump-context.h b/gcc/dump-context.h > > new file mode 100644 > > index 0000000..753f714 > > --- /dev/null > > +++ b/gcc/dump-context.h > > @@ -0,0 +1,128 @@ > > +/* Support code for handling the various dump_* calls in > > dumpfile.h > > + Copyright (C) 2018 Free Software Foundation, Inc. > > + Contributed by David Malcolm <dmalc...@redhat.com>. > > + > > +This file is part of GCC. > > + > > +GCC is free software; you can redistribute it and/or modify > > +it under the terms of the GNU General Public License as published > > by > > +the Free Software Foundation; either version 3, or (at your > > option) > > +any later version. > > + > > +GCC is distributed in the hope that it will be useful, > > +but WITHOUT ANY WARRANTY; without even the implied warranty of > > +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > +GNU General Public License for more details. > > + > > +You should have received a copy of the GNU General Public License > > +along with GCC; see the file COPYING3. If not see > > +<http://www.gnu.org/licenses/>. */ > > + > > + > > +#ifndef GCC_DUMP_CONTEXT_H > > +#define GCC_DUMP_CONTEXT_H 1 > > + > > +/* A class for handling the various dump_* calls. > > + > > + In particular, this class has responsibility for consolidating > > + the "dump_*" calls into optinfo instances (delimited by > > "dump_*_loc" > > + calls), and emitting them. > > + > > + Putting this in a class (rather than as global state) allows > > + for selftesting of this code. */ > > + > > +class dump_context > > +{ > > + friend class temp_dump_context; > > + public: > > + static dump_context &get () { return *s_current; } > > + > > + ~dump_context (); > > + > > + void dump_gimple_stmt (dump_flags_t dump_kind, dump_flags_t > > extra_dump_flags, > > + gimple *gs, int spc); > > + > > + void dump_gimple_stmt_loc (dump_flags_t dump_kind, > > + const dump_location_t &loc, > > + dump_flags_t extra_dump_flags, > > + gimple *gs, int spc); > > + > > + void dump_generic_expr (dump_flags_t dump_kind, > > + dump_flags_t extra_dump_flags, > > + tree t); > > + > > + void dump_generic_expr_loc (dump_flags_t dump_kind, > > + const dump_location_t &loc, > > + dump_flags_t extra_dump_flags, > > + tree t); > > + > > + void dump_printf_va (dump_flags_t dump_kind, const char *format, > > + va_list ap) ATTRIBUTE_PRINTF (3, 0); > > + > > + void dump_printf_loc_va (dump_flags_t dump_kind, const > > dump_location_t &loc, > > + const char *format, va_list ap) > > + ATTRIBUTE_PRINTF (4, 0); > > + > > + template<unsigned int N, typename C> > > + void dump_dec (dump_flags_t dump_kind, const poly_int<N, C> > > &value); > > + > > + void dump_symtab_node (dump_flags_t dump_kind, symtab_node > > *node); > > + > > + /* Managing nested scopes. */ > > + unsigned int get_scope_depth () const; > > + void begin_scope (const char *name, const dump_location_t &loc); > > + void end_scope (); > > + > > + /* For use in selftests; if true then optinfo_enabled_p is > > true. */ > > + bool forcibly_enable_optinfo_p () const > > + { > > + return m_forcibly_enable_optinfo; > > + } > > + > > + void end_any_optinfo (); > > + > > + private: > > + optinfo &ensure_pending_optinfo (); > > + optinfo &begin_next_optinfo (const dump_location_t &loc); > > + > > + /* For use in selftests; if true then optinfo_enabled_p is > > true. */ > > + bool m_forcibly_enable_optinfo; > > + > > + /* The current nesting depth of dump scopes, for showing nesting > > + via indentation). */ > > + unsigned int m_scope_depth; > > + > > + /* The optinfo currently being accumulated since the last > > dump_*_loc call, > > + if any. */ > > + optinfo *m_pending; > > + > > + /* The currently active dump_context, for use by the dump_* API > > calls. */ > > + static dump_context *s_current; > > + > > + /* The default active context. */ > > + static dump_context s_default; > > +}; > > + > > +#if CHECKING_P > > + > > +/* An RAII-style class for use in selftests for temporarily using > > a different > > + dump_context. */ > > + > > +class temp_dump_context > > +{ > > + public: > > + temp_dump_context (bool forcibly_enable_optinfo); > > + ~temp_dump_context (); > > + > > + /* Support for selftests. */ > > + optinfo *get_pending_optinfo () const { return > > m_context.m_pending; } > > + > > + private: > > + dump_context m_context; > > + dump_context *m_saved; > > + bool m_saved_flag_remarks; > > +}; > > + > > +#endif /* CHECKING_P */ > > + > > +#endif /* GCC_DUMP_CONTEXT_H */ > > diff --git a/gcc/dumpfile.c b/gcc/dumpfile.c > > index 5f69f9b..6e089ef 100644 > > --- a/gcc/dumpfile.c > > +++ b/gcc/dumpfile.c > > @@ -33,6 +33,11 @@ along with GCC; see the file COPYING3. If not > > see > > #include "gimple.h" /* for dump_user_location_t ctor. */ > > #include "rtl.h" /* for dump_user_location_t ctor. */ > > #include "selftest.h" > > +#include "optinfo.h" > > +#include "dump-context.h" > > +#include "cgraph.h" > > +#include "tree-pass.h" /* for "current_pass". */ > > +#include "optinfo-internal.h" /* for selftests. */ > > > > /* If non-NULL, return one past-the-end of the matching SUBPART of > > the WHOLE string. */ > > @@ -64,7 +69,7 @@ bool dumps_are_enabled = false; > > static void > > refresh_dumps_are_enabled () > > { > > - dumps_are_enabled = (dump_file || alt_dump_file); > > + dumps_are_enabled = (dump_file || alt_dump_file || > > optinfo_enabled_p ()); > > } > > > > /* Set global "dump_file" to NEW_DUMP_FILE, refreshing the > > "dumps_are_enabled" > > @@ -73,6 +78,7 @@ refresh_dumps_are_enabled () > > void > > set_dump_file (FILE *new_dump_file) > > { > > + dumpfile_ensure_any_optinfo_are_flushed (); > > dump_file = new_dump_file; > > refresh_dumps_are_enabled (); > > } > > @@ -83,6 +89,7 @@ set_dump_file (FILE *new_dump_file) > > static void > > set_alt_dump_file (FILE *new_alt_dump_file) > > { > > + dumpfile_ensure_any_optinfo_are_flushed (); > > alt_dump_file = new_alt_dump_file; > > refresh_dumps_are_enabled (); > > } > > @@ -458,25 +465,44 @@ dump_loc (dump_flags_t dump_kind, FILE > > *dfile, source_location loc) > > } > > } > > > > +/* Implementation of dump_context member functions. */ > > + > > +/* dump_context's dtor. */ > > + > > +dump_context::~dump_context () > > +{ > > + delete m_pending; > > +} > > + > > /* Dump gimple statement GS with SPC indentation spaces and > > EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is > > enabled. */ > > > > void > > -dump_gimple_stmt (dump_flags_t dump_kind, dump_flags_t > > extra_dump_flags, > > - gimple *gs, int spc) > > +dump_context::dump_gimple_stmt (dump_flags_t dump_kind, > > + dump_flags_t extra_dump_flags, > > + gimple *gs, int spc) > > { > > if (dump_file && (dump_kind & pflags)) > > print_gimple_stmt (dump_file, gs, spc, dump_flags | > > extra_dump_flags); > > > > if (alt_dump_file && (dump_kind & alt_flags)) > > print_gimple_stmt (alt_dump_file, gs, spc, dump_flags | > > extra_dump_flags); > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = ensure_pending_optinfo (); > > + info.handle_dump_file_kind (dump_kind); > > + info.add_stmt (gs, extra_dump_flags); > > + } > > } > > > > /* Similar to dump_gimple_stmt, except additionally print source > > location. */ > > > > void > > -dump_gimple_stmt_loc (dump_flags_t dump_kind, const > > dump_location_t &loc, > > - dump_flags_t extra_dump_flags, gimple *gs, > > int spc) > > +dump_context::dump_gimple_stmt_loc (dump_flags_t dump_kind, > > + const dump_location_t &loc, > > + dump_flags_t extra_dump_flags, > > + gimple *gs, int spc) > > { > > location_t srcloc = loc.get_location_t (); > > if (dump_file && (dump_kind & pflags)) > > @@ -490,20 +516,35 @@ dump_gimple_stmt_loc (dump_flags_t dump_kind, > > const dump_location_t &loc, > > dump_loc (dump_kind, alt_dump_file, srcloc); > > print_gimple_stmt (alt_dump_file, gs, spc, dump_flags | > > extra_dump_flags); > > } > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = begin_next_optinfo (loc); > > + info.handle_dump_file_kind (dump_kind); > > + info.add_stmt (gs, extra_dump_flags); > > + } > > } > > > > /* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams > > if > > DUMP_KIND is enabled. */ > > > > void > > -dump_generic_expr (dump_flags_t dump_kind, dump_flags_t > > extra_dump_flags, > > - tree t) > > +dump_context::dump_generic_expr (dump_flags_t dump_kind, > > + dump_flags_t extra_dump_flags, > > + tree t) > > { > > if (dump_file && (dump_kind & pflags)) > > print_generic_expr (dump_file, t, dump_flags | > > extra_dump_flags); > > > > if (alt_dump_file && (dump_kind & alt_flags)) > > print_generic_expr (alt_dump_file, t, dump_flags | > > extra_dump_flags); > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = ensure_pending_optinfo (); > > + info.handle_dump_file_kind (dump_kind); > > + info.add_tree (t, extra_dump_flags); > > + } > > } > > > > > > @@ -511,8 +552,10 @@ dump_generic_expr (dump_flags_t dump_kind, > > dump_flags_t extra_dump_flags, > > location. */ > > > > void > > -dump_generic_expr_loc (dump_flags_t dump_kind, const > > dump_location_t &loc, > > - dump_flags_t extra_dump_flags, tree t) > > +dump_context::dump_generic_expr_loc (dump_flags_t dump_kind, > > + const dump_location_t &loc, > > + dump_flags_t extra_dump_flags, > > + tree t) > > { > > location_t srcloc = loc.get_location_t (); > > if (dump_file && (dump_kind & pflags)) > > @@ -526,53 +569,82 @@ dump_generic_expr_loc (dump_flags_t > > dump_kind, const dump_location_t &loc, > > dump_loc (dump_kind, alt_dump_file, srcloc); > > print_generic_expr (alt_dump_file, t, dump_flags | > > extra_dump_flags); > > } > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = begin_next_optinfo (loc); > > + info.handle_dump_file_kind (dump_kind); > > + info.add_tree (t, extra_dump_flags); > > + } > > } > > > > /* Output a formatted message using FORMAT on appropriate dump > > streams. */ > > > > void > > -dump_printf (dump_flags_t dump_kind, const char *format, ...) > > +dump_context::dump_printf_va (dump_flags_t dump_kind, const char > > *format, > > + va_list ap) > > { > > if (dump_file && (dump_kind & pflags)) > > { > > - va_list ap; > > - va_start (ap, format); > > - vfprintf (dump_file, format, ap); > > - va_end (ap); > > + va_list aq; > > + va_copy (aq, ap); > > + vfprintf (dump_file, format, aq); > > + va_end (aq); > > } > > > > if (alt_dump_file && (dump_kind & alt_flags)) > > { > > - va_list ap; > > - va_start (ap, format); > > - vfprintf (alt_dump_file, format, ap); > > - va_end (ap); > > + va_list aq; > > + va_copy (aq, ap); > > + vfprintf (alt_dump_file, format, aq); > > + va_end (aq); > > + } > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = ensure_pending_optinfo (); > > + va_list aq; > > + va_copy (aq, ap); > > + info.add_printf_va (format, aq); > > + va_end (aq); > > } > > } > > > > -/* Similar to dump_printf, except source location is also > > printed. */ > > +/* Similar to dump_printf, except source location is also printed, > > and > > + dump location captured. */ > > > > void > > -dump_printf_loc (dump_flags_t dump_kind, const dump_location_t > > &loc, > > - const char *format, ...) > > +dump_context::dump_printf_loc_va (dump_flags_t dump_kind, const > > dump_location_t &loc, > > + const char *format, va_list ap) > > { > > location_t srcloc = loc.get_location_t (); > > + > > if (dump_file && (dump_kind & pflags)) > > { > > - va_list ap; > > dump_loc (dump_kind, dump_file, srcloc); > > - va_start (ap, format); > > - vfprintf (dump_file, format, ap); > > - va_end (ap); > > + va_list aq; > > + va_copy (aq, ap); > > + vfprintf (dump_file, format, aq); > > + va_end (aq); > > } > > > > if (alt_dump_file && (dump_kind & alt_flags)) > > { > > - va_list ap; > > dump_loc (dump_kind, alt_dump_file, srcloc); > > - va_start (ap, format); > > - vfprintf (alt_dump_file, format, ap); > > - va_end (ap); > > + va_list aq; > > + va_copy (aq, ap); > > + vfprintf (alt_dump_file, format, aq); > > + va_end (aq); > > + } > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = begin_next_optinfo (loc); > > + info.handle_dump_file_kind (dump_kind); > > + va_list aq; > > + va_copy (aq, ap); > > + info.add_printf_va (format, aq); > > + va_end (aq); > > } > > } > > > > @@ -580,7 +652,7 @@ dump_printf_loc (dump_flags_t dump_kind, const > > dump_location_t &loc, > > > > template<unsigned int N, typename C> > > void > > -dump_dec (dump_flags_t dump_kind, const poly_int<N, C> &value) > > +dump_context::dump_dec (dump_flags_t dump_kind, const poly_int<N, > > C> &value) > > { > > STATIC_ASSERT (poly_coeff_traits<C>::signedness >= 0); > > signop sgn = poly_coeff_traits<C>::signedness ? SIGNED : > > UNSIGNED; > > @@ -589,6 +661,203 @@ dump_dec (dump_flags_t dump_kind, const > > poly_int<N, C> &value) > > > > if (alt_dump_file && (dump_kind & alt_flags)) > > print_dec (value, alt_dump_file, sgn); > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = ensure_pending_optinfo (); > > + info.handle_dump_file_kind (dump_kind); > > + info.add_poly_int<N,C> (value); > > + } > > +} > > + > > +/* Output the name of NODE on appropriate dump streams. */ > > + > > +void > > +dump_context::dump_symtab_node (dump_flags_t dump_kind, > > symtab_node *node) > > +{ > > + if (dump_file && (dump_kind & pflags)) > > + fprintf (dump_file, "%s", node->dump_name ()); > > + > > + if (alt_dump_file && (dump_kind & alt_flags)) > > + fprintf (alt_dump_file, "%s", node->dump_name ()); > > + > > + if (optinfo_enabled_p ()) > > + { > > + optinfo &info = ensure_pending_optinfo (); > > + info.handle_dump_file_kind (dump_kind); > > + info.add_symtab_node (node); > > + } > > +} > > + > > +/* Get the current dump scope-nesting depth. > > + For use by -fopt-info (for showing nesting via > > indentation). */ > > + > > +unsigned int > > +dump_context::get_scope_depth () const > > +{ > > + return m_scope_depth; > > +} > > + > > +/* Push a nested dump scope. > > + Print "=== NAME ===\n" to the dumpfile, if any, and to the > > -fopt-info > > + destination, if any. > > + Emit a "scope" optinfo if optinfos are enabled. > > + Increment the scope depth. */ > > + > > +void > > +dump_context::begin_scope (const char *name, const dump_location_t > > &loc) > > +{ > > + /* Specialcase, to avoid going through dump_printf_loc, > > + so that we can create a optinfo of kind > > OPTINFO_KIND_SCOPE. */ > > + > > + if (dump_file) > > + { > > + dump_loc (MSG_NOTE, dump_file, loc.get_location_t ()); > > + fprintf (dump_file, "=== %s ===\n", name); > > + } > > + > > + if (alt_dump_file) > > + { > > + dump_loc (MSG_NOTE, alt_dump_file, loc.get_location_t ()); > > + fprintf (alt_dump_file, "=== %s ===\n", name); > > + } > > + > > + if (optinfo_enabled_p ()) > > + { > > + end_any_optinfo (); > > + optinfo info (loc, OPTINFO_KIND_SCOPE, current_pass); > > + info.add_printf ("=== %s ===", name); > > + info.emit (); > > + } > > + > > + m_scope_depth++; > > +} > > + > > +/* Pop a nested dump scope. */ > > + > > +void > > +dump_context::end_scope () > > +{ > > + end_any_optinfo (); > > + m_scope_depth--; > > +} > > + > > +/* Return the optinfo currently being accumulated, creating one if > > + necessary. */ > > + > > +optinfo & > > +dump_context::ensure_pending_optinfo () > > +{ > > + if (!m_pending) > > + return begin_next_optinfo (dump_location_t > > (dump_user_location_t ())); > > + return *m_pending; > > +} > > + > > +/* Start a new optinfo and return it, ending any optinfo that was > > already > > + accumulated. */ > > + > > +optinfo & > > +dump_context::begin_next_optinfo (const dump_location_t &loc) > > +{ > > + end_any_optinfo (); > > + gcc_assert (m_pending == NULL); > > + m_pending = new optinfo (loc, OPTINFO_KIND_NOTE, current_pass); > > + return *m_pending; > > +} > > + > > +/* End any optinfo that has been accumulated within this context; > > emitting > > + it to any destinations as appropriate - though none have > > currently been > > + implemented. */ > > + > > +void > > +dump_context::end_any_optinfo () > > +{ > > + if (m_pending) > > + m_pending->emit (); > > + delete m_pending; > > + m_pending = NULL; > > +} > > + > > +/* The current singleton dump_context, and its default. */ > > + > > +dump_context *dump_context::s_current = &dump_context::s_default; > > +dump_context dump_context::s_default; > > + > > +/* Implementation of dump_* API calls, calling into dump_context > > + member functions. */ > > + > > +/* Dump gimple statement GS with SPC indentation spaces and > > + EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is > > enabled. */ > > + > > +void > > +dump_gimple_stmt (dump_flags_t dump_kind, dump_flags_t > > extra_dump_flags, > > + gimple *gs, int spc) > > +{ > > + dump_context::get ().dump_gimple_stmt (dump_kind, > > extra_dump_flags, gs, spc); > > +} > > + > > +/* Similar to dump_gimple_stmt, except additionally print source > > location. */ > > + > > +void > > +dump_gimple_stmt_loc (dump_flags_t dump_kind, const > > dump_location_t &loc, > > + dump_flags_t extra_dump_flags, gimple *gs, > > int spc) > > +{ > > + dump_context::get ().dump_gimple_stmt_loc (dump_kind, loc, > > extra_dump_flags, > > + gs, spc); > > +} > > + > > +/* Dump expression tree T using EXTRA_DUMP_FLAGS on dump streams > > if > > + DUMP_KIND is enabled. */ > > + > > +void > > +dump_generic_expr (dump_flags_t dump_kind, dump_flags_t > > extra_dump_flags, > > + tree t) > > +{ > > + dump_context::get ().dump_generic_expr (dump_kind, > > extra_dump_flags, t); > > +} > > + > > +/* Similar to dump_generic_expr, except additionally print the > > source > > + location. */ > > + > > +void > > +dump_generic_expr_loc (dump_flags_t dump_kind, const > > dump_location_t &loc, > > + dump_flags_t extra_dump_flags, tree t) > > +{ > > + dump_context::get ().dump_generic_expr_loc (dump_kind, loc, > > extra_dump_flags, > > + t); > > +} > > + > > +/* Output a formatted message using FORMAT on appropriate dump > > streams. */ > > + > > +void > > +dump_printf (dump_flags_t dump_kind, const char *format, ...) > > +{ > > + va_list ap; > > + va_start (ap, format); > > + dump_context::get ().dump_printf_va (dump_kind, format, ap); > > + va_end (ap); > > +} > > + > > +/* Similar to dump_printf, except source location is also printed, > > and > > + dump location captured. */ > > + > > +void > > +dump_printf_loc (dump_flags_t dump_kind, const dump_location_t > > &loc, > > + const char *format, ...) > > +{ > > + va_list ap; > > + va_start (ap, format); > > + dump_context::get ().dump_printf_loc_va (dump_kind, loc, format, > > ap); > > + va_end (ap); > > +} > > + > > +/* Output VALUE in decimal to appropriate dump streams. */ > > + > > +template<unsigned int N, typename C> > > +void > > +dump_dec (dump_flags_t dump_kind, const poly_int<N, C> &value) > > +{ > > + dump_context::get ().dump_dec (dump_kind, value); > > } > > > > template void dump_dec (dump_flags_t, const poly_uint16 &); > > @@ -597,29 +866,42 @@ 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. */ > > +/* Emit and delete the currently pending optinfo, if there is one, > > + without the caller needing to know about class > > dump_context. */ > > + > > +void > > +dumpfile_ensure_any_optinfo_are_flushed () > > +{ > > + dump_context::get().end_any_optinfo (); > > +} > > + > > +/* Output the name of NODE on appropriate dump streams. */ > > > > -static int dump_scope_depth; > > +void > > +dump_symtab_node (dump_flags_t dump_kind, symtab_node *node) > > +{ > > + dump_context::get ().dump_symtab_node (dump_kind, node); > > +} > > > > /* Get the current dump scope-nesting depth. > > - For use by dump_*_loc (for showing nesting via > > indentation). */ > > + For use by -fopt-info (for showing nesting via > > indentation). */ > > > > unsigned int > > get_dump_scope_depth () > > { > > - return dump_scope_depth; > > + return dump_context::get ().get_scope_depth (); > > } > > > > /* Push a nested dump scope. > > Print "=== NAME ===\n" to the dumpfile, if any, and to the > > -fopt-info > > destination, if any. > > + Emit a "scope" opinfo if optinfos are enabled. > > 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++; > > + dump_context::get ().begin_scope (name, loc); > > } > > > > /* Pop a nested dump scope. */ > > @@ -627,7 +909,7 @@ dump_begin_scope (const char *name, const > > dump_location_t &loc) > > void > > dump_end_scope () > > { > > - dump_scope_depth--; > > + dump_context::get ().end_scope (); > > } > > > > /* Start a dump for PHASE. Store user-supplied dump flags in > > @@ -1180,6 +1462,24 @@ enable_rtl_dump_file (void) > > > > #if CHECKING_P > > > > +/* temp_dump_context's ctor. Temporarily override the > > dump_context > > + (to forcibly enable optinfo-generation). */ > > + > > +temp_dump_context::temp_dump_context (bool > > forcibly_enable_optinfo) > > +: m_context (), > > + m_saved (&dump_context ().get ()) > > +{ > > + dump_context::s_current = &m_context; > > + m_context.m_forcibly_enable_optinfo = forcibly_enable_optinfo; > > +} > > + > > +/* temp_dump_context's dtor. Restore the saved dump_context. */ > > + > > +temp_dump_context::~temp_dump_context () > > +{ > > + dump_context::s_current = m_saved; > > +} > > + > > namespace selftest { > > > > /* Verify that the dump_location_t constructors capture the source > > location > > @@ -1216,12 +1516,136 @@ test_impl_location () > > #endif > > } > > > > +/* Verify that ITEM is a text item, with EXPECTED_TEXT. */ > > + > > +static void > > +assert_is_text (const optinfo_item *item, const char > > *expected_text) > > +{ > > + ASSERT_EQ (item->get_kind (), OPTINFO_ITEM_KIND_TEXT); > > + const optinfo_item_text * text_item > > + = static_cast <const optinfo_item_text *> (item); > > + ASSERT_STREQ (text_item->get_text (), expected_text); > > +} > > + > > +/* Verify that ITEM is a tree item, with the expected values. */ > > + > > +static void > > +assert_is_tree (const optinfo_item *item, tree expected_tree, > > + dump_flags_t expected_dump_flags) > > +{ > > + ASSERT_EQ (item->get_kind (), OPTINFO_ITEM_KIND_TREE); > > + const optinfo_item_tree * tree_item > > + = static_cast <const optinfo_item_tree *> (item); > > + ASSERT_EQ (tree_item->get_node (), expected_tree); > > + ASSERT_EQ (tree_item->get_flags (), expected_dump_flags); > > +} > > + > > +/* Verify that ITEM is a gimple item, with the expected > > values. */ > > + > > +static void > > +assert_is_gimple (const optinfo_item *item, gimple *expected_stmt, > > + dump_flags_t expected_dump_flags) > > +{ > > + ASSERT_EQ (item->get_kind (), OPTINFO_ITEM_KIND_GIMPLE); > > + const optinfo_item_gimple * gimple_item > > + = static_cast <const optinfo_item_gimple *> (item); > > + ASSERT_EQ (gimple_item->get_stmt (), expected_stmt); > > + ASSERT_EQ (gimple_item->get_flags (), expected_dump_flags); > > +} > > + > > +/* Verify that calls to the dump_* API are captured and > > consolidated into > > + optimization records. */ > > + > > +static void > > +test_capture_of_dump_calls () > > +{ > > + dump_location_t loc; > > + > > + /* Tree, via dump_generic_expr. */ > > + { > > + temp_dump_context tmp (true); > > + dump_printf_loc (MSG_NOTE, loc, "test of tree: "); > > + dump_generic_expr (MSG_NOTE, TDF_SLIM, integer_zero_node); > > + > > + optinfo *info = tmp.get_pending_optinfo (); > > + ASSERT_TRUE (info != NULL); > > + ASSERT_EQ (info->get_kind (), OPTINFO_KIND_NOTE); > > + ASSERT_EQ (info->num_items (), 2); > > + assert_is_text (info->get_item (0), "test of tree: "); > > + assert_is_tree (info->get_item (1), integer_zero_node, > > TDF_SLIM); > > + } > > + > > + /* Tree, via dump_generic_expr_loc. */ > > + { > > + temp_dump_context tmp (true); > > + dump_generic_expr_loc (MSG_NOTE, loc, TDF_SLIM, > > integer_one_node); > > + > > + optinfo *info = tmp.get_pending_optinfo (); > > + ASSERT_TRUE (info != NULL); > > + ASSERT_EQ (info->get_kind (), OPTINFO_KIND_NOTE); > > + ASSERT_EQ (info->num_items (), 1); > > + assert_is_tree (info->get_item (0), integer_one_node, > > TDF_SLIM); > > + } > > + > > + /* Gimple. */ > > + { > > + greturn *stmt = gimple_build_return (NULL); > > + > > + temp_dump_context tmp (true); > > + dump_gimple_stmt_loc (MSG_NOTE, loc, TDF_SLIM, stmt, 0); > > + > > + optinfo *info = tmp.get_pending_optinfo (); > > + ASSERT_TRUE (info != NULL); > > + ASSERT_EQ (info->num_items (), 1); > > + assert_is_gimple (info->get_item (0), stmt, TDF_SLIM); > > + > > + /* Verify that optinfo instances are flushed if a GC is about > > to > > + happen (and thus don't need to be GTY-marked). > > + We don't want them in the PCH file, but we don't want the > > + items to have their data collected from under them. */ > > + selftest::forcibly_ggc_collect (); > > + ASSERT_TRUE (tmp.get_pending_optinfo () == NULL); > > + } > > + > > + /* poly_int. */ > > + { > > + temp_dump_context tmp (true); > > + dump_dec (MSG_NOTE, poly_int64 (42)); > > + > > + optinfo *info = tmp.get_pending_optinfo (); > > + ASSERT_TRUE (info != NULL); > > + ASSERT_EQ (info->num_items (), 1); > > + assert_is_text (info->get_item (0), "42"); > > + } > > + > > + /* Verify that MSG_* affects optinfo->get_kind (); we tested > > MSG_NOTE > > + above. */ > > + { > > + /* MSG_OPTIMIZED_LOCATIONS. */ > > + { > > + temp_dump_context tmp (true); > > + dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc, "test"); > > + ASSERT_EQ (tmp.get_pending_optinfo ()->get_kind (), > > + OPTINFO_KIND_SUCCESS); > > + } > > + > > + /* MSG_MISSED_OPTIMIZATION. */ > > + { > > + temp_dump_context tmp (true); > > + dump_printf_loc (MSG_MISSED_OPTIMIZATION, loc, "test"); > > + ASSERT_EQ (tmp.get_pending_optinfo ()->get_kind (), > > + OPTINFO_KIND_FAILURE); > > + } > > + } > > +} > > + > > /* Run all of the selftests within this file. */ > > > > void > > dumpfile_c_tests () > > { > > test_impl_location (); > > + test_capture_of_dump_calls (); > > } > > > > } // namespace selftest > > diff --git a/gcc/dumpfile.h b/gcc/dumpfile.h > > index 0e588a6..899bb89 100644 > > --- a/gcc/dumpfile.h > > +++ b/gcc/dumpfile.h > > @@ -420,30 +420,6 @@ extern FILE *dump_begin (int, dump_flags_t *); > > extern void dump_end (int, FILE *); > > extern int opt_info_switch_p (const char *); > > extern const char *dump_flag_name (int); > > -extern void dump_printf (dump_flags_t, const char *, ...) > > ATTRIBUTE_PRINTF_2; > > -extern void dump_printf_loc (dump_flags_t, const dump_location_t > > &, > > - const char *, ...) ATTRIBUTE_PRINTF_3; > > -extern void dump_function (int phase, tree fn); > > -extern void dump_basic_block (dump_flags_t, basic_block, int); > > -extern void dump_generic_expr_loc (dump_flags_t, const > > dump_location_t &, > > - dump_flags_t, tree); > > -extern void dump_generic_expr (dump_flags_t, dump_flags_t, tree); > > -extern void dump_gimple_stmt_loc (dump_flags_t, const > > dump_location_t &, > > - dump_flags_t, gimple *, int); > > -extern void dump_gimple_stmt (dump_flags_t, dump_flags_t, gimple > > *, int); > > -extern void print_combine_total_stats (void); > > -extern bool enable_rtl_dump_file (void); > > - > > -template<unsigned int N, typename C> > > -void dump_dec (dump_flags_t, const poly_int<N, C> &); > > - > > -/* In tree-dump.c */ > > -extern void dump_node (const_tree, dump_flags_t, FILE *); > > - > > -/* In combine.c */ > > -extern void dump_combine_total_stats (FILE *); > > -/* In cfghooks.c */ > > -extern void dump_bb (FILE *, basic_block, int, dump_flags_t); > > > > /* Global variables used to communicate with passes. */ > > extern FILE *dump_file; > > @@ -461,6 +437,49 @@ dump_enabled_p (void) > > return dumps_are_enabled; > > } > > > > +/* The following API calls (which *don't* take a "FILE *") > > + write the output to zero or more locations: > > + (a) the active dump_file, if any > > + (b) the -fopt-info destination, if any > > + (c) to the "optinfo" destinations, if any: > > + > > + dump_* (MSG_*) --> dumpfile.c --+--> (a) dump_file > > + | > > + +--> (b) alt_dump_file > > + | > > + `--> (c) optinfo > > + `---> optinfo > > destinations > > + > > + For optinfos, the dump_*_loc mark the beginning of an optinfo > > + instance: all subsequent dump_* calls are consolidated into > > + that optinfo, until the next dump_*_loc call (or a change in > > + dump scope, or a call to > > dumpfile_ensure_any_optinfo_are_flushed). > > + > > + A group of dump_* calls should be guarded by: > > + > > + if (dump_enabled_p ()) > > + > > + to minimize the work done for the common case where dumps > > + are disabled. */ > > + > > +extern void dump_printf (dump_flags_t, const char *, ...) > > ATTRIBUTE_PRINTF_2; > > +extern void dump_printf_loc (dump_flags_t, const dump_location_t > > &, > > + const char *, ...) ATTRIBUTE_PRINTF_3; > > +extern void dump_function (int phase, tree fn); > > +extern void dump_basic_block (dump_flags_t, basic_block, int); > > +extern void dump_generic_expr (dump_flags_t, dump_flags_t, tree); > > +extern void dump_generic_expr_loc (dump_flags_t, const > > dump_location_t &, > > + dump_flags_t, tree); > > +extern void dump_gimple_stmt_loc (dump_flags_t, const > > dump_location_t &, > > + dump_flags_t, gimple *, int); > > +extern void dump_gimple_stmt (dump_flags_t, dump_flags_t, gimple > > *, int); > > +extern void dump_symtab_node (dump_flags_t, symtab_node *); > > + > > +template<unsigned int N, typename C> > > +void dump_dec (dump_flags_t, const poly_int<N, C> &); > > + > > +extern void dumpfile_ensure_any_optinfo_are_flushed (); > > + > > /* Managing nested scopes, so that dumps can express the call > > chain > > leading to a dump message. */ > > > > @@ -500,8 +519,23 @@ class auto_dump_scope > > #define AUTO_DUMP_SCOPE(NAME, LOC) \ > > auto_dump_scope scope (NAME, LOC) > > > > +extern void dump_function (int phase, tree fn); > > +extern void print_combine_total_stats (void); > > +extern bool enable_rtl_dump_file (void); > > + > > +/* In tree-dump.c */ > > +extern void dump_node (const_tree, dump_flags_t, FILE *); > > + > > +/* In combine.c */ > > +extern void dump_combine_total_stats (FILE *); > > +/* In cfghooks.c */ > > +extern void dump_bb (FILE *, basic_block, int, dump_flags_t); > > + > > namespace gcc { > > > > +/* A class for managing all of the various dump files used by the > > + optimization passes. */ > > + > > class dump_manager > > { > > public: > > diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c > > index 51783e5..f3a2119 100644 > > --- a/gcc/ggc-page.c > > +++ b/gcc/ggc-page.c > > @@ -2177,6 +2177,8 @@ ggc_collect (void) > > if (G.allocated < allocated_last_gc + min_expand && > > !ggc_force_collect) > > return; > > > > + dumpfile_ensure_any_optinfo_are_flushed (); > > + > > timevar_push (TV_GC); > > if (!quiet_flag) > > fprintf (stderr, " {GC %luk -> ", (unsigned long) G.allocated > > / 1024); > > diff --git a/gcc/optinfo-internal.h b/gcc/optinfo-internal.h > > new file mode 100644 > > index 0000000..8144174 > > --- /dev/null > > +++ b/gcc/optinfo-internal.h > > @@ -0,0 +1,148 @@ > > +/* Implementation details of optinfo. > > + Copyright (C) 2018 Free Software Foundation, Inc. > > + Contributed by David Malcolm <dmalc...@redhat.com>. > > + > > +This file is part of GCC. > > + > > +GCC is free software; you can redistribute it and/or modify it > > under > > +the terms of the GNU General Public License as published by the > > Free > > +Software Foundation; either version 3, or (at your option) any > > later > > +version. > > + > > +GCC is distributed in the hope that it will be useful, but WITHOUT > > ANY > > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public > > License > > +for more details. > > + > > +You should have received a copy of the GNU General Public License > > +along with GCC; see the file COPYING3. If not see > > +<http://www.gnu.org/licenses/>. */ > > + > > +#ifndef GCC_OPTINFO_INTERNAL_H > > +#define GCC_OPTINFO_INTERNAL_H > > + > > +/* Multiple dispatch: there are various kinds of items within an > > optinfo, > > + and various destinations to send optinfo to. > > + > > + Handling this for now by exposing all of the item subclasses, > > + and having the destinations handle them with "switch" > > statements. */ > > + > > +/* An enum for discriminating between optinfo_item subclasses. */ > > + > > +enum optinfo_item_kind > > +{ > > + OPTINFO_ITEM_KIND_TEXT, > > + OPTINFO_ITEM_KIND_TREE, > > + OPTINFO_ITEM_KIND_GIMPLE, > > + OPTINFO_ITEM_KIND_SYMTAB_NODE > > +}; > > + > > +/* Abstract base class for items within an optinfo. */ > > + > > +class optinfo_item > > +{ > > + public: > > + virtual ~optinfo_item () {} > > + > > + virtual enum optinfo_item_kind get_kind () const = 0; > > +}; > > + > > +/* optinfo_item subclasses. */ > > + > > +/* Item within an optinfo: text, either owned by the item > > + (for optinfo_printf), or borrowed (for string literals). */ > > + > > +class optinfo_item_text : public optinfo_item > > +{ > > + public: > > + optinfo_item_text (char *text, bool owned) > > + : m_text (text), m_owned (owned) > > + {} > > + ~optinfo_item_text () > > + { > > + if (m_owned) > > + free (m_text); > > + } > > + > > + enum optinfo_item_kind get_kind () const FINAL OVERRIDE > > + { > > + return OPTINFO_ITEM_KIND_TEXT; > > + } > > + > > + const char *get_text () const { return m_text; } > > + > > + void trim_trailing_whitespace (); > > + > > + private: > > + char *m_text; > > + bool m_owned; > > +}; > > + > > +/* Item within an optinfo: a tree, with dump flags. > > + Note that this is not GTY-marked; see the description of > > + class optinfo for a discussion of the interaction with the > > + garbage-collector. */ > > + > > +class optinfo_item_tree : public optinfo_item > > +{ > > + public: > > + optinfo_item_tree (tree node, dump_flags_t dump_flags) > > + : m_node (node), m_dump_flags (dump_flags) > > + {} > > + enum optinfo_item_kind get_kind () const FINAL OVERRIDE > > + { > > + return OPTINFO_ITEM_KIND_TREE; > > + } > > + > > + tree get_node () const { return m_node; } > > + dump_flags_t get_flags () const { return m_dump_flags; } > > + > > + private: > > + tree m_node; > > + dump_flags_t m_dump_flags; > > +}; > > + > > +/* Item within an optinfo: a gimple statement. > > + Note that this is not GTY-marked; see the description of > > + class optinfo for a discussion of the interaction with the > > + garbage-collector. */ > > + > > +class optinfo_item_gimple : public optinfo_item > > +{ > > + public: > > + optinfo_item_gimple (gimple *stmt, dump_flags_t dump_flags) > > + : m_stmt (stmt), m_dump_flags (dump_flags) {} > > + enum optinfo_item_kind get_kind () const FINAL OVERRIDE > > + { > > + return OPTINFO_ITEM_KIND_GIMPLE; > > + } > > + > > + gimple *get_stmt () const { return m_stmt; } > > + dump_flags_t get_flags () const { return m_dump_flags; } > > + > > + private: > > + gimple *m_stmt; > > + dump_flags_t m_dump_flags; > > +}; > > + > > +/* Item within an optinfo: a symbol table node. > > + Note that this is not GTY-marked; see the description of > > + class optinfo for a discussion of the interaction with the > > + garbage-collector. */ > > + > > +class optinfo_item_symtab_node : public optinfo_item > > +{ > > + public: > > + optinfo_item_symtab_node (symtab_node *node) : m_node (node) {} > > + enum optinfo_item_kind get_kind () const FINAL OVERRIDE > > + { > > + return OPTINFO_ITEM_KIND_SYMTAB_NODE; > > + } > > + > > + symtab_node *get_node () const { return m_node; } > > + > > + private: > > + symtab_node *m_node; > > +}; > > + > > +#endif /* #ifndef GCC_OPTINFO_INTERNAL_H */ > > diff --git a/gcc/optinfo.cc b/gcc/optinfo.cc > > new file mode 100644 > > index 0000000..1da7d37 > > --- /dev/null > > +++ b/gcc/optinfo.cc > > @@ -0,0 +1,251 @@ > > +/* Optimization information. > > + Copyright (C) 2018 Free Software Foundation, Inc. > > + Contributed by David Malcolm <dmalc...@redhat.com>. > > + > > +This file is part of GCC. > > + > > +GCC is free software; you can redistribute it and/or modify it > > under > > +the terms of the GNU General Public License as published by the > > Free > > +Software Foundation; either version 3, or (at your option) any > > later > > +version. > > + > > +GCC is distributed in the hope that it will be useful, but WITHOUT > > ANY > > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public > > License > > +for more details. > > + > > +You should have received a copy of the GNU General Public License > > +along with GCC; see the file COPYING3. If not see > > +<http://www.gnu.org/licenses/>. */ > > + > > +#include "config.h" > > +#include "system.h" > > +#include "coretypes.h" > > + > > +#include "backend.h" > > +#include "tree.h" > > +#include "gimple.h" > > + > > +#include "optinfo.h" > > +#include "optinfo-internal.h" > > +#include "dump-context.h" > > +#include "selftest.h" > > + > > +/* Remove any trailing whitespace characters from this text item. > > + Primarily for use in stripping trailing newline characters when > > + emitting remarks (since the diagnostic subsystem doesn't expect > > + trailing newlines in messages). */ > > + > > +void > > +optinfo_item_text::trim_trailing_whitespace () > > +{ > > + size_t len = strlen (m_text); > > + if (len == 0) > > + return; > > + > > + size_t new_len = len; > > + while (new_len > 0 && ISSPACE (m_text[new_len - 1])) > > + new_len--; > > + > > + if (new_len == len) > > + return; > > + > > + if (m_owned) > > + m_text[new_len] = '\0'; > > + else > > + { > > + m_text = xstrndup (m_text, new_len); > > + m_owned = true; > > + } > > +} > > + > > +/* Get a string from KIND. */ > > + > > +const char * > > +optinfo_kind_to_string (enum optinfo_kind kind) > > +{ > > + switch (kind) > > + { > > + default: > > + gcc_unreachable (); > > + case OPTINFO_KIND_SUCCESS: > > + return "success"; > > + case OPTINFO_KIND_FAILURE: > > + return "failure"; > > + case OPTINFO_KIND_NOTE: > > + return "note"; > > + case OPTINFO_KIND_SCOPE: > > + return "scope"; > > + } > > +} > > + > > +/* optinfo's dtor. */ > > + > > +optinfo::~optinfo () > > +{ > > + /* Cleanup. */ > > + unsigned i; > > + optinfo_item *item; > > + FOR_EACH_VEC_ELT (m_items, i, item) > > + delete item; > > +} > > + > > +/* Emit the optinfo to all of the active destinations. */ > > + > > +void > > +optinfo::emit () > > +{ > > + /* Eliminate any trailing whitespace. */ > > + while (m_items.length () > 0) > > + { > > + optinfo_item *last_item = m_items[m_items.length () - 1]; > > + if (last_item->get_kind () != OPTINFO_ITEM_KIND_TEXT) > > + break; > > + > > + optinfo_item_text *last_text = (optinfo_item_text > > *)last_item; > > + last_text->trim_trailing_whitespace (); > > + > > + if (strlen (last_text->get_text ()) > 0) > > + break; > > + > > + m_items.pop (); > > + delete last_item; > > + } > > + > > + /* currently this is a no-op. */ > > +} > > + > > +/* Update the optinfo's kind based on DUMP_KIND. */ > > + > > +void > > +optinfo::handle_dump_file_kind (dump_flags_t dump_kind) > > +{ > > + if (dump_kind & MSG_OPTIMIZED_LOCATIONS) > > + m_kind = OPTINFO_KIND_SUCCESS; > > + else if (dump_kind & MSG_MISSED_OPTIMIZATION) > > + m_kind = OPTINFO_KIND_FAILURE; > > + else if (dump_kind & MSG_NOTE) > > + m_kind = OPTINFO_KIND_NOTE; > > +} > > + > > +/* Append a string literal to this optinfo. */ > > + > > +void > > +optinfo::add_string (const char *str) > > +{ > > + optinfo_item *item > > + = new optinfo_item_text (const_cast <char *> (str), false); > > + m_items.safe_push (item); > > +} > > + > > +/* Append printf-formatted text to this optinfo. */ > > + > > +void > > +optinfo::add_printf (const char *format, ...) > > +{ > > + va_list ap; > > + va_start (ap, format); > > + add_printf_va (format, ap); > > + va_end (ap); > > +} > > + > > +/* Append printf-formatted text to this optinfo. */ > > + > > +void > > +optinfo::add_printf_va (const char *format, va_list ap) > > +{ > > + char *formatted_text = xvasprintf (format, ap); > > + optinfo_item *item > > + = new optinfo_item_text (formatted_text, true); > > + m_items.safe_push (item); > > +} > > + > > +/* Append a gimple statement to this optinfo. */ > > + > > +void > > +optinfo::add_stmt (gimple *stmt, dump_flags_t dump_flags) > > +{ > > + m_items.safe_push (new optinfo_item_gimple (stmt, dump_flags)); > > +} > > + > > +/* Append a tree node to this optinfo. */ > > + > > +void > > +optinfo::add_tree (tree node, dump_flags_t dump_flags) > > +{ > > + m_items.safe_push (new optinfo_item_tree (node, dump_flags)); > > +} > > + > > +/* Append a symbol table node to this optinfo. */ > > + > > +void > > +optinfo::add_symtab_node (symtab_node *node) > > +{ > > + m_items.safe_push (new optinfo_item_symtab_node (node)); > > +} > > + > > +/* Append the decimal represenation of a wide_int_ref to this > > + optinfo. */ > > + > > +void > > +optinfo::add_dec (const wide_int_ref &wi, signop sgn) > > +{ > > + char buf[WIDE_INT_PRINT_BUFFER_SIZE]; > > + print_dec (wi, buf, sgn); > > + optinfo_item *item > > + = new optinfo_item_text (xstrdup (buf), true); > > + m_items.safe_push (item); > > +} > > + > > +/* Should optinfo instances be created? > > + All creation of optinfos should be guarded by this predicate. > > + Return true if any optinfo destinations are active. */ > > + > > +bool optinfo_enabled_p () > > +{ > > + /* Currently no destinations are implemented, just a hook for > > + selftests. */ > > + return dump_context::get ().forcibly_enable_optinfo_p (); > > +} > > + > > +/* Return true if any of the active optinfo destinations make use > > + of inlining information. > > + (if true, then the information is preserved). */ > > + > > +bool optinfo_wants_inlining_info_p () > > +{ > > + return false; > > +} > > + > > +#if CHECKING_P > > + > > +namespace selftest { > > + > > +/* Verify that optinfo_item_text::trim_trailing_whitespace turns > > + INPUT into EXPECTED. */ > > + > > +static void > > +test_trim_trailing_whitespace (const char *input, const char > > *expected) > > +{ > > + optinfo_item_text item (const_cast <char *> (input), false); > > + item.trim_trailing_whitespace (); > > + ASSERT_STREQ (item.get_text (), expected); > > +} > > + > > +/* Run all of the selftests within this file. */ > > + > > +void > > +optinfo_cc_tests () > > +{ > > + /* Verify that optinfo_item_text::trim_trailing_whitespace > > works. */ > > + test_trim_trailing_whitespace ("", ""); > > + test_trim_trailing_whitespace ("\n", ""); > > + test_trim_trailing_whitespace ("foo", "foo"); > > + test_trim_trailing_whitespace ("foo\n", "foo"); > > + test_trim_trailing_whitespace ("foo\n\n", "foo"); > > + test_trim_trailing_whitespace ("foo bar \n\n", "foo bar"); > > +} > > + > > +} // namespace selftest > > + > > +#endif /* CHECKING_P */ > > diff --git a/gcc/optinfo.h b/gcc/optinfo.h > > new file mode 100644 > > index 0000000..0d49823 > > --- /dev/null > > +++ b/gcc/optinfo.h > > @@ -0,0 +1,175 @@ > > +/* Optimization information. > > + Copyright (C) 2018 Free Software Foundation, Inc. > > + Contributed by David Malcolm <dmalc...@redhat.com>. > > + > > +This file is part of GCC. > > + > > +GCC is free software; you can redistribute it and/or modify it > > under > > +the terms of the GNU General Public License as published by the > > Free > > +Software Foundation; either version 3, or (at your option) any > > later > > +version. > > + > > +GCC is distributed in the hope that it will be useful, but WITHOUT > > ANY > > +WARRANTY; without even the implied warranty of MERCHANTABILITY or > > +FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public > > License > > +for more details. > > + > > +You should have received a copy of the GNU General Public License > > +along with GCC; see the file COPYING3. If not see > > +<http://www.gnu.org/licenses/>. */ > > + > > +#ifndef GCC_OPTINFO_H > > +#define GCC_OPTINFO_H > > + > > +/* An "optinfo" is a bundle of information describing part of an > > + optimization, which can be emitted to zero or more of several > > + destinations, such as: > > + > > + * as a "remark" through the diagnostics subsystem > > + > > + * saved to a file as an "optimization record" > > + > > + Currently no such destinations are implemented. > > + > > + They are generated in response to calls to the "dump_*" API in > > + dumpfile.h; repeated calls to the "dump_*" API are consolidated > > + into a pending optinfo instance, with a "dump_*_loc" starting a > > new > > + optinfo instance. > > + > > + The data sent to the dump calls are captured within the pending > > optinfo > > + instance as a sequence of optinfo_items. For example, given: > > + > > + if (dump_enabled_p ()) > > + { > > + dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, > > + "not vectorized: live stmt not > > supported: "); > > + dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, > > stmt, 0); > > + } > > + > > + the "dump_printf_loc" call begins a new optinfo containing two > > items: > > + (1) a text item containing "not vectorized: live stmt not > > supported: " > > + (2) a gimple item for "stmt" > > + > > + Dump destinations are thus able to access rich metadata about > > the > > + items when the optinfo is emitted to them, rather than just > > having plain > > + text. For example, when saving the above optinfo to a file as > > an > > + "optimization record", the record could capture the source > > location of > > + "stmt" above, rather than just its textual form. > > + > > + The currently pending optinfo is emitted and deleted: > > + * each time a "dump_*_loc" call occurs (which starts the next > > optinfo), or > > + * when the dump files are changed (at the end of a pass), or > > + * when a garbage collection is about to happen. This safety > > measure > > + ensures that no GC happens during the lifetime of an optinfo > > instance, > > + and thus that any optinfo_items within the optinfo instances > > can refer > > + to GC-allocated objects without needing to be GTY-marked: > > they will never > > + refer to collected garbage. optinfo and optinfo_item are not > > GTY-marked > > + as it would make no sense for them to be in PCH files. > > + > > + Dumping to an optinfo instance is non-trivial (due to building > > optinfo_item > > + instances), so all usage should be guarded by > > + > > + if (optinfo_enabled_p ()) > > + > > + which is off by default. */ > > + > > + > > +/* Forward decls. */ > > +struct opt_pass; > > +class optinfo_item; /* optinfo-internal.h. */ > > + > > +/* Should optinfo instances be created? > > + All creation of optinfos should be guarded by this predicate. > > + Return true if any optinfo destinations are active. */ > > + > > +extern bool optinfo_enabled_p (); > > + > > +/* Return true if any of the active optinfo destinations make use > > + of inlining information. > > + (if true, then the information is preserved). */ > > + > > +extern bool optinfo_wants_inlining_info_p (); > > + > > +/* The various kinds of optinfo. */ > > + > > +enum optinfo_kind > > +{ > > + OPTINFO_KIND_SUCCESS, > > + OPTINFO_KIND_FAILURE, > > + OPTINFO_KIND_NOTE, > > + OPTINFO_KIND_SCOPE > > +}; > > + > > +extern const char *optinfo_kind_to_string (enum optinfo_kind > > kind); > > + > > +/* A bundle of information describing part of an optimization. */ > > + > > +class optinfo > > +{ > > + friend class dump_context; > > + > > + public: > > + optinfo (const dump_location_t &loc, > > + enum optinfo_kind kind, > > + opt_pass *pass) > > + : m_loc (loc), m_kind (kind), m_pass (pass), m_items () > > + {} > > + ~optinfo (); > > + > > + const dump_user_location_t & > > + get_user_location () const { return m_loc.get_user_location (); > > } > > + > > + const dump_impl_location_t & > > + get_impl_location () const { return m_loc.get_impl_location (); > > } > > + > > + enum optinfo_kind get_kind () const { return m_kind; } > > + opt_pass *get_pass () const { return m_pass; } > > + unsigned int num_items () const { return m_items.length (); } > > + const optinfo_item *get_item (unsigned int i) const { return > > m_items[i]; } > > + > > + location_t get_location_t () const { return m_loc.get_location_t > > (); } > > + profile_count get_count () const { return m_loc.get_count (); } > > + > > + private: > > + void emit (); > > + > > + /* Pre-canned ways of manipulating the optinfo, for use by > > friend class > > + dump_context. */ > > + void handle_dump_file_kind (dump_flags_t); > > + void add_string (const char *str); > > + void add_printf (const char *format, ...) ATTRIBUTE_PRINTF_2; > > + void add_printf_va (const char *format, va_list ap) > > ATTRIBUTE_PRINTF (2, 0); > > + void add_stmt (gimple *stmt, dump_flags_t dump_flags); > > + void add_tree (tree node, dump_flags_t dump_flags); > > + void add_symtab_node (symtab_node *node); > > + void add_dec (const wide_int_ref &wi, signop sgn); > > + > > + template<unsigned int N, typename C> > > + void add_poly_int (const poly_int<N, C> &value) > > + { > > + /* Compare with dump_dec (MSG_NOTE, ). */ > > + > > + STATIC_ASSERT (poly_coeff_traits<C>::signedness >= 0); > > + signop sgn = poly_coeff_traits<C>::signedness ? SIGNED : > > UNSIGNED; > > + > > + if (value.is_constant ()) > > + add_dec (value.coeffs[0], sgn); > > + else > > + { > > + add_string ("["); > > + for (unsigned int i = 0; i < N; ++i) > > + { > > + add_dec (value.coeffs[i], sgn); > > + add_string (i == N - 1 ? "]" : ","); > > + } > > + } > > + } > > + > > + private: > > + dump_location_t m_loc; > > + enum optinfo_kind m_kind; > > + opt_pass *m_pass; > > + auto_vec <optinfo_item *> m_items; > > +}; > > + > > +#endif /* #ifndef GCC_OPTINFO_H */ > > diff --git a/gcc/selftest-run-tests.c b/gcc/selftest-run-tests.c > > index 7f4d6f3..989c50a 100644 > > --- a/gcc/selftest-run-tests.c > > +++ b/gcc/selftest-run-tests.c > > @@ -72,6 +72,7 @@ selftest::run_tests () > > typed_splay_tree_c_tests (); > > unique_ptr_tests_cc_tests (); > > opt_proposer_c_tests (); > > + optinfo_cc_tests (); > > > > /* Mid-level data structures. */ > > input_c_tests (); > > diff --git a/gcc/selftest.h b/gcc/selftest.h > > index 54fc488..48881c9 100644 > > --- a/gcc/selftest.h > > +++ b/gcc/selftest.h > > @@ -228,6 +228,7 @@ extern void gimple_c_tests (); > > extern void hash_map_tests_c_tests (); > > extern void hash_set_tests_c_tests (); > > extern void input_c_tests (); > > +extern void optinfo_cc_tests (); > > extern void predict_c_tests (); > > extern void pretty_print_c_tests (); > > extern void read_rtl_function_c_tests (); > > -- > > 1.8.5.3 > >
