aboutsummaryrefslogtreecommitdiff
path: root/gcc/tree-vect-loop.c
diff options
context:
space:
mode:
authorSharad Singhai <singhai@google.com>2012-10-01 05:43:06 +0000
committerSharad Singhai <singhai@google.com>2012-10-01 05:43:06 +0000
commit65b0a81dfa834f3f2d1fc225ca673dc2aeeadf04 (patch)
tree525ba5cb84f1f7d04874c56225d38fe09fea8455 /gcc/tree-vect-loop.c
parentaec4819c0eda79d5fc88b1466682bd680f4eb8e8 (diff)
2012-09-30 Sharad Singhai <singhai@google.com>
* doc/invoke.texi: Add documentation for the new option. * tree-dump.c: Move general dump file related functionality into dumpfile.c. Remove unneeded headers. * tree-dump.h: Move function declarations into dumpfile.h. * dumpfile.h: Include "line-map.h". Add defines for MSG flags. (struct dump_file_info): Move here from tree-dump.c. Rename flags to pflags, state to pstate, stream to pstream, filename to pfilename. All callers updated. Add alt_flags, alt_state, alt_filenmae, alt_stream. * tree-vectorizer.c: Include "dumpfile.h". Remove vect_dump. (vect_set_dump_settings): Remove. (vect_print_dump_info): Ditto. * tree-vectorizer.h: Remove declaration of vect_dump and vect_print_dump_info. * tree-vect-loop.c: Include "dumpfile.h". Use new dump style. * tree-vect-data-refs.c: Ditto. * tree-vect-stmts.c: Ditto. * tree-vect-slp.c: Ditto. * tree-vect-patterns.c: Ditto. * tree-vect-loop-manip.c: Ditto. * testsuite/gcc.target/i386/vect-double-1.c: Fix test. * opts.c (vect_set_verbosity_level): Remove. (common_handle_option): Handle -fopt-info flag. Deprecate -ftree-vectorizer-verbose. * tree-parloops.c (gather_scalar_reductions): Remove reference to vect_dump. * flag-types.h: Remove vect_verbosity_levels. * common.opt: Add -fopt-info. Deprecate -ftree-vectorizer-verbose. * opts-global.c (dump_remap_tree_vectorizer_verbose): New function. (handle_common_deferred_options): Handle -fopt-info and -ftree-vectorizer-verbose. * Makefile.in: Add dumpfile.o. (tree-dump.o): Update dependencies. (tree-vect-loop.o): Ditto. (tree-vect-loop-manip.o): Ditto. (tree-vect-slp.o): Ditto. (tree-vect-stmts.o): Ditto. (tree-vectorizer.o): Ditto. (opts.o): Ditto. * passes.c (finish_optimization_passes): Instead of using dump_begin/dump_end, use dump_start/dump_finish. Do not use dump_file. (pass_init_dump_file): Ditto. * c-decl.c (c_write_global_declarations): Use a different method to determine if the dump has ben initialized. * decl2.c (cp_write_global_declarations): Use a different method to determine if the dump has ben initialized. git-svn-id: https://gcc.gnu.org/svn/gcc/trunk@191883 138bc75d-0d04-0410-961f-82ee72b054a4
Diffstat (limited to 'gcc/tree-vect-loop.c')
-rw-r--r--gcc/tree-vect-loop.c999
1 files changed, 560 insertions, 439 deletions
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
index 728bc0f09c3..d01203e8a82 100644
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -23,6 +23,7 @@ along with GCC; see the file COPYING3. If not see
#include "config.h"
#include "system.h"
#include "coretypes.h"
+#include "dumpfile.h"
#include "tm.h"
#include "ggc.h"
#include "tree.h"
@@ -184,8 +185,9 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
gimple_stmt_iterator pattern_def_si = gsi_none ();
bool analyze_pattern_stmt = false;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== vect_determine_vectorization_factor ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== vect_determine_vectorization_factor ===");
for (i = 0; i < nbbs; i++)
{
@@ -195,10 +197,10 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
{
phi = gsi_stmt (si);
stmt_info = vinfo_for_stmt (phi);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "==> examining phi: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "==> examining phi: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
}
gcc_assert (stmt_info);
@@ -208,34 +210,37 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
gcc_assert (!STMT_VINFO_VECTYPE (stmt_info));
scalar_type = TREE_TYPE (PHI_RESULT (phi));
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "get vectype for scalar type: ");
- print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "get vectype for scalar type: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, scalar_type);
}
vectype = get_vectype_for_scalar_type (scalar_type);
if (!vectype)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump,
- "not vectorized: unsupported data-type ");
- print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: unsupported "
+ "data-type ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM,
+ scalar_type);
}
return false;
}
STMT_VINFO_VECTYPE (stmt_info) = vectype;
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "vectype: ");
- print_generic_expr (vect_dump, vectype, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
}
nunits = TYPE_VECTOR_SUBPARTS (vectype);
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "nunits = %d", nunits);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "nunits = %d", nunits);
if (!vectorization_factor
|| (nunits > vectorization_factor))
@@ -254,10 +259,11 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
stmt_info = vinfo_for_stmt (stmt);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "==> examining statement: ");
- print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "==> examining statement: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
}
gcc_assert (stmt_info);
@@ -273,16 +279,17 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
{
stmt = pattern_stmt;
stmt_info = vinfo_for_stmt (pattern_stmt);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "==> examining pattern statement: ");
- print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "==> examining pattern statement: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
}
}
else
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "skip.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "skip.");
gsi_next (&si);
continue;
}
@@ -321,12 +328,12 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
if (!gsi_end_p (pattern_def_si))
{
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump,
- "==> examining pattern def stmt: ");
- print_gimple_stmt (vect_dump, pattern_def_stmt, 0,
- TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "==> examining pattern def stmt: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM,
+ pattern_def_stmt, 0);
}
stmt = pattern_def_stmt;
@@ -344,20 +351,23 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
if (gimple_get_lhs (stmt) == NULL_TREE)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump, "not vectorized: irregular stmt.");
- print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: irregular stmt.");
+ dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt,
+ 0);
}
return false;
}
if (VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))))
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump, "not vectorized: vector stmt in loop:");
- print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: vector stmt in loop:");
+ dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, stmt, 0);
}
return false;
}
@@ -377,19 +387,22 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
{
gcc_assert (!STMT_VINFO_DATA_REF (stmt_info));
scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "get vectype for scalar type: ");
- print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "get vectype for scalar type: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, scalar_type);
}
vectype = get_vectype_for_scalar_type (scalar_type);
if (!vectype)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump,
- "not vectorized: unsupported data-type ");
- print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: unsupported "
+ "data-type ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM,
+ scalar_type);
}
return false;
}
@@ -402,19 +415,21 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
support one vector size per loop). */
scalar_type = vect_get_smallest_scalar_type (stmt, &dummy,
&dummy);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "get vectype for scalar type: ");
- print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "get vectype for scalar type: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, scalar_type);
}
vf_vectype = get_vectype_for_scalar_type (scalar_type);
if (!vf_vectype)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump,
- "not vectorized: unsupported data-type ");
- print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: unsupported data-type ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM,
+ scalar_type);
}
return false;
}
@@ -422,28 +437,29 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
if ((GET_MODE_SIZE (TYPE_MODE (vectype))
!= GET_MODE_SIZE (TYPE_MODE (vf_vectype))))
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump,
- "not vectorized: different sized vector "
- "types in statement, ");
- print_generic_expr (vect_dump, vectype, TDF_SLIM);
- fprintf (vect_dump, " and ");
- print_generic_expr (vect_dump, vf_vectype, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: different sized vector "
+ "types in statement, ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM,
+ vectype);
+ dump_printf (MSG_MISSED_OPTIMIZATION, " and ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM,
+ vf_vectype);
}
return false;
}
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "vectype: ");
- print_generic_expr (vect_dump, vf_vectype, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, vf_vectype);
}
nunits = TYPE_VECTOR_SUBPARTS (vf_vectype);
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "nunits = %d", nunits);
-
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "nunits = %d", nunits);
if (!vectorization_factor
|| (nunits > vectorization_factor))
vectorization_factor = nunits;
@@ -457,12 +473,14 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
}
/* TODO: Analyze cost. Decide if worth while to vectorize. */
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "vectorization factor = %d", vectorization_factor);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "vectorization factor = %d",
+ vectorization_factor);
if (vectorization_factor <= 1)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: unsupported data-type");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: unsupported data-type");
return false;
}
LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
@@ -497,12 +515,12 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init,
step_expr = evolution_part;
init_expr = unshare_expr (initial_condition_in_loop_num (access_fn, loop_nb));
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "step: ");
- print_generic_expr (vect_dump, step_expr, TDF_SLIM);
- fprintf (vect_dump, ", init: ");
- print_generic_expr (vect_dump, init_expr, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "step: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, step_expr);
+ dump_printf (MSG_NOTE, ", init: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, init_expr);
}
*init = init_expr;
@@ -510,8 +528,9 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init,
if (TREE_CODE (step_expr) != INTEGER_CST)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "step unknown.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "step unknown.");
return false;
}
@@ -534,8 +553,9 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
gimple_stmt_iterator gsi;
bool double_reduc;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== vect_analyze_scalar_cycles ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== vect_analyze_scalar_cycles ===");
/* First - identify all inductions. Reduction detection assumes that all the
inductions have been identified, therefore, this order must not be
@@ -547,10 +567,10 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
tree def = PHI_RESULT (phi);
stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "Analyze phi: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
}
/* Skip virtual phi's. The data dependences that are associated with
@@ -565,10 +585,11 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
if (access_fn)
{
STRIP_NOPS (access_fn);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "Access function of PHI: ");
- print_generic_expr (vect_dump, access_fn, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Access function of PHI: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, access_fn);
}
STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo)
= evolution_part_in_loop_num (access_fn, loop->num);
@@ -583,8 +604,8 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) != NULL_TREE);
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Detected induction.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "Detected induction.");
STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
}
@@ -598,10 +619,10 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
gimple reduc_stmt;
bool nested_cycle;
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "Analyze phi: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
}
gcc_assert (!virtual_operand_p (def)
@@ -614,8 +635,9 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
{
if (double_reduc)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Detected double reduction.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Detected double reduction.");
STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_double_reduction_def;
STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
@@ -625,8 +647,9 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
{
if (nested_cycle)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Detected vectorizable nested cycle.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Detected vectorizable nested cycle.");
STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_nested_cycle;
STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
@@ -634,8 +657,9 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
}
else
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Detected reduction.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Detected reduction.");
STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_reduction_def;
STMT_VINFO_DEF_TYPE (vinfo_for_stmt (reduc_stmt)) =
@@ -649,8 +673,9 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_vinfo, struct loop *loop)
}
}
else
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Unknown def-use cycle pattern.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "Unknown def-use cycle pattern.");
}
VEC_free (gimple, heap, worklist);
@@ -710,9 +735,9 @@ vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
{
tree niters;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== get_loop_niters ===");
-
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== get_loop_niters ===");
niters = number_of_exit_cond_executions (loop);
if (niters != NULL_TREE
@@ -720,10 +745,10 @@ vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
{
*number_of_iterations = niters;
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "==> get_loop_niters:" );
- print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "==> get_loop_niters:");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, *number_of_iterations);
}
}
@@ -968,16 +993,18 @@ vect_analyze_loop_1 (struct loop *loop)
{
loop_vec_info loop_vinfo;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "===== analyze_loop_nest_1 =====");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "===== analyze_loop_nest_1 =====");
/* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
loop_vinfo = vect_analyze_loop_form (loop);
if (!loop_vinfo)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad inner-loop form.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad inner-loop form.");
return NULL;
}
@@ -1001,8 +1028,9 @@ vect_analyze_loop_form (struct loop *loop)
tree number_of_iterations = NULL;
loop_vec_info inner_loop_vinfo = NULL;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== vect_analyze_loop_form ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== vect_analyze_loop_form ===");
/* Different restrictions apply when we are considering an inner-most loop,
vs. an outer (nested) loop.
@@ -1024,15 +1052,17 @@ vect_analyze_loop_form (struct loop *loop)
if (loop->num_nodes != 2)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: control flow in loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: control flow in loop.");
return NULL;
}
if (empty_block_p (loop->header))
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: empty loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: empty loop.");
return NULL;
}
}
@@ -1060,8 +1090,9 @@ vect_analyze_loop_form (struct loop *loop)
if ((loop->inner)->inner || (loop->inner)->next)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: multiple nested loops.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: multiple nested loops.");
return NULL;
}
@@ -1069,25 +1100,27 @@ vect_analyze_loop_form (struct loop *loop)
inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
if (!inner_loop_vinfo)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: Bad inner loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: Bad inner loop.");
return NULL;
}
if (!expr_invariant_in_loop_p (loop,
LOOP_VINFO_NITERS (inner_loop_vinfo)))
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump,
- "not vectorized: inner-loop count not invariant.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: inner-loop count not invariant.");
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
}
if (loop->num_nodes != 5)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: control flow in loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: control flow in loop.");
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
}
@@ -1101,25 +1134,29 @@ vect_analyze_loop_form (struct loop *loop)
|| !single_exit (innerloop)
|| single_exit (innerloop)->dest != EDGE_PRED (loop->latch, 0)->src)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: unsupported outerloop form.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: unsupported outerloop form.");
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
}
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Considering outer-loop vectorization.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Considering outer-loop vectorization.");
}
if (!single_exit (loop)
|| EDGE_COUNT (loop->header->preds) != 2)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
if (!single_exit (loop))
- fprintf (vect_dump, "not vectorized: multiple exits.");
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: multiple exits.");
else if (EDGE_COUNT (loop->header->preds) != 2)
- fprintf (vect_dump, "not vectorized: too many incoming edges.");
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: too many incoming edges.");
}
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, true);
@@ -1133,8 +1170,9 @@ vect_analyze_loop_form (struct loop *loop)
if (!empty_block_p (loop->latch)
|| !gimple_seq_empty_p (phi_nodes (loop->latch)))
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: unexpected loop form.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: unexpected loop form.");
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
@@ -1147,13 +1185,14 @@ vect_analyze_loop_form (struct loop *loop)
if (!(e->flags & EDGE_ABNORMAL))
{
split_loop_exit_edge (e);
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "split exit edge.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf (MSG_NOTE, "split exit edge.");
}
else
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: abnormal loop exit edge.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: abnormal loop exit edge.");
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
@@ -1163,8 +1202,9 @@ vect_analyze_loop_form (struct loop *loop)
loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
if (!loop_cond)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "not vectorized: complicated exit condition.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: complicated exit condition.");
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
@@ -1172,9 +1212,10 @@ vect_analyze_loop_form (struct loop *loop)
if (!number_of_iterations)
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump,
- "not vectorized: number of iterations cannot be computed.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: number of iterations cannot be "
+ "computed.");
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
@@ -1182,8 +1223,9 @@ vect_analyze_loop_form (struct loop *loop)
if (chrec_contains_undetermined (number_of_iterations))
{
- if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS))
- fprintf (vect_dump, "Infinite number of iterations.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "Infinite number of iterations.");
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, true);
return NULL;
@@ -1191,16 +1233,18 @@ vect_analyze_loop_form (struct loop *loop)
if (!NITERS_KNOWN_P (number_of_iterations))
{
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "Symbolic number of iterations is ");
- print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Symbolic number of iterations is ");
+ dump_generic_expr (MSG_NOTE, TDF_DETAILS, number_of_iterations);
}
}
else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: number of iterations = 0.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: number of iterations = 0.");
if (inner_loop_vinfo)
destroy_loop_vec_info (inner_loop_vinfo, false);
return NULL;
@@ -1244,8 +1288,9 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
bool only_slp_in_loop = true, ok;
HOST_WIDE_INT max_niter;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== vect_analyze_loop_operations ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== vect_analyze_loop_operations ===");
gcc_assert (LOOP_VINFO_VECT_FACTOR (loop_vinfo));
vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
@@ -1279,9 +1324,10 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));
LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Updating vectorization factor to %d ",
- vectorization_factor);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Updating vectorization factor to %d ",
+ vectorization_factor);
}
for (i = 0; i < nbbs; i++)
@@ -1294,10 +1340,10 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
ok = true;
stmt_info = vinfo_for_stmt (phi);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "examining phi: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "examining phi: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
}
/* Inner-loop loop-closed exit phi in outer-loop vectorization
@@ -1313,9 +1359,10 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
&& STMT_VINFO_DEF_TYPE (stmt_info)
!= vect_double_reduction_def)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump,
- "Unsupported loop-closed phi in outer-loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "Unsupported loop-closed phi in "
+ "outer-loop.");
return false;
}
@@ -1354,8 +1401,9 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
if (STMT_VINFO_LIVE_P (stmt_info))
{
/* FORNOW: not yet supported. */
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: value used after loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: value used after loop.");
return false;
}
@@ -1363,8 +1411,9 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
&& STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
{
/* A scalar-dependence cycle that we don't support. */
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: scalar dependence cycle.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: scalar dependence cycle.");
return false;
}
@@ -1377,11 +1426,12 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
if (!ok)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump,
- "not vectorized: relevant phi not supported: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: relevant phi not "
+ "supported: ");
+ dump_gimple_stmt (MSG_MISSED_OPTIMIZATION, TDF_SLIM, phi, 0);
}
return false;
}
@@ -1402,31 +1452,35 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
touching this loop. */
if (!need_to_vectorize)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump,
- "All the computation can be taken out of the loop.");
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump,
- "not vectorized: redundant loop. no profit to vectorize.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "All the computation can be taken out of the loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: redundant loop. no profit to "
+ "vectorize.");
return false;
}
if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
- && vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump,
- "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
- vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
+ && dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "vectorization_factor = %d, niters = "
+ HOST_WIDE_INT_PRINT_DEC, vectorization_factor,
+ LOOP_VINFO_INT_NITERS (loop_vinfo));
if ((LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
&& (LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor))
|| ((max_niter = max_stmt_executions_int (loop)) != -1
&& (unsigned HOST_WIDE_INT) max_niter < vectorization_factor))
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: iteration count too small.");
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump,"not vectorized: iteration count smaller than "
- "vectorization factor.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: iteration count too small.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: iteration count smaller than "
+ "vectorization factor.");
return false;
}
@@ -1441,11 +1495,13 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
if (min_profitable_iters < 0)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: vectorization not profitable.");
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "not vectorized: vector version will never be "
- "profitable.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: vectorization not profitable.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: vector version will never be "
+ "profitable.");
return false;
}
@@ -1464,13 +1520,14 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
&& LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: vectorization not "
- "profitable.");
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "not vectorized: iteration count smaller than "
- "user specified loop bound parameter or minimum "
- "profitable iterations (whichever is more conservative).");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: vectorization not profitable.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "not vectorized: iteration count smaller than user "
+ "specified loop bound parameter or minimum profitable "
+ "iterations (whichever is more conservative).");
return false;
}
@@ -1478,20 +1535,20 @@ vect_analyze_loop_operations (loop_vec_info loop_vinfo, bool slp)
|| LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
|| LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "epilog loop required.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "epilog loop required.");
if (!vect_can_advance_ivs_p (loop_vinfo))
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump,
- "not vectorized: can't create epilog loop 1.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: can't create epilog loop 1.");
return false;
}
if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
{
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump,
- "not vectorized: can't create epilog loop 2.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not vectorized: can't create epilog loop 2.");
return false;
}
}
@@ -1522,8 +1579,9 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad data references.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad data references.");
return false;
}
@@ -1539,8 +1597,9 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "unexpected pattern.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "unexpected pattern.");
return false;
}
@@ -1553,22 +1612,25 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
if (!ok
|| max_vf < min_vf)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad data dependence.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad data dependence.");
return false;
}
ok = vect_determine_vectorization_factor (loop_vinfo);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "can't determine vectorization factor.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "can't determine vectorization factor.");
return false;
}
if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad data dependence.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad data dependence.");
return false;
}
@@ -1578,8 +1640,9 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad data alignment.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad data alignment.");
return false;
}
@@ -1589,8 +1652,9 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad data access.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad data access.");
return false;
}
@@ -1600,9 +1664,10 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_prune_runtime_alias_test_list (loop_vinfo);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "too long list of versioning for alias "
- "run-time tests.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "too long list of versioning for alias "
+ "run-time tests.");
return false;
}
@@ -1612,8 +1677,9 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_enhance_data_refs_alignment (loop_vinfo);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad data alignment.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad data alignment.");
return false;
}
@@ -1636,8 +1702,9 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
ok = vect_analyze_loop_operations (loop_vinfo, slp);
if (!ok)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad operation or unsupported loop bound.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad operation or unsupported loop bound.");
return false;
}
@@ -1659,15 +1726,17 @@ vect_analyze_loop (struct loop *loop)
current_vector_size = 0;
vector_sizes = targetm.vectorize.autovectorize_vector_sizes ();
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "===== analyze_loop_nest =====");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "===== analyze_loop_nest =====");
if (loop_outer (loop)
&& loop_vec_info_for_loop (loop_outer (loop))
&& LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop (loop_outer (loop))))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "outer-loop already vectorized.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "outer-loop already vectorized.");
return NULL;
}
@@ -1677,8 +1746,9 @@ vect_analyze_loop (struct loop *loop)
loop_vinfo = vect_analyze_loop_form (loop);
if (!loop_vinfo)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "bad loop form.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "bad loop form.");
return NULL;
}
@@ -1698,9 +1768,10 @@ vect_analyze_loop (struct loop *loop)
/* Try the next biggest vector size. */
current_vector_size = 1 << floor_log2 (vector_sizes);
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "***** Re-trying analysis with "
- "vector size %d\n", current_vector_size);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "***** Re-trying analysis with "
+ "vector size %d\n", current_vector_size);
}
}
@@ -1754,10 +1825,10 @@ reduction_code_for_scalar_code (enum tree_code code,
STMT is printed with a message MSG. */
static void
-report_vect_op (gimple stmt, const char *msg)
+report_vect_op (int msg_type, gimple stmt, const char *msg)
{
- fprintf (vect_dump, "%s", msg);
- print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
+ dump_printf_loc (msg_type, vect_location, "%s", msg);
+ dump_gimple_stmt (msg_type, TDF_SLIM, stmt, 0);
}
@@ -1929,10 +2000,10 @@ vect_is_slp_reduction (loop_vec_info loop_info, gimple phi, gimple first_stmt)
== vect_internal_def
&& !is_loop_header_bb_p (gimple_bb (def_stmt)))))
{
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "swapping oprnds: ");
- print_gimple_stmt (vect_dump, next_stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location, "swapping oprnds: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, next_stmt, 0);
}
swap_tree_operands (next_stmt,
@@ -2031,8 +2102,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (!flow_bb_inside_loop_p (loop, gimple_bb (use_stmt)))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "intermediate value used outside loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "intermediate value used outside loop.");
return NULL;
}
@@ -2042,18 +2114,20 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
nloop_uses++;
if (nloop_uses > 1)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "reduction used in loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "reduction used in loop.");
return NULL;
}
}
if (TREE_CODE (loop_arg) != SSA_NAME)
{
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump, "reduction: not ssa_name: ");
- print_generic_expr (vect_dump, loop_arg, TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "reduction: not ssa_name: ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM, loop_arg);
}
return NULL;
}
@@ -2061,15 +2135,16 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
def_stmt = SSA_NAME_DEF_STMT (loop_arg);
if (!def_stmt)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "reduction: no def_stmt.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "reduction: no def_stmt.");
return NULL;
}
if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- print_gimple_stmt (vect_dump, def_stmt, 0, TDF_SLIM);
+ if (dump_kind_p (MSG_NOTE))
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, def_stmt, 0);
return NULL;
}
@@ -2096,8 +2171,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
nloop_uses++;
if (nloop_uses > 1)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "reduction used in loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "reduction used in loop.");
return NULL;
}
}
@@ -2111,8 +2187,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (gimple_phi_num_args (def_stmt) != 1
|| TREE_CODE (op1) != SSA_NAME)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "unsupported phi node definition.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "unsupported phi node definition.");
return NULL;
}
@@ -2123,8 +2200,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
&& flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
&& is_gimple_assign (def1))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "detected double reduction: ");
+ if (dump_kind_p (MSG_NOTE))
+ report_vect_op (MSG_NOTE, def_stmt,
+ "detected double reduction: ");
*double_reduc = true;
return def_stmt;
@@ -2149,8 +2227,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (check_reduction
&& (!commutative_tree_code (code) || !associative_tree_code (code)))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: not commutative/associative: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: not commutative/associative: ");
return NULL;
}
@@ -2158,8 +2237,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
{
if (code != COND_EXPR)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: not binary operation: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: not binary operation: ");
return NULL;
}
@@ -2176,8 +2256,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: uses not ssa_names: ");
return NULL;
}
@@ -2189,8 +2270,9 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: uses not ssa_names: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: uses not ssa_names: ");
return NULL;
}
@@ -2206,24 +2288,29 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
|| (op4 && TREE_CODE (op4) == SSA_NAME
&& !types_compatible_p (type, TREE_TYPE (op4))))
{
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "reduction: multiple types: operation type: ");
- print_generic_expr (vect_dump, type, TDF_SLIM);
- fprintf (vect_dump, ", operands types: ");
- print_generic_expr (vect_dump, TREE_TYPE (op1), TDF_SLIM);
- fprintf (vect_dump, ",");
- print_generic_expr (vect_dump, TREE_TYPE (op2), TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "reduction: multiple types: operation type: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM, type);
+ dump_printf (MSG_NOTE, ", operands types: ");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM,
+ TREE_TYPE (op1));
+ dump_printf (MSG_NOTE, ",");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM,
+ TREE_TYPE (op2));
if (op3)
{
- fprintf (vect_dump, ",");
- print_generic_expr (vect_dump, TREE_TYPE (op3), TDF_SLIM);
+ dump_printf (MSG_NOTE, ",");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM,
+ TREE_TYPE (op3));
}
if (op4)
{
- fprintf (vect_dump, ",");
- print_generic_expr (vect_dump, TREE_TYPE (op4), TDF_SLIM);
+ dump_printf (MSG_NOTE, ",");
+ dump_generic_expr (MSG_NOTE, TDF_SLIM,
+ TREE_TYPE (op4));
}
}
@@ -2243,23 +2330,25 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
&& check_reduction)
{
/* Changing the order of operations changes the semantics. */
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: unsafe fp math optimization: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: unsafe fp math optimization: ");
return NULL;
}
else if (INTEGRAL_TYPE_P (type) && TYPE_OVERFLOW_TRAPS (type)
&& check_reduction)
{
/* Changing the order of operations changes the semantics. */
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: unsafe int math optimization: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: unsafe int math optimization: ");
return NULL;
}
else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
{
/* Changing the order of operations changes the semantics. */
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt,
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
"reduction: unsafe fixed-point math optimization: ");
return NULL;
}
@@ -2295,8 +2384,8 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (code != COND_EXPR
&& ((!def1 || gimple_nop_p (def1)) && (!def2 || gimple_nop_p (def2))))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: no defs for operands: ");
+ if (dump_kind_p (MSG_NOTE))
+ report_vect_op (MSG_NOTE, def_stmt, "reduction: no defs for operands: ");
return NULL;
}
@@ -2317,8 +2406,8 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
== vect_internal_def
&& !is_loop_header_bb_p (gimple_bb (def1)))))))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "detected reduction: ");
+ if (dump_kind_p (MSG_NOTE))
+ report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
return def_stmt;
}
@@ -2340,8 +2429,8 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
/* Swap operands (just for simplicity - so that the rest of the code
can assume that the reduction variable is always the last (second)
argument). */
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt,
+ if (dump_kind_p (MSG_NOTE))
+ report_vect_op (MSG_NOTE, def_stmt,
"detected reduction: need to swap operands: ");
swap_tree_operands (def_stmt, gimple_assign_rhs1_ptr (def_stmt),
@@ -2352,8 +2441,8 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
}
else
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "detected reduction: ");
+ if (dump_kind_p (MSG_NOTE))
+ report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
}
return def_stmt;
@@ -2362,14 +2451,16 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
/* Try to find SLP reduction chain. */
if (check_reduction && vect_is_slp_reduction (loop_info, phi, def_stmt))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: detected reduction chain: ");
+ if (dump_kind_p (MSG_NOTE))
+ report_vect_op (MSG_NOTE, def_stmt,
+ "reduction: detected reduction chain: ");
return def_stmt;
}
- if (vect_print_dump_info (REPORT_DETAILS))
- report_vect_op (def_stmt, "reduction: unknown pattern: ");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
+ "reduction: unknown pattern: ");
return NULL;
}
@@ -2475,10 +2566,10 @@ vect_get_known_peeling_cost (loop_vec_info loop_vinfo, int peel_iters_prologue,
if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
{
*peel_iters_epilogue = vf/2;
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model: "
- "epilogue peel iters set to vf/2 because "
- "loop iterations are unknown .");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "cost model: epilogue peel iters set to vf/2 "
+ "because loop iterations are unknown .");
/* If peeled iterations are known but number of scalar loop
iterations are unknown, count a taken branch per peeled loop. */
@@ -2536,8 +2627,7 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
/* Cost model disabled. */
if (!flag_vect_cost_model)
{
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model disabled.");
+ dump_printf_loc (MSG_NOTE, vect_location, "cost model disabled.");
return 0;
}
@@ -2549,9 +2639,9 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo));
(void) add_stmt_cost (target_cost_data, len, vector_stmt, NULL, 0,
vect_prologue);
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model: Adding cost of checks for loop "
- "versioning to treat misalignment.\n");
+ dump_printf (MSG_NOTE,
+ "cost model: Adding cost of checks for loop "
+ "versioning to treat misalignment.\n");
}
/* Requires loop versioning with alias checks. */
@@ -2561,9 +2651,9 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
unsigned len = VEC_length (ddr_p, LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo));
(void) add_stmt_cost (target_cost_data, len, vector_stmt, NULL, 0,
vect_prologue);
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model: Adding cost of checks for loop "
- "versioning aliasing.\n");
+ dump_printf (MSG_NOTE,
+ "cost model: Adding cost of checks for loop "
+ "versioning aliasing.\n");
}
if (LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)
@@ -2593,17 +2683,15 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
if (npeel < 0)
{
peel_iters_prologue = vf/2;
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model: "
- "prologue peel iters set to vf/2.");
+ dump_printf (MSG_NOTE, "cost model: "
+ "prologue peel iters set to vf/2.");
/* If peeling for alignment is unknown, loop bound of main loop becomes
unknown. */
peel_iters_epilogue = vf/2;
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model: "
- "epilogue peel iters set to vf/2 because "
- "peeling for alignment is unknown .");
+ dump_printf (MSG_NOTE, "cost model: "
+ "epilogue peel iters set to vf/2 because "
+ "peeling for alignment is unknown.");
/* If peeled iterations are unknown, count a taken branch and a not taken
branch per peeled loop. Even if scalar loop iterations are known,
@@ -2769,32 +2857,35 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
/* vector version will never be profitable. */
else
{
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "cost model: the vector iteration cost = %d "
- "divided by the scalar iteration cost = %d "
- "is greater or equal to the vectorization factor = %d.",
- vec_inside_cost, scalar_single_iter_cost, vf);
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "cost model: the vector iteration cost = %d "
+ "divided by the scalar iteration cost = %d "
+ "is greater or equal to the vectorization factor = %d.",
+ vec_inside_cost, scalar_single_iter_cost, vf);
return -1;
}
- if (vect_print_dump_info (REPORT_COST))
- {
- fprintf (vect_dump, "Cost model analysis: \n");
- fprintf (vect_dump, " Vector inside of loop cost: %d\n",
- vec_inside_cost);
- fprintf (vect_dump, " Vector prologue cost: %d\n",
- vec_prologue_cost);
- fprintf (vect_dump, " Vector epilogue cost: %d\n",
- vec_epilogue_cost);
- fprintf (vect_dump, " Scalar iteration cost: %d\n",
- scalar_single_iter_cost);
- fprintf (vect_dump, " Scalar outside cost: %d\n", scalar_outside_cost);
- fprintf (vect_dump, " prologue iterations: %d\n",
- peel_iters_prologue);
- fprintf (vect_dump, " epilogue iterations: %d\n",
- peel_iters_epilogue);
- fprintf (vect_dump, " Calculated minimum iters for profitability: %d\n",
- min_profitable_iters);
+ if (dump_kind_p (MSG_NOTE))
+ {
+ dump_printf_loc (MSG_NOTE, vect_location, "Cost model analysis: \n");
+ dump_printf (MSG_NOTE, " Vector inside of loop cost: %d\n",
+ vec_inside_cost);
+ dump_printf (MSG_NOTE, " Vector prologue cost: %d\n",
+ vec_prologue_cost);
+ dump_printf (MSG_NOTE, " Vector epilogue cost: %d\n",
+ vec_epilogue_cost);
+ dump_printf (MSG_NOTE, " Scalar iteration cost: %d\n",
+ scalar_single_iter_cost);
+ dump_printf (MSG_NOTE, " Scalar outside cost: %d\n",
+ scalar_outside_cost);
+ dump_printf (MSG_NOTE, " prologue iterations: %d\n",
+ peel_iters_prologue);
+ dump_printf (MSG_NOTE, " epilogue iterations: %d\n",
+ peel_iters_epilogue);
+ dump_printf (MSG_NOTE,
+ " Calculated minimum iters for profitability: %d\n",
+ min_profitable_iters);
}
min_profitable_iters =
@@ -2805,9 +2896,9 @@ vect_estimate_min_profitable_iters (loop_vec_info loop_vinfo)
then skip the vectorized loop. */
min_profitable_iters--;
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, " Profitability threshold = %d\n",
- min_profitable_iters);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ " Profitability threshold = %d\n", min_profitable_iters);
return min_profitable_iters;
}
@@ -2864,10 +2955,12 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
if (!vectype)
{
- if (vect_print_dump_info (REPORT_COST))
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
{
- fprintf (vect_dump, "unsupported data-type ");
- print_generic_expr (vect_dump, TREE_TYPE (reduction_op), TDF_SLIM);
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "unsupported data-type ");
+ dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_SLIM,
+ TREE_TYPE (reduction_op));
}
return false;
}
@@ -2933,10 +3026,11 @@ vect_model_reduction_cost (stmt_vec_info stmt_info, enum tree_code reduc_code,
}
}
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "vect_model_reduction_cost: inside_cost = %d, "
- "prologue_cost = %d, epilogue_cost = %d .", inside_cost,
- prologue_cost, epilogue_cost);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf (MSG_NOTE,
+ "vect_model_reduction_cost: inside_cost = %d, "
+ "prologue_cost = %d, epilogue_cost = %d .", inside_cost,
+ prologue_cost, epilogue_cost);
return true;
}
@@ -2961,9 +3055,10 @@ vect_model_induction_cost (stmt_vec_info stmt_info, int ncopies)
prologue_cost = add_stmt_cost (target_cost_data, 2, scalar_to_vec,
stmt_info, 0, vect_prologue);
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump, "vect_model_induction_cost: inside_cost = %d, "
- "prologue_cost = %d .", inside_cost, prologue_cost);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "vect_model_induction_cost: inside_cost = %d, "
+ "prologue_cost = %d .", inside_cost, prologue_cost);
}
@@ -3089,10 +3184,11 @@ get_initial_def_for_induction (gimple iv_phi)
new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
gcc_assert (!new_bb);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "created new init_stmt: ");
- print_gimple_stmt (vect_dump, init_stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "created new init_stmt: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, init_stmt, 0);
}
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, new_name);
}
@@ -3231,21 +3327,24 @@ get_initial_def_for_induction (gimple iv_phi)
&& !STMT_VINFO_LIVE_P (stmt_vinfo));
STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "vector of inductions after inner-loop:");
- print_gimple_stmt (vect_dump, new_stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "vector of inductions after inner-loop:");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, new_stmt, 0);
}
}
}
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "transform induction: created def-use cycle: ");
- print_gimple_stmt (vect_dump, induction_phi, 0, TDF_SLIM);
- fprintf (vect_dump, "\n");
- print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (vec_def), 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "transform induction: created def-use cycle: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, induction_phi, 0);
+ dump_printf (MSG_NOTE, "\n");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM,
+ SSA_NAME_DEF_STMT (vec_def), 0);
}
STMT_VINFO_VEC_STMT (phi_info) = induction_phi;
@@ -3646,14 +3745,13 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "transform reduction: created def-use"
- " cycle: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
- fprintf (vect_dump, "\n");
- print_gimple_stmt (vect_dump, SSA_NAME_DEF_STMT (def), 0,
- TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "transform reduction: created def-use cycle: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
+ dump_printf (MSG_NOTE, "\n");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, SSA_NAME_DEF_STMT (def), 0);
}
phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
@@ -3848,8 +3946,9 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
/*** Case 1: Create:
v_out2 = reduc_expr <v_out1> */
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Reduce using direct vector reduction.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Reduce using direct vector reduction.");
vec_dest = vect_create_destination_var (scalar_dest, vectype);
tmp = build1 (reduc_code, vectype, new_phi_result);
@@ -3898,8 +3997,9 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
Create: va = vop <va, va'>
} */
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Reduce using vector shifts");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Reduce using vector shifts");
vec_dest = vect_create_destination_var (scalar_dest, vectype);
new_temp = new_phi_result;
@@ -3938,8 +4038,9 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
Create: s = op <s, s'> // For non SLP cases
} */
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "Reduce using scalar code. ");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Reduce using scalar code. ");
vec_size_in_bits = tree_low_cst (TYPE_SIZE (vectype), 1);
FOR_EACH_VEC_ELT (gimple, new_phis, i, new_phi)
@@ -4028,8 +4129,9 @@ vect_create_epilog_for_reduction (VEC (tree, heap) *vect_defs, gimple stmt,
{
tree rhs;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "extract scalar result");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "extract scalar result");
if (BYTES_BIG_ENDIAN)
bitpos = size_binop (MULT_EXPR,
@@ -4266,11 +4368,11 @@ vect_finalize_reduction:
UNKNOWN_LOCATION);
add_phi_arg (vect_phi, PHI_RESULT (inner_phi),
loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "created double reduction phi "
- "node: ");
- print_gimple_stmt (vect_dump, vect_phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "created double reduction phi node: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, vect_phi, 0);
}
vect_phi_res = PHI_RESULT (vect_phi);
@@ -4616,8 +4718,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
{
if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0, NULL))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "unsupported condition in reduction");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "unsupported condition in reduction");
return false;
}
@@ -4630,24 +4733,25 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
optab = optab_for_tree_code (code, vectype_in, optab_default);
if (!optab)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "no optab.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "no optab.");
return false;
}
if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "op not supported by target.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf (MSG_NOTE, "op not supported by target.");
if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
|| LOOP_VINFO_VECT_FACTOR (loop_vinfo)
< vect_min_worthwhile_factor (code))
return false;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "proceeding using word mode.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf (MSG_NOTE, "proceeding using word mode.");
}
/* Worthwhile without SIMD support? */
@@ -4655,8 +4759,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
&& LOOP_VINFO_VECT_FACTOR (loop_vinfo)
< vect_min_worthwhile_factor (code))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "not worthwhile without SIMD support.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "not worthwhile without SIMD support.");
return false;
}
@@ -4735,8 +4840,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
optab_default);
if (!reduc_optab)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "no optab for reduction.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "no optab for reduction.");
epilog_reduc_code = ERROR_MARK;
}
@@ -4744,8 +4850,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
if (reduc_optab
&& optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "reduc op not supported by target.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "reduc op not supported by target.");
epilog_reduc_code = ERROR_MARK;
}
@@ -4754,8 +4861,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
{
if (!nested_cycle || double_reduc)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "no reduc code for scalar code.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "no reduc code for scalar code.");
return false;
}
@@ -4763,8 +4871,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
if (double_reduc && ncopies > 1)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "multiple types in double reduction");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "multiple types in double reduction");
return false;
}
@@ -4781,8 +4890,9 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
ops[1] = fold_convert (TREE_TYPE (ops[0]), ops[1]);
else
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "invalid types in dot-prod");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "invalid types in dot-prod");
return false;
}
@@ -4798,8 +4908,8 @@ vectorizable_reduction (gimple stmt, gimple_stmt_iterator *gsi,
/** Transform. **/
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "transform reduction.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "transform reduction.");
/* FORNOW: Multiple types are not supported for condition. */
if (code == COND_EXPR)
@@ -5084,8 +5194,9 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
if (ncopies > 1)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "multiple types in nested loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "multiple types in nested loop.");
return false;
}
@@ -5107,9 +5218,10 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
if (!(STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
&& !STMT_VINFO_LIVE_P (exit_phi_vinfo)))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "inner-loop induction only used outside "
- "of the outer vectorized loop.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "inner-loop induction only used outside "
+ "of the outer vectorized loop.");
return false;
}
}
@@ -5130,16 +5242,17 @@ vectorizable_induction (gimple phi, gimple_stmt_iterator *gsi ATTRIBUTE_UNUSED,
if (!vec_stmt) /* transformation not required. */
{
STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== vectorizable_induction ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== vectorizable_induction ===");
vect_model_induction_cost (stmt_info, ncopies);
return true;
}
/** Transform. **/
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "transform induction phi.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "transform induction phi.");
vec_def = get_initial_def_for_induction (phi);
*vec_stmt = SSA_NAME_DEF_STMT (vec_def);
@@ -5203,8 +5316,9 @@ vectorizable_live_operation (gimple stmt,
&& !vect_is_simple_use (op, stmt, loop_vinfo, NULL, &def_stmt, &def,
&dt))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "use not simple.");
+ if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
+ "use not simple.");
return false;
}
@@ -5241,8 +5355,9 @@ vect_loop_kill_debug_uses (struct loop *loop, gimple stmt)
{
if (gimple_debug_bind_p (ustmt))
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "killing debug use");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "killing debug use");
gimple_debug_bind_reset_value (ustmt);
update_stmt (ustmt);
@@ -5280,8 +5395,8 @@ vect_transform_loop (loop_vec_info loop_vinfo)
bool check_profitability = false;
int th;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== vec_transform_loop ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "=== vec_transform_loop ===");
/* Use the more conservative vectorization threshold. If the number
of iterations is constant assume the cost check has been performed
@@ -5294,9 +5409,9 @@ vect_transform_loop (loop_vec_info loop_vinfo)
if (th >= LOOP_VINFO_VECT_FACTOR (loop_vinfo) - 1
&& !LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
{
- if (vect_print_dump_info (REPORT_COST))
- fprintf (vect_dump,
- "Profitability threshold is %d loop iterations.", th);
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "Profitability threshold is %d loop iterations.", th);
check_profitability = true;
}
@@ -5355,10 +5470,11 @@ vect_transform_loop (loop_vec_info loop_vinfo)
for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
{
phi = gsi_stmt (si);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "------>vectorizing phi: ");
- print_gimple_stmt (vect_dump, phi, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "------>vectorizing phi: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
}
stmt_info = vinfo_for_stmt (phi);
if (!stmt_info)
@@ -5373,13 +5489,13 @@ vect_transform_loop (loop_vec_info loop_vinfo)
if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
!= (unsigned HOST_WIDE_INT) vectorization_factor)
- && vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "multiple-types.");
+ && dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "multiple-types.");
if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
{
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "transform phi.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "transform phi.");
vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
}
}
@@ -5394,10 +5510,11 @@ vect_transform_loop (loop_vec_info loop_vinfo)
else
stmt = gsi_stmt (si);
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "------>vectorizing statement: ");
- print_gimple_stmt (vect_dump, stmt, 0, TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "------>vectorizing statement: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
}
stmt_info = vinfo_for_stmt (stmt);
@@ -5465,12 +5582,13 @@ vect_transform_loop (loop_vec_info loop_vinfo)
if (!gsi_end_p (pattern_def_si))
{
- if (vect_print_dump_info (REPORT_DETAILS))
+ if (dump_kind_p (MSG_NOTE))
{
- fprintf (vect_dump, "==> vectorizing pattern def"
- " stmt: ");
- print_gimple_stmt (vect_dump, pattern_def_stmt, 0,
- TDF_SLIM);
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "==> vectorizing pattern def "
+ "stmt: ");
+ dump_gimple_stmt (MSG_NOTE, TDF_SLIM,
+ pattern_def_stmt, 0);
}
stmt = pattern_def_stmt;
@@ -5491,10 +5609,11 @@ vect_transform_loop (loop_vec_info loop_vinfo)
STMT_VINFO_VECTYPE (stmt_info));
if (!STMT_SLP_TYPE (stmt_info)
&& nunits != (unsigned int) vectorization_factor
- && vect_print_dump_info (REPORT_DETAILS))
+ && dump_kind_p (MSG_NOTE))
/* For SLP VF is set according to unrolling factor, and not to
vector size, hence for SLP this print is not valid. */
- fprintf (vect_dump, "multiple-types.");
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "multiple-types.");
/* SLP. Schedule all the SLP instances when the first SLP stmt is
reached. */
@@ -5504,8 +5623,9 @@ vect_transform_loop (loop_vec_info loop_vinfo)
{
slp_scheduled = true;
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "=== scheduling SLP instances ===");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location,
+ "=== scheduling SLP instances ===");
vect_schedule_slp (loop_vinfo, NULL);
}
@@ -5523,8 +5643,8 @@ vect_transform_loop (loop_vec_info loop_vinfo)
}
/* -------- vectorize statement ------------ */
- if (vect_print_dump_info (REPORT_DETAILS))
- fprintf (vect_dump, "transform statement.");
+ if (dump_kind_p (MSG_NOTE))
+ dump_printf_loc (MSG_NOTE, vect_location, "transform statement.");
grouped_store = false;
is_store = vect_transform_stmt (stmt, &si, &grouped_store, NULL, NULL);
@@ -5566,8 +5686,9 @@ vect_transform_loop (loop_vec_info loop_vinfo)
until all the loops have been transformed? */
update_ssa (TODO_update_ssa);
- if (vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
- fprintf (vect_dump, "LOOP VECTORIZED.");
- if (loop->inner && vect_print_dump_info (REPORT_VECTORIZED_LOCATIONS))
- fprintf (vect_dump, "OUTER LOOP VECTORIZED.");
+ if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+ dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location, "LOOP VECTORIZED.");
+ if (loop->inner && dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+ dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
+ "OUTER LOOP VECTORIZED.");
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-24 08:40:55 +0000