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
manually verified that the references to dumpfile.c in the saved
optimization records were fixed.
Successfully bootstrapped & regrtested on x86_64-pc-linux-gnu.
OK for trunk?
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.
---
gcc/dump-context.h | 49 +++++----
gcc/dumpfile.c | 277 +++++++++++++++++++++++++++++++----------------
gcc/dumpfile.h | 72 +++++++++---
gcc/loop-unroll.c | 7 +-
gcc/opt-problem.cc | 2 +-
gcc/optinfo-emit-json.cc | 2 +-
gcc/optinfo.cc | 2 +-
gcc/profile.c | 2 +-
gcc/selftest.h | 9 ++
gcc/tree-vect-slp.c | 8 +-
10 files changed, 292 insertions(+), 138 deletions(-)
diff --git a/gcc/dump-context.h b/gcc/dump-context.h
index 2016ce7..26bed1e 100644
--- 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 e125650..5005f5e 100644
--- 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 c82157d..d51e4ce 100644
--- 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 48bbda0..5b37052 100644
--- 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 dad3a8c..c781ee3 100644
--- 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 841a13b..f28a0e3 100644
--- 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 f76da45..314fcbf 100644
--- 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 2130319..be6d3b8 100644
--- 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 29ade6b..2d7cc3b55 100644
--- 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 f2bb8da..c5bf39c 100644
--- 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");
--
1.8.5.3
