Fix missing dump_impl_location_t values, using a new dump_metadata_t

The dump_* API attempts to capture emission location metadata for the
various dump messages, but looking in -fsave-optimization-record shows
that many dump messages are lacking useful impl_location values, instead
having this location within dumpfile.c:

            "impl_location": {
                "file": "../../src/gcc/dumpfile.c",
                "function": "ensure_pending_optinfo",
                "line": 1169
            },

The problem is that the auto-capturing of dump_impl_location_t is tied to
dump_location_t, and this is tied to the dump_*_loc calls.  If a message
comes from a dump_* call without a "_loc" suffix (e.g. dump_printf), the
current code synthesizes the dump_location_t within
dump_context::ensure_pending_optinfo, and thus saves the useless
impl_location seen above.

This patch fixes things by changing the dump_* API so that, rather than
taking a dump_flags_t, they take a new class dump_metadata_t, which is
constructed from a dump_flags_t, but captures the emission location.

Hence e.g.:

  dump_printf (MSG_NOTE, "some message\n");

implicitly builds a dump_metadata_t wrapping the MSG_NOTE and the
emission location.  If there are several dump_printf calls without
a dump_*_loc call, the emission location within the optinfo is that
of the first dump call within it.

The patch updates selftest::test_capture_of_dump_calls to verify
that the impl location of various dump_* calls is captured.  I also
verified things manually.

gcc/ChangeLog:
	* dump-context.h (dump_context::dump_loc): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.  Convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_context::dump_loc_immediate): Convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_context::dump_gimple_stmt): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::void dump_gimple_stmt_loc): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_gimple_expr): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_gimple_expr_loc): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_generic_expr): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_generic_expr_loc): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_printf_va): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_printf_loc_va): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_dec): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_symtab_node): Likewise.
	(dump_context::begin_scope): Split out 2nd param into
	user and impl locations.
	(dump_context::ensure_pending_optinfo): Add metadata param.
	(dump_context::begin_next_optinfo): Replace dump_location_t param
	with metadata and user location.
	* dumpfile.c (dump_context::dump_loc): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.  Convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_context::dump_loc_immediate): Convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_context::dump_gimple_stmt): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::void dump_gimple_stmt_loc): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_gimple_expr): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_gimple_expr_loc): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_generic_expr): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_generic_expr_loc): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_printf_va): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_printf_loc_va): Likewise; convert
	2nd param from const dump_location_t & to
	const dump_user_location_t &.
	(dump_context::dump_dec): Convert 1st param from
	dump_flags_t to const dump_metadata_t &.
	(dump_context::dump_symtab_node): Likewise.
	(dump_context::begin_scope): Split out 2nd param into
	user and impl locations.
	(dump_context::ensure_pending_optinfo): Add metadata param.
	(dump_context::begin_next_optinfo): Replace dump_location_t param
	with metadata and user location.
	(dump_gimple_stmt): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_gimple_stmt_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_gimple_expr): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_gimple_expr_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_generic_expr): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_generic_expr_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_printf): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_printf_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_dec): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_symtab_node): Likewise.
	(dump_begin_scope): Split out 2nd param into user and impl
	locations.
	(selftest::assert_impl_location_eq): New function.
	(ASSERT_IMPL_LOCATION_EQ): New macro.
	(selftest::test_impl_location): Update to use
	ASSERT_IMPL_LOCATION_EQ.
	(selftest::test_capture_of_dump_calls): Convert "loc" to
	dump_user_location_t.  Add ASSERT_IMPL_LOCATION_EQ throughout,
	verifying line numbers of dump emissions.
	* dumpfile.h (class dump_metadata_t): New class.
	(dump_printf): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_printf_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_generic_expr_loc): Likewise.
	(dump_generic_expr): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_gimple_stmt_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_gimple_stmt): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_gimple_expr_loc): Likewise; convert 2nd param from
	const dump_location_t & to const dump_user_location_t &.
	(dump_gimple_expr): Convert 1st param from dump_flags_t to
	const dump_metadata_t &.
	(dump_symtab_node): Likewise.
	(dump_dec): Likewise.
	(dump_begin_scope): Split out 2nd param into user and impl
	locations.
	(auto_dump_scope::auto_dump_scope): Split "loc" param into a user
	location and impl_location, and capture the impl_location.
	(AUTO_DUMP_SCOPE): Rename param from LOC to USER_LOC.
	* loop-unroll.c (report_unroll): Update for changes to
	dump_printf_loc and dump_printf.
	* opt-problem.cc (opt_problem::opt_problem): Update for change to
	dump_loc.
	* optinfo-emit-json.cc
	(selftest::test_building_json_from_dump_calls): Convert "loc" from
	dump_location_t to dump_user_location_t.
	* optinfo.cc (optinfo::emit_for_opt_problem): Update for change in
	dump_loc_immediate.
	* profile.c (compute_branch_probabilities): Update for change to
	dump_printf_loc.
	* selftest.h (ASSERT_STR_CONTAINS_AT): New macro.
	* tree-vect-slp.c (vect_print_slp_tree): Update for change to
	dump_printf_loc.

From-SVN: r266501

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 78207cc1f0a81bacd9da15158a47181b69d9c332..c4ec55654086def59b84fbdf332d57a79daace9a 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,137 @@
+2018-11-26  David Malcolm  <dmalcolm@redhat.com>
+
+       * dump-context.h (dump_context::dump_loc): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.  Convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_context::dump_loc_immediate): Convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_context::dump_gimple_stmt): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::void dump_gimple_stmt_loc): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_gimple_expr): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_gimple_expr_loc): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_generic_expr): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_generic_expr_loc): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_printf_va): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_printf_loc_va): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_dec): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_symtab_node): Likewise.
+       (dump_context::begin_scope): Split out 2nd param into
+       user and impl locations.
+       (dump_context::ensure_pending_optinfo): Add metadata param.
+       (dump_context::begin_next_optinfo): Replace dump_location_t param
+       with metadata and user location.
+       * dumpfile.c (dump_context::dump_loc): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.  Convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_context::dump_loc_immediate): Convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_context::dump_gimple_stmt): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::void dump_gimple_stmt_loc): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_gimple_expr): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_gimple_expr_loc): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_generic_expr): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_generic_expr_loc): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_printf_va): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_printf_loc_va): Likewise; convert
+       2nd param from const dump_location_t & to
+       const dump_user_location_t &.
+       (dump_context::dump_dec): Convert 1st param from
+       dump_flags_t to const dump_metadata_t &.
+       (dump_context::dump_symtab_node): Likewise.
+       (dump_context::begin_scope): Split out 2nd param into
+       user and impl locations.
+       (dump_context::ensure_pending_optinfo): Add metadata param.
+       (dump_context::begin_next_optinfo): Replace dump_location_t param
+       with metadata and user location.
+       (dump_gimple_stmt): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_gimple_stmt_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_gimple_expr): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_gimple_expr_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_generic_expr): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_generic_expr_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_printf): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_printf_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_dec): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_symtab_node): Likewise.
+       (dump_begin_scope): Split out 2nd param into user and impl
+       locations.
+       (selftest::assert_impl_location_eq): New function.
+       (ASSERT_IMPL_LOCATION_EQ): New macro.
+       (selftest::test_impl_location): Update to use
+       ASSERT_IMPL_LOCATION_EQ.
+       (selftest::test_capture_of_dump_calls): Convert "loc" to
+       dump_user_location_t.  Add ASSERT_IMPL_LOCATION_EQ throughout,
+       verifying line numbers of dump emissions.
+       * dumpfile.h (class dump_metadata_t): New class.
+       (dump_printf): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_printf_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_generic_expr_loc): Likewise.
+       (dump_generic_expr): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_gimple_stmt_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_gimple_stmt): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_gimple_expr_loc): Likewise; convert 2nd param from
+       const dump_location_t & to const dump_user_location_t &.
+       (dump_gimple_expr): Convert 1st param from dump_flags_t to
+       const dump_metadata_t &.
+       (dump_symtab_node): Likewise.
+       (dump_dec): Likewise.
+       (dump_begin_scope): Split out 2nd param into user and impl
+       locations.
+       (auto_dump_scope::auto_dump_scope): Split "loc" param into a user
+       location and impl_location, and capture the impl_location.
+       (AUTO_DUMP_SCOPE): Rename param from LOC to USER_LOC.
+       * loop-unroll.c (report_unroll): Update for changes to
+       dump_printf_loc and dump_printf.
+       * opt-problem.cc (opt_problem::opt_problem): Update for change to
+       dump_loc.
+       * optinfo-emit-json.cc
+       (selftest::test_building_json_from_dump_calls): Convert "loc" from
+       dump_location_t to dump_user_location_t.
+       * optinfo.cc (optinfo::emit_for_opt_problem): Update for change in
+       dump_loc_immediate.
+       * profile.c (compute_branch_probabilities): Update for change to
+       dump_printf_loc.
+       * selftest.h (ASSERT_STR_CONTAINS_AT): New macro.
+       * tree-vect-slp.c (vect_print_slp_tree): Update for change to
+       dump_printf_loc.
+
 2018-11-27  Jozef Lawrynowicz  <jozef.l@mittosystems.com>
 
        * doc/sourcebuild.texi: Document check_effective_target_int_eq_float

diff --git a/gcc/dump-context.h b/gcc/dump-context.h
index 2016ce700d280ab1ae53cae667dfd592a74c7635..26bed1e577b443b3a6e4dbb272236d690754937c 100644 (file)
--- a/gcc/dump-context.h
+++ b/gcc/dump-context.h
@@ -50,51 +50,57 @@ class dump_context
 
   void refresh_dumps_are_enabled ();
 
-  void dump_loc (dump_flags_t dump_kind, const dump_location_t &loc);
-  void dump_loc_immediate (dump_flags_t dump_kind, const dump_location_t &loc);
+  void dump_loc (const dump_metadata_t &metadata,
+                const dump_user_location_t &loc);
+  void dump_loc_immediate (dump_flags_t dump_kind,
+                          const dump_user_location_t &loc);
 
-  void dump_gimple_stmt (dump_flags_t dump_kind, dump_flags_t extra_dump_flags,
+  void dump_gimple_stmt (const dump_metadata_t &metadata,
+                        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,
+  void dump_gimple_stmt_loc (const dump_metadata_t &metadata,
+                            const dump_user_location_t &loc,
                             dump_flags_t extra_dump_flags,
                             gimple *gs, int spc);
 
-  void dump_gimple_expr (dump_flags_t dump_kind,
+  void dump_gimple_expr (const dump_metadata_t &metadata,
                         dump_flags_t extra_dump_flags,
                         gimple *gs, int spc);
 
-  void dump_gimple_expr_loc (dump_flags_t dump_kind,
-                           const dump_location_t &loc,
-                           dump_flags_t extra_dump_flags,
-                           gimple *gs,
-                           int spc);
+  void dump_gimple_expr_loc (const dump_metadata_t &metadata,
+                            const dump_user_location_t &loc,
+                            dump_flags_t extra_dump_flags,
+                            gimple *gs,
+                            int spc);
 
-  void dump_generic_expr (dump_flags_t dump_kind,
+  void dump_generic_expr (const dump_metadata_t &metadata,
                          dump_flags_t extra_dump_flags,
                          tree t);
 
-  void dump_generic_expr_loc (dump_flags_t dump_kind,
-                             const dump_location_t &loc,
+  void dump_generic_expr_loc (const dump_metadata_t &metadata,
+                             const dump_user_location_t &loc,
                              dump_flags_t extra_dump_flags,
                              tree t);
 
-  void dump_printf_va (dump_flags_t dump_kind, const char *format,
+  void dump_printf_va (const dump_metadata_t &metadata, const char *format,
                       va_list *ap) ATTRIBUTE_GCC_DUMP_PRINTF (3, 0);
 
-  void dump_printf_loc_va (dump_flags_t dump_kind, const dump_location_t &loc,
+  void dump_printf_loc_va (const dump_metadata_t &metadata,
+                          const dump_user_location_t &loc,
                           const char *format, va_list *ap)
     ATTRIBUTE_GCC_DUMP_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_dec (const dump_metadata_t &metadata, const poly_int<N, C> &value);
 
-  void dump_symtab_node (dump_flags_t dump_kind, symtab_node *node);
+  void dump_symtab_node (const dump_metadata_t &metadata, symtab_node *node);
 
   /* Managing nested scopes.  */
   unsigned int get_scope_depth () const;
-  void begin_scope (const char *name, const dump_location_t &loc);
+  void begin_scope (const char *name,
+                   const dump_user_location_t &user_location,
+                   const dump_impl_location_t &impl_location);
   void end_scope ();
 
   /* Should optinfo instances be created?
@@ -117,8 +123,9 @@ class dump_context
   bool apply_dump_filter_p (dump_flags_t dump_kind, dump_flags_t filter) const;
 
  private:
-  optinfo &ensure_pending_optinfo ();
-  optinfo &begin_next_optinfo (const dump_location_t &loc);
+  optinfo &ensure_pending_optinfo (const dump_metadata_t &metadata);
+  optinfo &begin_next_optinfo (const dump_metadata_t &metadata,
+                              const dump_user_location_t &loc);
 
   /* The current nesting depth of dump scopes, for showing nesting
      via indentation).  */

diff --git a/gcc/dumpfile.c b/gcc/dumpfile.c
index e125650eed107f5e4bb2dc92771a65c027ed277f..5005f5e96b6cf660c9a5cfc7f6aa11d883a7da2e 100644 (file)
--- a/gcc/dumpfile.c
+++ b/gcc/dumpfile.c
@@ -580,24 +580,22 @@ dump_context::apply_dump_filter_p (dump_flags_t dump_kind,
    If optinfos are enabled, begin a new optinfo.  */
 
 void
-dump_context::dump_loc (dump_flags_t dump_kind, const dump_location_t &loc)
+dump_context::dump_loc (const dump_metadata_t &metadata,
+                       const dump_user_location_t &loc)
 {
   end_any_optinfo ();
 
-  dump_loc_immediate (dump_kind, loc);
+  dump_loc_immediate (metadata.get_dump_flags (), loc);
 
   if (optinfo_enabled_p ())
-    {
-      optinfo &info = begin_next_optinfo (loc);
-      info.handle_dump_file_kind (dump_kind);
-    }
+    begin_next_optinfo (metadata, loc);
 }
 
 /* As dump_loc above, but without starting a new optinfo. */
 
 void
 dump_context::dump_loc_immediate (dump_flags_t dump_kind,
-                                 const dump_location_t &loc)
+                                 const dump_user_location_t &loc)
 {
   location_t srcloc = loc.get_location_t ();
 
@@ -632,18 +630,17 @@ make_item_for_dump_gimple_stmt (gimple *stmt, int spc, dump_flags_t dump_flags)
    EXTRA_DUMP_FLAGS on the dump streams if DUMP_KIND is enabled.  */
 
 void
-dump_context::dump_gimple_stmt (dump_flags_t dump_kind,
+dump_context::dump_gimple_stmt (const dump_metadata_t &metadata,
                                dump_flags_t extra_dump_flags,
                                gimple *gs, int spc)
 {
   optinfo_item *item
     = make_item_for_dump_gimple_stmt (gs, spc, dump_flags | extra_dump_flags);
-  emit_item (item, dump_kind);
+  emit_item (item, metadata.get_dump_flags ());
 
   if (optinfo_enabled_p ())
     {
-      optinfo &info = ensure_pending_optinfo ();
-      info.handle_dump_file_kind (dump_kind);
+      optinfo &info = ensure_pending_optinfo (metadata);
       info.add_item (item);
     }
   else
@@ -653,13 +650,13 @@ dump_context::dump_gimple_stmt (dump_flags_t dump_kind,
 /* Similar to dump_gimple_stmt, except additionally print source location.  */
 
 void
-dump_context::dump_gimple_stmt_loc (dump_flags_t dump_kind,
-                                   const dump_location_t &loc,
+dump_context::dump_gimple_stmt_loc (const dump_metadata_t &metadata,
+                                   const dump_user_location_t &loc,
                                    dump_flags_t extra_dump_flags,
                                    gimple *gs, int spc)
 {
-  dump_loc (dump_kind, loc);
-  dump_gimple_stmt (dump_kind, extra_dump_flags, gs, spc);
+  dump_loc (metadata, loc);
+  dump_gimple_stmt (metadata, extra_dump_flags, gs, spc);
 }
 
 /* Make an item for the given dump call, equivalent to print_gimple_expr.  */
@@ -683,18 +680,17 @@ make_item_for_dump_gimple_expr (gimple *stmt, int spc, dump_flags_t dump_flags)
    Do not terminate with a newline or semicolon.  */
 
 void
-dump_context::dump_gimple_expr (dump_flags_t dump_kind,
+dump_context::dump_gimple_expr (const dump_metadata_t &metadata,
                                dump_flags_t extra_dump_flags,
                                gimple *gs, int spc)
 {
   optinfo_item *item
     = make_item_for_dump_gimple_expr (gs, spc, dump_flags | extra_dump_flags);
-  emit_item (item, dump_kind);
+  emit_item (item, metadata.get_dump_flags ());
 
   if (optinfo_enabled_p ())
     {
-      optinfo &info = ensure_pending_optinfo ();
-      info.handle_dump_file_kind (dump_kind);
+      optinfo &info = ensure_pending_optinfo (metadata);
       info.add_item (item);
     }
   else
@@ -704,14 +700,14 @@ dump_context::dump_gimple_expr (dump_flags_t dump_kind,
 /* Similar to dump_gimple_expr, except additionally print source location.  */
 
 void
-dump_context::dump_gimple_expr_loc (dump_flags_t dump_kind,
-                                   const dump_location_t &loc,
+dump_context::dump_gimple_expr_loc (const dump_metadata_t &metadata,
+                                   const dump_user_location_t &loc,
                                    dump_flags_t extra_dump_flags,
                                    gimple *gs,
                                    int spc)
 {
-  dump_loc (dump_kind, loc);
-  dump_gimple_expr (dump_kind, extra_dump_flags, gs, spc);
+  dump_loc (metadata, loc);
+  dump_gimple_expr (metadata, extra_dump_flags, gs, spc);
 }
 
 /* Make an item for the given dump call, equivalent to print_generic_expr.  */
@@ -738,18 +734,17 @@ make_item_for_dump_generic_expr (tree node, dump_flags_t dump_flags)
    DUMP_KIND is enabled.  */
 
 void
-dump_context::dump_generic_expr (dump_flags_t dump_kind,
+dump_context::dump_generic_expr (const dump_metadata_t &metadata,
                                 dump_flags_t extra_dump_flags,
                                 tree t)
 {
   optinfo_item *item
     = make_item_for_dump_generic_expr (t, dump_flags | extra_dump_flags);
-  emit_item (item, dump_kind);
+  emit_item (item, metadata.get_dump_flags ());
 
   if (optinfo_enabled_p ())
     {
-      optinfo &info = ensure_pending_optinfo ();
-      info.handle_dump_file_kind (dump_kind);
+      optinfo &info = ensure_pending_optinfo (metadata);
       info.add_item (item);
     }
   else
@@ -761,13 +756,13 @@ dump_context::dump_generic_expr (dump_flags_t dump_kind,
    location.  */
 
 void
-dump_context::dump_generic_expr_loc (dump_flags_t dump_kind,
-                                    const dump_location_t &loc,
+dump_context::dump_generic_expr_loc (const dump_metadata_t &metadata,
+                                    const dump_user_location_t &loc,
                                     dump_flags_t extra_dump_flags,
                                     tree t)
 {
-  dump_loc (dump_kind, loc);
-  dump_generic_expr (dump_kind, extra_dump_flags, t);
+  dump_loc (metadata, loc);
+  dump_generic_expr (metadata, extra_dump_flags, t);
 }
 
 /* Make an item for the given dump call.  */
@@ -987,10 +982,10 @@ dump_pretty_printer::decode_format (text_info *text, const char *spec,
 /* Output a formatted message using FORMAT on appropriate dump streams.  */
 
 void
-dump_context::dump_printf_va (dump_flags_t dump_kind, const char *format,
+dump_context::dump_printf_va (const dump_metadata_t &metadata, const char *format,
                              va_list *ap)
 {
-  dump_pretty_printer pp (this, dump_kind);
+  dump_pretty_printer pp (this, metadata.get_dump_flags ());
 
   text_info text;
   text.err_no = errno;
@@ -1003,8 +998,7 @@ dump_context::dump_printf_va (dump_flags_t dump_kind, const char *format,
   /* Phase 3.  */
   if (optinfo_enabled_p ())
     {
-      optinfo &info = ensure_pending_optinfo ();
-      info.handle_dump_file_kind (dump_kind);
+      optinfo &info = ensure_pending_optinfo (metadata);
       pp.emit_items (&info);
     }
   else
@@ -1015,12 +1009,12 @@ dump_context::dump_printf_va (dump_flags_t dump_kind, const char *format,
    dump location captured.  */
 
 void
-dump_context::dump_printf_loc_va (dump_flags_t dump_kind,
-                                 const dump_location_t &loc,
+dump_context::dump_printf_loc_va (const dump_metadata_t &metadata,
+                                 const dump_user_location_t &loc,
                                  const char *format, va_list *ap)
 {
-  dump_loc (dump_kind, loc);
-  dump_printf_va (dump_kind, format, ap);
+  dump_loc (metadata, loc);
+  dump_printf_va (metadata, format, ap);
 }
 
 /* Make an item for the given dump call, equivalent to print_dec.  */
@@ -1056,15 +1050,14 @@ make_item_for_dump_dec (const poly_int<N, C> &value)
 
 template<unsigned int N, typename C>
 void
-dump_context::dump_dec (dump_flags_t dump_kind, const poly_int<N, C> &value)
+dump_context::dump_dec (const dump_metadata_t &metadata, const poly_int<N, C> &value)
 {
   optinfo_item *item = make_item_for_dump_dec (value);
-  emit_item (item, dump_kind);
+  emit_item (item, metadata.get_dump_flags ());
 
   if (optinfo_enabled_p ())
     {
-      optinfo &info = ensure_pending_optinfo ();
-      info.handle_dump_file_kind (dump_kind);
+      optinfo &info = ensure_pending_optinfo (metadata);
       info.add_item (item);
     }
   else
@@ -1074,15 +1067,14 @@ dump_context::dump_dec (dump_flags_t dump_kind, const 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)
+dump_context::dump_symtab_node (const dump_metadata_t &metadata, symtab_node *node)
 {
   optinfo_item *item = make_item_for_dump_symtab_node (node);
-  emit_item (item, dump_kind);
+  emit_item (item, metadata.get_dump_flags ());
 
   if (optinfo_enabled_p ())
     {
-      optinfo &info = ensure_pending_optinfo ();
-      info.handle_dump_file_kind (dump_kind);
+      optinfo &info = ensure_pending_optinfo (metadata);
       info.add_item (item);
     }
   else
@@ -1105,19 +1097,23 @@ dump_context::get_scope_depth () const
    Emit a "scope" optinfo if optinfos are enabled.  */
 
 void
-dump_context::begin_scope (const char *name, const dump_location_t &loc)
+dump_context::begin_scope (const char *name,
+                          const dump_user_location_t &user_location,
+                          const dump_impl_location_t &impl_location)
 {
   m_scope_depth++;
 
+  location_t src_loc = user_location.get_location_t ();
+
   if (dump_file && apply_dump_filter_p (MSG_NOTE, pflags))
-    ::dump_loc (MSG_NOTE, dump_file, loc.get_location_t ());
+    ::dump_loc (MSG_NOTE, dump_file, src_loc);
 
   if (alt_dump_file && apply_dump_filter_p (MSG_NOTE, alt_flags))
-    ::dump_loc (MSG_NOTE, alt_dump_file, loc.get_location_t ());
+    ::dump_loc (MSG_NOTE, alt_dump_file, src_loc);
 
   /* Support for temp_dump_context in selftests.  */
   if (m_test_pp && apply_dump_filter_p (MSG_NOTE, m_test_pp_flags))
-    ::dump_loc (MSG_NOTE, m_test_pp, loc.get_location_t ());
+    ::dump_loc (MSG_NOTE, m_test_pp, src_loc);
 
   pretty_printer pp;
   pp_printf (&pp, "=== %s ===\n", name);
@@ -1128,7 +1124,9 @@ dump_context::begin_scope (const char *name, const dump_location_t &loc)
 
   if (optinfo_enabled_p ())
     {
-      optinfo &info = begin_next_optinfo (loc);
+      optinfo &info
+       = begin_next_optinfo (dump_metadata_t (MSG_NOTE, impl_location),
+                             user_location);
       info.m_kind = OPTINFO_KIND_SCOPE;
       info.add_item (item);
       end_any_optinfo ();
@@ -1163,10 +1161,10 @@ dump_context::optinfo_enabled_p () const
    necessary.  */
 
 optinfo &
-dump_context::ensure_pending_optinfo ()
+dump_context::ensure_pending_optinfo (const dump_metadata_t &metadata)
 {
   if (!m_pending)
-    return begin_next_optinfo (dump_location_t (dump_user_location_t ()));
+    return begin_next_optinfo (metadata, dump_user_location_t ());
   return *m_pending;
 }
 
@@ -1174,11 +1172,14 @@ dump_context::ensure_pending_optinfo ()
    accumulated.  */
 
 optinfo &
-dump_context::begin_next_optinfo (const dump_location_t &loc)
+dump_context::begin_next_optinfo (const dump_metadata_t &metadata,
+                                 const dump_user_location_t &user_loc)
 {
   end_any_optinfo ();
   gcc_assert (m_pending == NULL);
+  dump_location_t loc (user_loc, metadata.get_impl_location ());
   m_pending = new optinfo (loc, OPTINFO_KIND_NOTE, current_pass);
+  m_pending->handle_dump_file_kind (metadata.get_dump_flags ());
   return *m_pending;
 }
 
@@ -1248,21 +1249,22 @@ dump_context dump_context::s_default;
    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,
+dump_gimple_stmt (const dump_metadata_t &metadata, dump_flags_t extra_dump_flags,
                  gimple *gs, int spc)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_gimple_stmt (dump_kind, extra_dump_flags, gs, spc);
+  dump_context::get ().dump_gimple_stmt (metadata, 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_gimple_stmt_loc (const dump_metadata_t &metadata,
+                     const dump_user_location_t &loc,
                      dump_flags_t extra_dump_flags, gimple *gs, int spc)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_gimple_stmt_loc (dump_kind, loc, extra_dump_flags,
+  dump_context::get ().dump_gimple_stmt_loc (metadata, loc, extra_dump_flags,
                                             gs, spc);
 }
 
@@ -1271,21 +1273,23 @@ dump_gimple_stmt_loc (dump_flags_t dump_kind, const dump_location_t &loc,
    Do not terminate with a newline or semicolon.  */
 
 void
-dump_gimple_expr (dump_flags_t dump_kind, dump_flags_t extra_dump_flags,
+dump_gimple_expr (const dump_metadata_t &metadata,
+                 dump_flags_t extra_dump_flags,
                  gimple *gs, int spc)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_gimple_expr (dump_kind, extra_dump_flags, gs, spc);
+  dump_context::get ().dump_gimple_expr (metadata, extra_dump_flags, gs, spc);
 }
 
 /* Similar to dump_gimple_expr, except additionally print source location.  */
 
 void
-dump_gimple_expr_loc (dump_flags_t dump_kind, const dump_location_t &loc,
+dump_gimple_expr_loc (const dump_metadata_t &metadata,
+                     const dump_user_location_t &loc,
                      dump_flags_t extra_dump_flags, gimple *gs, int spc)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_gimple_expr_loc (dump_kind, loc, extra_dump_flags,
+  dump_context::get ().dump_gimple_expr_loc (metadata, loc, extra_dump_flags,
                                             gs, spc);
 }
 
@@ -1293,34 +1297,35 @@ dump_gimple_expr_loc (dump_flags_t dump_kind, const dump_location_t &loc,
    DUMP_KIND is enabled.  */
 
 void
-dump_generic_expr (dump_flags_t dump_kind, dump_flags_t extra_dump_flags,
+dump_generic_expr (const dump_metadata_t &metadata, dump_flags_t extra_dump_flags,
                   tree t)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_generic_expr (dump_kind, extra_dump_flags, t);
+  dump_context::get ().dump_generic_expr (metadata, 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_generic_expr_loc (const dump_metadata_t &metadata,
+                      const dump_user_location_t &loc,
                       dump_flags_t extra_dump_flags, tree t)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_generic_expr_loc (dump_kind, loc, extra_dump_flags,
+  dump_context::get ().dump_generic_expr_loc (metadata, 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, ...)
+dump_printf (const dump_metadata_t &metadata, const char *format, ...)
 {
   VERIFY_DUMP_ENABLED_P;
   va_list ap;
   va_start (ap, format);
-  dump_context::get ().dump_printf_va (dump_kind, format, &ap);
+  dump_context::get ().dump_printf_va (metadata, format, &ap);
   va_end (ap);
 }
 
@@ -1328,13 +1333,14 @@ dump_printf (dump_flags_t dump_kind, const char *format, ...)
    dump location captured.  */
 
 void
-dump_printf_loc (dump_flags_t dump_kind, const dump_location_t &loc,
+dump_printf_loc (const dump_metadata_t &metadata,
+                const dump_user_location_t &loc,
                 const char *format, ...)
 {
   VERIFY_DUMP_ENABLED_P;
   va_list ap;
   va_start (ap, format);
-  dump_context::get ().dump_printf_loc_va (dump_kind, loc, format, &ap);
+  dump_context::get ().dump_printf_loc_va (metadata, loc, format, &ap);
   va_end (ap);
 }
 
@@ -1342,17 +1348,17 @@ 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_dec (const dump_metadata_t &metadata, const poly_int<N, C> &value)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_dec (dump_kind, value);
+  dump_context::get ().dump_dec (metadata, value);
 }
 
-template void dump_dec (dump_flags_t, const poly_uint16 &);
-template void dump_dec (dump_flags_t, const poly_int64 &);
-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 &);
+template void dump_dec (const dump_metadata_t &metadata, const poly_uint16 &);
+template void dump_dec (const dump_metadata_t &metadata, const poly_int64 &);
+template void dump_dec (const dump_metadata_t &metadata, const poly_uint64 &);
+template void dump_dec (const dump_metadata_t &metadata, const poly_offset_int &);
+template void dump_dec (const dump_metadata_t &metadata, const poly_widest_int &);
 
 void
 dump_dec (dump_flags_t dump_kind, const poly_wide_int &value, signop sgn)
@@ -1394,10 +1400,10 @@ dumpfile_ensure_any_optinfo_are_flushed ()
 /* Output the name of NODE on appropriate dump streams.  */
 
 void
-dump_symtab_node (dump_flags_t dump_kind, symtab_node *node)
+dump_symtab_node (const dump_metadata_t &metadata, symtab_node *node)
 {
   VERIFY_DUMP_ENABLED_P;
-  dump_context::get ().dump_symtab_node (dump_kind, node);
+  dump_context::get ().dump_symtab_node (metadata, node);
 }
 
 /* Get the current dump scope-nesting depth.
@@ -1416,9 +1422,11 @@ get_dump_scope_depth ()
    Increment the scope depth.  */
 
 void
-dump_begin_scope (const char *name, const dump_location_t &loc)
+dump_begin_scope (const char *name,
+                 const dump_user_location_t &user_location,
+                 const dump_impl_location_t &impl_location)
 {
-  dump_context::get ().begin_scope (name, loc);
+  dump_context::get ().begin_scope (name, user_location, impl_location);
 }
 
 /* Pop a nested dump scope.  */
@@ -2083,6 +2091,36 @@ temp_dump_context::get_dumped_text ()
   return pp_formatted_text (&m_pp);
 }
 
+/* Verify that IMPL_LOC is within EXPECTED_FILE at EXPECTED_LINE,
+   from EXPECTED_FUNCTION, using LOC for the location of any failure,
+   provided that the build compiler is sufficiently recent.  */
+
+static void
+assert_impl_location_eq (const location &loc ATTRIBUTE_UNUSED,
+                        const dump_impl_location_t &impl_loc ATTRIBUTE_UNUSED,
+                        const char *expected_file ATTRIBUTE_UNUSED,
+                        int expected_line ATTRIBUTE_UNUSED,
+                        const char *expected_function ATTRIBUTE_UNUSED)
+{
+#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
+  ASSERT_STR_CONTAINS_AT (loc, impl_loc.m_file, expected_file);
+  ASSERT_EQ_AT (loc, impl_loc.m_line, expected_line);
+  ASSERT_STR_CONTAINS_AT (loc, impl_loc.m_function, expected_function);
+#endif
+}
+
+/* Verify that IMPL_LOC is within EXPECTED_FILE at EXPECTED_LINE,
+   from EXPECTED_FUNCTION, provided that the build compiler is
+   sufficiently recent.  */
+
+#define ASSERT_IMPL_LOCATION_EQ(IMPL_LOC, EXPECTED_FILE, EXPECTED_LINE, \
+                               EXPECTED_FUNCTION)                      \
+  SELFTEST_BEGIN_STMT                                                  \
+    assert_impl_location_eq (SELFTEST_LOCATION, IMPL_LOC,              \
+                            EXPECTED_FILE, EXPECTED_LINE,              \
+                            EXPECTED_FUNCTION);                        \
+  SELFTEST_END_STMT
+
 /* Verify that the dump_location_t constructors capture the source location
    at which they were called (provided that the build compiler is sufficiently
    recent).  */
@@ -2090,31 +2128,29 @@ temp_dump_context::get_dumped_text ()
 static void
 test_impl_location ()
 {
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
   /* Default ctor.  */
   {
     dump_location_t loc;
     const int expected_line = __LINE__ - 1;
-    ASSERT_STR_CONTAINS (loc.get_impl_location ().m_file, "dumpfile.c");
-    ASSERT_EQ (loc.get_impl_location ().m_line, expected_line);
+    ASSERT_IMPL_LOCATION_EQ (loc.get_impl_location (),
+                            "dumpfile.c", expected_line, "test_impl_location");
   }
 
   /* Constructing from a gimple.  */
   {
     dump_location_t loc ((gimple *)NULL);
     const int expected_line = __LINE__ - 1;
-    ASSERT_STR_CONTAINS (loc.get_impl_location ().m_file, "dumpfile.c");
-    ASSERT_EQ (loc.get_impl_location ().m_line, expected_line);
+    ASSERT_IMPL_LOCATION_EQ (loc.get_impl_location (),
+                            "dumpfile.c", expected_line, "test_impl_location");
   }
 
   /* Constructing from an rtx_insn.  */
   {
     dump_location_t loc ((rtx_insn *)NULL);
     const int expected_line = __LINE__ - 1;
-    ASSERT_STR_CONTAINS (loc.get_impl_location ().m_file, "dumpfile.c");
-    ASSERT_EQ (loc.get_impl_location ().m_line, expected_line);
+    ASSERT_IMPL_LOCATION_EQ (loc.get_impl_location (),
+                            "dumpfile.c", expected_line, "test_impl_location");
   }
-#endif
 }
 
 /* Verify that the text dumped so far in CONTEXT equals
@@ -2161,7 +2197,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
   if (stmt_loc > LINE_MAP_MAX_LOCATION_WITH_COLS)
     return;
 
-  dump_location_t loc = dump_location_t::from_location_t (stmt_loc);
+  dump_user_location_t loc = dump_user_location_t::from_location_t (stmt_loc);
 
   gimple *stmt = gimple_build_return (NULL);
   gimple_set_location (stmt, stmt_loc);
@@ -2188,6 +2224,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_printf (MSG_NOTE, "int: %i str: %s", 42, "foo");
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "int: 42 str: foo");
        if (with_optinfo)
@@ -2197,6 +2234,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->get_kind (), OPTINFO_KIND_NOTE);
            ASSERT_EQ (info->num_items (), 1);
            ASSERT_IS_TEXT (info->get_item (0), "int: 42 str: foo");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2205,6 +2245,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_printf (MSG_NOTE, "tree: %T", integer_zero_node);
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "tree: 0");
        if (with_optinfo)
@@ -2215,6 +2256,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->num_items (), 2);
            ASSERT_IS_TEXT (info->get_item (0), "tree: ");
            ASSERT_IS_TREE (info->get_item (1), UNKNOWN_LOCATION, "0");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2223,6 +2267,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_printf (MSG_NOTE, "gimple: %E", stmt);
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "gimple: return;");
        if (with_optinfo)
@@ -2233,6 +2278,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->num_items (), 2);
            ASSERT_IS_TEXT (info->get_item (0), "gimple: ");
            ASSERT_IS_GIMPLE (info->get_item (1), stmt_loc, "return;");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2241,6 +2289,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_printf (MSG_NOTE, "gimple: %G", stmt);
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "gimple: return;\n");
        if (with_optinfo)
@@ -2251,6 +2300,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->num_items (), 2);
            ASSERT_IS_TEXT (info->get_item (0), "gimple: ");
            ASSERT_IS_GIMPLE (info->get_item (1), stmt_loc, "return;\n");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2259,6 +2311,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_printf (MSG_NOTE, "node: %C", node);
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "node: test_decl/0");
        if (with_optinfo)
@@ -2269,6 +2322,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->num_items (), 2);
            ASSERT_IS_TEXT (info->get_item (0), "node: ");
            ASSERT_IS_SYMTAB_NODE (info->get_item (1), decl_loc, "test_decl/0");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2302,6 +2358,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_IS_GIMPLE (info->get_item (5), stmt_loc, "return;");
            ASSERT_IS_GIMPLE (info->get_item (6), stmt_loc, "return;");
            ASSERT_IS_TEXT (info->get_item (7), " after\n");
+           /* We don't ASSERT_IMPL_LOCATION_EQ here, to avoid having to
+              enforce at which exact line the multiline dump_printf_loc
+              occurred.  */
          }
       }
 
@@ -2310,6 +2369,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_printf_loc (MSG_NOTE, loc, "test of tree: ");
+       const int expected_impl_line = __LINE__ - 1;
        dump_generic_expr (MSG_NOTE, TDF_SLIM, integer_zero_node);
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "test.txt:5:10: note: test of tree: 0");
@@ -2322,6 +2382,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->num_items (), 2);
            ASSERT_IS_TEXT (info->get_item (0), "test of tree: ");
            ASSERT_IS_TREE (info->get_item (1), UNKNOWN_LOCATION, "0");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2330,6 +2393,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_generic_expr_loc (MSG_NOTE, loc, TDF_SLIM, integer_one_node);
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "test.txt:5:10: note: 1");
        if (with_optinfo)
@@ -2340,6 +2404,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->get_kind (), OPTINFO_KIND_NOTE);
            ASSERT_EQ (info->num_items (), 1);
            ASSERT_IS_TREE (info->get_item (0), UNKNOWN_LOCATION, "1");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2350,6 +2417,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
          temp_dump_context tmp (with_optinfo, true,
                                 MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
          dump_gimple_stmt_loc (MSG_NOTE, loc, TDF_SLIM, stmt, 2);
+         const int expected_impl_line = __LINE__ - 1;
 
          ASSERT_DUMPED_TEXT_EQ (tmp, "test.txt:5:10: note: return;\n");
          if (with_optinfo)
@@ -2358,6 +2426,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
              ASSERT_TRUE (info != NULL);
              ASSERT_EQ (info->num_items (), 1);
              ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;\n");
+             ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                      "dumpfile.c", expected_impl_line,
+                                      "test_capture_of_dump_calls");
            }
        }
 
@@ -2366,6 +2437,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
          temp_dump_context tmp (with_optinfo, true,
                                 MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
          dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 2);
+         const int expected_impl_line = __LINE__ - 1;
 
          ASSERT_DUMPED_TEXT_EQ (tmp, "return;\n");
          if (with_optinfo)
@@ -2374,6 +2446,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
              ASSERT_TRUE (info != NULL);
              ASSERT_EQ (info->num_items (), 1);
              ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;\n");
+             ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                      "dumpfile.c", expected_impl_line,
+                                      "test_capture_of_dump_calls");
            }
        }
 
@@ -2382,6 +2457,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
          temp_dump_context tmp (with_optinfo, true,
                                 MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
          dump_gimple_expr_loc (MSG_NOTE, loc, TDF_SLIM, stmt, 2);
+         const int expected_impl_line = __LINE__ - 1;
 
          ASSERT_DUMPED_TEXT_EQ (tmp, "test.txt:5:10: note: return;");
          if (with_optinfo)
@@ -2390,6 +2466,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
              ASSERT_TRUE (info != NULL);
              ASSERT_EQ (info->num_items (), 1);
              ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;");
+             ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                      "dumpfile.c", expected_impl_line,
+                                      "test_capture_of_dump_calls");
            }
        }
 
@@ -2398,6 +2477,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
          temp_dump_context tmp (with_optinfo, true,
                                 MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
          dump_gimple_expr (MSG_NOTE, TDF_SLIM, stmt, 2);
+         const int expected_impl_line = __LINE__ - 1;
 
          ASSERT_DUMPED_TEXT_EQ (tmp, "return;");
          if (with_optinfo)
@@ -2406,6 +2486,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
              ASSERT_TRUE (info != NULL);
              ASSERT_EQ (info->num_items (), 1);
              ASSERT_IS_GIMPLE (info->get_item (0), stmt_loc, "return;");
+             ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                      "dumpfile.c", expected_impl_line,
+                                      "test_capture_of_dump_calls");
            }
        }
       }
@@ -2415,6 +2498,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_symtab_node (MSG_NOTE, node);
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "test_decl/0");
        if (with_optinfo)
@@ -2424,6 +2508,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_EQ (info->get_kind (), OPTINFO_KIND_NOTE);
            ASSERT_EQ (info->num_items (), 1);
            ASSERT_IS_SYMTAB_NODE (info->get_item (0), decl_loc, "test_decl/0");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2432,6 +2519,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
        temp_dump_context tmp (with_optinfo, true,
                               MSG_ALL_KINDS | MSG_PRIORITY_USER_FACING);
        dump_dec (MSG_NOTE, poly_int64 (42));
+       const int expected_impl_line = __LINE__ - 1;
 
        ASSERT_DUMPED_TEXT_EQ (tmp, "42");
        if (with_optinfo)
@@ -2440,6 +2528,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
            ASSERT_TRUE (info != NULL);
            ASSERT_EQ (info->num_items (), 1);
            ASSERT_IS_TEXT (info->get_item (0), "42");
+           ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                    "dumpfile.c", expected_impl_line,
+                                    "test_capture_of_dump_calls");
          }
       }
 
@@ -2476,6 +2567,7 @@ test_capture_of_dump_calls (const line_table_case &case_)
            dump_printf_loc (MSG_NOTE, stmt, "msg 6\n");
          }
          dump_printf_loc (MSG_NOTE, stmt, "msg 7\n");
+         const int expected_impl_line = __LINE__ - 1;
 
          switch (dump_filter & MSG_ALL_PRIORITIES)
            {
@@ -2527,6 +2619,9 @@ test_capture_of_dump_calls (const line_table_case &case_)
              ASSERT_TRUE (info != NULL);
              ASSERT_EQ (info->num_items (), 1);
              ASSERT_IS_TEXT (info->get_item (0), "msg 7\n");
+             ASSERT_IMPL_LOCATION_EQ (info->get_impl_location (),
+                                      "dumpfile.c", expected_impl_line,
+                                      "test_capture_of_dump_calls");
            }
        }
     }

diff --git a/gcc/dumpfile.h b/gcc/dumpfile.h
index c82157d295c2f088893ca8cc033d877351b4f337..d51e4ceaf114ab5f6f253ef9ea39385de421f066 100644 (file)
--- a/gcc/dumpfile.h
+++ b/gcc/dumpfile.h
@@ -385,6 +385,38 @@ struct dump_impl_location_t
   const char *m_function;
 };
 
+/* A bundle of metadata for describing a dump message:
+   (a) the dump_flags
+   (b) the source location within the compiler/plugin.
+
+   The constructors use default parameters so that (b) gets sets up
+   automatically.
+
+   Hence you can pass in e.g. MSG_NOTE, and the dump call
+   will automatically record where in GCC's source code the
+   dump was emitted from.  */
+
+class dump_metadata_t
+{
+ public:
+  dump_metadata_t (dump_flags_t dump_flags,
+                  const dump_impl_location_t &impl_location
+                    = dump_impl_location_t ())
+  : m_dump_flags (dump_flags),
+    m_impl_location (impl_location)
+  {
+  }
+
+  dump_flags_t get_dump_flags () const { return m_dump_flags; }
+
+  const dump_impl_location_t &
+  get_impl_location () const { return m_impl_location; }
+
+ private:
+  dump_flags_t m_dump_flags;
+  dump_impl_location_t m_impl_location;
+};
+
 /* A bundle of information for describing the location of a dump message:
    (a) the source location and hotness within the user's code, together with
    (b) the source location within the compiler/plugin.
@@ -521,27 +553,30 @@ dump_enabled_p (void)
    to minimize the work done for the common case where dumps
    are disabled.  */
 
-extern void dump_printf (dump_flags_t, const char *, ...)
+extern void dump_printf (const dump_metadata_t &, const char *, ...)
   ATTRIBUTE_GCC_DUMP_PRINTF (2, 3);
 
-extern void dump_printf_loc (dump_flags_t, const dump_location_t &,
+extern void dump_printf_loc (const dump_metadata_t &, const dump_user_location_t &,
                             const char *, ...)
   ATTRIBUTE_GCC_DUMP_PRINTF (3, 0);
 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 &,
+extern void dump_generic_expr_loc (const dump_metadata_t &,
+                                  const dump_user_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 &,
+extern void dump_generic_expr (const dump_metadata_t &, dump_flags_t, tree);
+extern void dump_gimple_stmt_loc (const dump_metadata_t &,
+                                 const dump_user_location_t &,
                                  dump_flags_t, gimple *, int);
-extern void dump_gimple_stmt (dump_flags_t, dump_flags_t, gimple *, int);
-extern void dump_gimple_expr_loc (dump_flags_t, const dump_location_t &,
+extern void dump_gimple_stmt (const dump_metadata_t &, dump_flags_t, gimple *, int);
+extern void dump_gimple_expr_loc (const dump_metadata_t &,
+                                 const dump_user_location_t &,
                                  dump_flags_t, gimple *, int);
-extern void dump_gimple_expr (dump_flags_t, dump_flags_t, gimple *, int);
-extern void dump_symtab_node (dump_flags_t, symtab_node *);
+extern void dump_gimple_expr (const dump_metadata_t &, dump_flags_t, gimple *, int);
+extern void dump_symtab_node (const dump_metadata_t &, symtab_node *);
 
 template<unsigned int N, typename C>
-void dump_dec (dump_flags_t, const poly_int<N, C> &);
+void dump_dec (const dump_metadata_t &, const poly_int<N, C> &);
 extern void dump_dec (dump_flags_t, const poly_wide_int &, signop);
 extern void dump_hex (dump_flags_t, const poly_wide_int &);
 
@@ -551,7 +586,9 @@ extern void dumpfile_ensure_any_optinfo_are_flushed ();
    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_begin_scope (const char *name,
+                             const dump_user_location_t &user_location,
+                             const dump_impl_location_t &impl_location);
 extern void dump_end_scope ();
 
 /* Implementation detail of the AUTO_DUMP_SCOPE macro below.
@@ -563,10 +600,13 @@ extern void dump_end_scope ();
 class auto_dump_scope
 {
  public:
-  auto_dump_scope (const char *name, dump_location_t loc)
+  auto_dump_scope (const char *name,
+                  const dump_user_location_t &user_location,
+                  const dump_impl_location_t &impl_location
+                  = dump_impl_location_t ())
   {
     if (dump_enabled_p ())
-      dump_begin_scope (name, loc);
+      dump_begin_scope (name, user_location, impl_location);
   }
   ~auto_dump_scope ()
   {
@@ -576,7 +616,7 @@ class auto_dump_scope
 };
 
 /* A macro for calling:
-     dump_begin_scope (NAME, LOC);
+     dump_begin_scope (NAME, USER_LOC);
    via an RAII object, thus printing "=== MSG ===\n" to the dumpfile etc,
    and then calling
      dump_end_scope ();
@@ -587,8 +627,8 @@ class auto_dump_scope
    top level implicitly default to MSG_PRIORITY_USER_FACING, whereas those
    in a nested scope implicitly default to MSG_PRIORITY_INTERNALS.  */
 
-#define AUTO_DUMP_SCOPE(NAME, LOC) \
-  auto_dump_scope scope (NAME, LOC)
+#define AUTO_DUMP_SCOPE(NAME, USER_LOC) \
+  auto_dump_scope scope (NAME, USER_LOC)
 
 extern void dump_function (int phase, tree fn);
 extern void print_combine_total_stats (void);

diff --git a/gcc/loop-unroll.c b/gcc/loop-unroll.c
index 48bbda0dd77bc15f5fb640cad04d2f28662a5e5f..5b37052b5485ed10efc63deb91c2df6ad7ab8015 100644 (file)
--- a/gcc/loop-unroll.c
+++ b/gcc/loop-unroll.c
@@ -199,15 +199,16 @@ report_unroll (struct loop *loop, dump_location_t locus)
   if (!dump_enabled_p ())
     return;
 
-  dump_printf_loc (report_flags, locus,
+  dump_metadata_t metadata (report_flags, locus.get_impl_location ());
+  dump_printf_loc (metadata, locus.get_user_location (),
                    "loop unrolled %d times",
                    loop->lpt_decision.times);
   if (profile_info && loop->header->count.initialized_p ())
-    dump_printf (report_flags,
+    dump_printf (metadata,
                  " (header execution count %d)",
                  (int)loop->header->count.to_gcov_type ());
 
-  dump_printf (report_flags, "\n");
+  dump_printf (metadata, "\n");
 }
 
 /* Decide whether unroll loops and how much.  */

diff --git a/gcc/opt-problem.cc b/gcc/opt-problem.cc
index dad3a8c008b3f7dc2fa3365193e272695bc6b60d..c781ee33237ff513b7efbdfd2d288b2412f5c8ab 100644 (file)
--- a/gcc/opt-problem.cc
+++ b/gcc/opt-problem.cc
@@ -54,7 +54,7 @@ opt_problem::opt_problem (const dump_location_t &loc,
 
   /* Print the location to the "immediate" dump destinations.  */
   dump_context &dc = dump_context::get ();
-  dc.dump_loc (MSG_MISSED_OPTIMIZATION, loc);
+  dc.dump_loc (MSG_MISSED_OPTIMIZATION, loc.get_user_location ());
 
   /* Print the formatted string to this opt_problem's optinfo, dumping
      the items to the "immediate" dump destinations, and storing items

diff --git a/gcc/optinfo-emit-json.cc b/gcc/optinfo-emit-json.cc
index 841a13b4f3bae15d67be545aad8ee3d24d9dde1f..f28a0e3cb5b7f3f57f4f09fb39ab3df98228d8df 100644 (file)
--- a/gcc/optinfo-emit-json.cc
+++ b/gcc/optinfo-emit-json.cc
@@ -453,7 +453,7 @@ static void
 test_building_json_from_dump_calls ()
 {
   temp_dump_context tmp (true, true, MSG_NOTE);
-  dump_location_t loc;
+  dump_user_location_t loc;
   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 ();

diff --git a/gcc/optinfo.cc b/gcc/optinfo.cc
index f76da45fb988ad50ff200e9a65bd565b9620530c..314fcbf3e226846dec6bdde0d9d954d0c694793c 100644 (file)
--- a/gcc/optinfo.cc
+++ b/gcc/optinfo.cc
@@ -118,7 +118,7 @@ optinfo::emit_for_opt_problem () const
   dump_kind |= MSG_PRIORITY_REEMITTED;
 
   /* Re-emit to "immediate" destinations, without creating a new optinfo.  */
-  dump_context::get ().dump_loc_immediate (dump_kind, get_dump_location ());
+  dump_context::get ().dump_loc_immediate (dump_kind, get_user_location ());
   unsigned i;
   optinfo_item *item;
   FOR_EACH_VEC_ELT (m_items, i, item)

diff --git a/gcc/profile.c b/gcc/profile.c
index 2130319b081644698eab5b45cc85dd2b560429e0..be6d3b8af7e105c41e7758f8cb5ee53e695728a8 100644 (file)
--- a/gcc/profile.c
+++ b/gcc/profile.c
@@ -577,7 +577,7 @@ compute_branch_probabilities (unsigned cfg_checksum, unsigned lineno_checksum)
            {
              informed = 1;
              dump_printf_loc (MSG_NOTE,
-                             dump_location_t::from_location_t (input_location),
+                             dump_user_location_t::from_location_t (input_location),
                               "correcting inconsistent profile data\n");
            }
          correct_negative_edge_counts ();

diff --git a/gcc/selftest.h b/gcc/selftest.h
index 29ade6baf77e7da3b040efd394514130f30cf5a4..2d7cc3b55e3f79b7c2c6039ece46766e6e533ce5 100644 (file)
--- a/gcc/selftest.h
+++ b/gcc/selftest.h
@@ -436,6 +436,15 @@ extern int num_passes;
                                   (HAYSTACK), (NEEDLE));               \
   SELFTEST_END_STMT
 
+/* Like ASSERT_STR_CONTAINS, but treat LOC as the effective location of the
+   selftest.  */
+
+#define ASSERT_STR_CONTAINS_AT(LOC, HAYSTACK, NEEDLE)                  \
+  SELFTEST_BEGIN_STMT                                                  \
+  ::selftest::assert_str_contains (LOC, #HAYSTACK, #NEEDLE,            \
+                                  (HAYSTACK), (NEEDLE));               \
+  SELFTEST_END_STMT
+
 /* Evaluate STR and PREFIX and determine if STR starts with PREFIX.
      ::selftest::pass if STR does start with PREFIX.
      ::selftest::fail if does not, or either is NULL.  */

diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c
index 4267cc9a92afc48d0a633dd2d8b82456bf3d271d..40c4584d6258f28c294ff18da6715772a0866c4a 100644 (file)
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -1457,14 +1457,16 @@ vect_print_slp_tree (dump_flags_t dump_kind, dump_location_t loc,
   if (visited.add (node))
     return;
 
-  dump_printf_loc (dump_kind, loc, "node%s %p\n",
+  dump_metadata_t metadata (dump_kind, loc.get_impl_location ());
+  dump_user_location_t user_loc = loc.get_user_location ();
+  dump_printf_loc (metadata, user_loc, "node%s %p\n",
                   SLP_TREE_DEF_TYPE (node) != vect_internal_def
                   ? " (external)" : "", node);
   FOR_EACH_VEC_ELT (SLP_TREE_SCALAR_STMTS (node), i, stmt_info)
-    dump_printf_loc (dump_kind, loc, "\tstmt %d %G", i, stmt_info->stmt);
+    dump_printf_loc (metadata, user_loc, "\tstmt %d %G", i, stmt_info->stmt);
   if (SLP_TREE_CHILDREN (node).is_empty ())
     return;
-  dump_printf_loc (dump_kind, loc, "\tchildren");
+  dump_printf_loc (metadata, user_loc, "\tchildren");
   FOR_EACH_VEC_ELT (SLP_TREE_CHILDREN (node), i, child)
     dump_printf (dump_kind, " %p", (void *)child);
   dump_printf (dump_kind, "\n");