Skip to content

R
riscv-gcc-1
Commit c866976a by Leehod Baruch Committed by Dorit Nuzman
Options

invoke.texi (ftree-vectorizer-verbose): New. 

        * doc/invoke.texi (ftree-vectorizer-verbose): New.
        * opts.c (OPT_ftree_vectorizer_verbose_): New case for switch.
        * common.opt (ftree-vectorizer-verbose): New Flag for the vectorizer
        was added.
        * tree.h (vect_set_verbosity_level): New extern function declaration
        added.
        * tree-vectorizer.h (verbosity_levels): New enum type.
        * tree-vectorizer.c (vect_debug_stats): Function removed.
        (vect_debug_details): Likewise.
        (vect_verbosity_level): Global variable was defined and initialized.
        (vect_dump): Global variable definition.
        (vect_print_dump_info): New function.
        (vect_set_dump_settings): New function.
        (vect_set_verbosity_level): New function.
        (vectorize_loops): Add call to vect_set_dump_settings.

        (slpeel_make_loop_iterate_ntimes): Dump condition was changed.
        (slpeel_tree_duplicate_loop_to_edge_cfg): Likewise.
        (slpeel_tree_peel_loop_to_edge): Likewise.

        (vect_analyze_offset_expr): Call to vect_print_dump_info with
        appropriate verbosity level instead of call to vect_debug_details
        or vect_debug_stats.
        (vect_get_base_and_offset):
        (vect_create_addr_base_for_vector_ref):
        (get_vectype_for_scalar_type):
        (vect_create_data_ref_ptr):
        (vect_init_vector):
        (vect_get_vec_def_for_operand):
        (vect_finish_stmt_generation):
        (vectorizable_assignment):
        (vectorizable_operation):
        (vectorizable_store):
        (vectorizable_load):
        (vect_transform_stmt):
        (vect_update_ivs_after_vectorizer):
        (vect_do_peeling_for_loop_bound):
        (vect_update_inits_of_drs):
        (vect_do_peeling_for_alignment):
        (vect_transform_loop):
        (vect_is_simple_use):
        (vect_analyze_operations):
        (vect_is_simple_iv_evolution):
        (vect_analyze_scalar_cycles):
        (vect_analyze_data_ref_dependence):
        (vect_analyze_data_ref_dependences):
        (vect_compute_data_ref_alignment):
        (vect_enhance_data_refs_alignment):
        (vect_analyze_data_refs_alignment):
        (vect_analyze_data_ref_access):
        (vect_analyze_data_ref_accesses):
        (vect_analyze_pointer_ref_access):
        (vect_get_memtag_and_dr):
        (vect_analyze_data_refs):
        (vect_mark_relevant):
        (vect_stmt_relevant_p):
        (vect_mark_stmts_to_be_vectorized):
        (vect_can_advance_ivs_p):
        (vect_get_loop_niters):
        (vect_analyze_loop_form):
        (vect_analyze_loop):
        (vectorize_loops): Likewise.

        (vect_do_peeling_for_loop_bound): Dump format slightly changed.
        (vect_update_inits_of_drs):
        (vect_do_peeling_for_alignment):
        (vect_transform_loop):
        (vect_analyze_operations):
        (vect_analyze_scalar_cycles):
        (vect_analyze_data_ref_dependences):
        (vect_analyze_data_refs_alignment):
        (vect_analyze_data_ref_accesses):
        (vect_analyze_data_refs):
        (vect_mark_stmts_to_be_vectorized):
        (vect_get_loop_niters):
        (vect_analyze_loop_form):
        (vect_analyze_loop): Likewise.
        (vect_mark_stmts_to_be_vectorized): Add call to print_generic_expr.

Co-Authored-By: Dorit Naishlos <dorit@il.ibm.com>

From-SVN: r94697
parent 88ab13d6
Showing with 624 additions and 441 deletions
gcc/ChangeLog
2005-02-07 Leehod Baruch <leehod@il.ibm.com>
Dorit Naishlos <dorit@il.ibm.com>
* doc/invoke.texi (ftree-vectorizer-verbose): New.
* opts.c (OPT_ftree_vectorizer_verbose_): New case for switch.
* common.opt (ftree-vectorizer-verbose): New Flag for the vectorizer
was added.
* tree.h (vect_set_verbosity_level): New extern function declaration
added.
* tree-vectorizer.h (verbosity_levels): New enum type.
* tree-vectorizer.c (vect_debug_stats): Function removed.
(vect_debug_details): Likewise.
(vect_verbosity_level): Global variable was defined and initialized.
(vect_dump): Global variable definition.
(vect_print_dump_info): New function.
(vect_set_dump_settings): New function.
(vect_set_verbosity_level): New function.
(vectorize_loops): Add call to vect_set_dump_settings.
(slpeel_make_loop_iterate_ntimes): Dump condition was changed.
(slpeel_tree_duplicate_loop_to_edge_cfg): Likewise.
(slpeel_tree_peel_loop_to_edge): Likewise.
(vect_analyze_offset_expr): Call to vect_print_dump_info with
appropriate verbosity level instead of call to vect_debug_details
or vect_debug_stats.
(vect_get_base_and_offset):
(vect_create_addr_base_for_vector_ref):
(get_vectype_for_scalar_type):
(vect_create_data_ref_ptr):
(vect_init_vector):
(vect_get_vec_def_for_operand):
(vect_finish_stmt_generation):
(vectorizable_assignment):
(vectorizable_operation):
(vectorizable_store):
(vectorizable_load):
(vect_transform_stmt):
(vect_update_ivs_after_vectorizer):
(vect_do_peeling_for_loop_bound):
(vect_update_inits_of_drs):
(vect_do_peeling_for_alignment):
(vect_transform_loop):
(vect_is_simple_use):
(vect_analyze_operations):
(vect_is_simple_iv_evolution):
(vect_analyze_scalar_cycles):
(vect_analyze_data_ref_dependence):
(vect_analyze_data_ref_dependences):
(vect_compute_data_ref_alignment):
(vect_enhance_data_refs_alignment):
(vect_analyze_data_refs_alignment):
(vect_analyze_data_ref_access):
(vect_analyze_data_ref_accesses):
(vect_analyze_pointer_ref_access):
(vect_get_memtag_and_dr):
(vect_analyze_data_refs):
(vect_mark_relevant):
(vect_stmt_relevant_p):
(vect_mark_stmts_to_be_vectorized):
(vect_can_advance_ivs_p):
(vect_get_loop_niters):
(vect_analyze_loop_form):
(vect_analyze_loop):
(vectorize_loops): Likewise.
(vect_do_peeling_for_loop_bound): Dump format slightly changed.
(vect_update_inits_of_drs):
(vect_do_peeling_for_alignment):
(vect_transform_loop):
(vect_analyze_operations):
(vect_analyze_scalar_cycles):
(vect_analyze_data_ref_dependences):
(vect_analyze_data_refs_alignment):
(vect_analyze_data_ref_accesses):
(vect_analyze_data_refs):
(vect_mark_stmts_to_be_vectorized):
(vect_get_loop_niters):
(vect_analyze_loop_form):
(vect_analyze_loop): Likewise.
(vect_mark_stmts_to_be_vectorized): Add call to print_generic_expr.
2005-02-07 Richard Sandiford <rsandifo@redhat.com> 2005-02-07 Richard Sandiford <rsandifo@redhat.com>
PR bootstrap/19796 PR bootstrap/19796
......
gcc/common.opt
...@@ -916,6 +916,10 @@ ftree-vectorize ...@@ -916,6 +916,10 @@ ftree-vectorize
Common Report Var(flag_tree_vectorize) Common Report Var(flag_tree_vectorize)
Enable loop vectorization on trees Enable loop vectorization on trees
ftree-vectorizer-verbose=
Common RejectNegative Joined
-ftree-vectorizer-verbose=<number> Set the verbosity level of the vectorizer
; -fverbose-asm causes extra commentary information to be produced in ; -fverbose-asm causes extra commentary information to be produced in
; the generated assembly code (to make it more readable). This option ; the generated assembly code (to make it more readable). This option
; is generally only of use to those who actually need to read the ; is generally only of use to those who actually need to read the
......
gcc/doc/invoke.texi
...@@ -266,6 +266,7 @@ Objective-C and Objective-C++ Dialects}. ...@@ -266,6 +266,7 @@ Objective-C and Objective-C++ Dialects}.
-fdump-tree-nrv -fdump-tree-vect @gol -fdump-tree-nrv -fdump-tree-vect @gol
-fdump-tree-sra@r{[}-@var{n}@r{]} @gol -fdump-tree-sra@r{[}-@var{n}@r{]} @gol
-fdump-tree-fre@r{[}-@var{n}@r{]} @gol -fdump-tree-fre@r{[}-@var{n}@r{]} @gol
-ftree-vectorizer-verbose=@var{n} @gol
-feliminate-dwarf2-dups -feliminate-unused-debug-types @gol -feliminate-dwarf2-dups -feliminate-unused-debug-types @gol
-feliminate-unused-debug-symbols -fmem-report -fprofile-arcs -ftree-based-profiling @gol -feliminate-unused-debug-symbols -fmem-report -fprofile-arcs -ftree-based-profiling @gol
-frandom-seed=@var{string} -fsched-verbose=@var{n} @gol -frandom-seed=@var{string} -fsched-verbose=@var{n} @gol
...@@ -3882,6 +3883,13 @@ made by appending @file{.vect} to the source file name. ...@@ -3882,6 +3883,13 @@ made by appending @file{.vect} to the source file name.
Enable all the available tree dumps with the flags provided in this option. Enable all the available tree dumps with the flags provided in this option.
@end table @end table
@item -ftree-vectorizer-verbose=@var{n}
@opindex ftree-vectorizer-verbose
This option controls the amount of debugging output the vectorizer prints.
This information is written to standard error, unless @option{-fdump-tree-all}
or @option{-fdump-tree-vect} is specified, in which case it is output to the
usual dump listing file, @file{.vect}.
@item -frandom-seed=@var{string} @item -frandom-seed=@var{string}
@opindex frandom-string @opindex frandom-string
This option provides a seed that GCC uses when it would otherwise use This option provides a seed that GCC uses when it would otherwise use
......
gcc/opts.c
...@@ -945,6 +945,10 @@ common_handle_option (size_t scode, const char *arg, int value) ...@@ -945,6 +945,10 @@ common_handle_option (size_t scode, const char *arg, int value)
stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg)); stack_limit_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (arg));
break; break;
case OPT_ftree_vectorizer_verbose_:
vect_set_verbosity_level (arg);
break;
case OPT_ftls_model_: case OPT_ftls_model_:
if (!strcmp (arg, "global-dynamic")) if (!strcmp (arg, "global-dynamic"))
flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC; flag_tls_default = TLS_MODEL_GLOBAL_DYNAMIC;
......
gcc/testsuite/ChangeLog
2005-02-07 Leehod Baruch <leehod@il.ibm.com>
Dorit Naishlos <dorit@il.ibm.com>
* testsuite/gcc.dg/vect/vect.exp: Add -ftree-vectorizer-verbose=3.
2005-02-06 Richard Sandiford <rsandifo@redhat.com> 2005-02-06 Richard Sandiford <rsandifo@redhat.com>
* gcc.c-torture/compile/20050206-1.c: New test. * gcc.c-torture/compile/20050206-1.c: New test.
......
gcc/testsuite/gcc.dg/vect/vect.exp
...@@ -23,7 +23,8 @@ load_lib gcc-dg.exp ...@@ -23,7 +23,8 @@ load_lib gcc-dg.exp
set DEFAULT_VECTCFLAGS "" set DEFAULT_VECTCFLAGS ""
# These flags are used for all targets. # These flags are used for all targets.
lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" "-fdump-tree-vect-stats" lappend DEFAULT_VECTCFLAGS "-O2" "-ftree-vectorize" \
"-ftree-vectorizer-verbose=3" "-fdump-tree-vect-stats"
# If the target system supports vector instructions, the default action # If the target system supports vector instructions, the default action
# for a test is 'run', otherwise it's 'compile'. Save current default. # for a test is 'run', otherwise it's 'compile'. Save current default.
......
gcc/tree-vectorizer.c
...@@ -271,9 +271,18 @@ stmt_vec_info new_stmt_vec_info (tree, loop_vec_info); ...@@ -271,9 +271,18 @@ stmt_vec_info new_stmt_vec_info (tree, loop_vec_info);
Vectorization Debug Information. Vectorization Debug Information.
*************************************************************************/ *************************************************************************/
/* vect_verbosity_level set to invalid verbosity level to mark that it's
uninitialized. */
enum verbosity_levels vect_verbosity_level = MAX_VERBOSITY_LEVEL;
/* vect_dump will be set to stderr or dump_file if exist. */
FILE *vect_dump;
/* Utilities for output formatting. */ /* Utilities for output formatting. */
static bool vect_debug_stats (LOC); static bool vect_print_dump_info (enum verbosity_levels, LOC);
static bool vect_debug_details (LOC); static void vect_set_dump_settings (void);
void vect_set_verbosity_level (const char *);
/************************************************************************* /*************************************************************************
...@@ -708,8 +717,13 @@ slpeel_make_loop_iterate_ntimes (struct loop *loop, tree niters) ...@@ -708,8 +717,13 @@ slpeel_make_loop_iterate_ntimes (struct loop *loop, tree niters)
bsi_remove (&loop_cond_bsi); bsi_remove (&loop_cond_bsi);
loop_loc = find_loop_location (loop); loop_loc = find_loop_location (loop);
if (vect_debug_details (loop_loc)) if (dump_file && (dump_flags & TDF_DETAILS))
{
if (loop_loc != UNKNOWN_LOC)
fprintf (dump_file, "\nloop at %s:%d: ",
LOC_FILE (loop_loc), LOC_LINE (loop_loc));
print_generic_expr (dump_file, cond_stmt, TDF_SLIM); print_generic_expr (dump_file, cond_stmt, TDF_SLIM);
}
loop->nb_iterations = niters; loop->nb_iterations = niters;
} }
...@@ -1003,9 +1017,13 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loops *loops, ...@@ -1003,9 +1017,13 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loops *loops,
if (!(new_loop = slpeel_tree_duplicate_loop_to_edge_cfg (loop, loops, e))) if (!(new_loop = slpeel_tree_duplicate_loop_to_edge_cfg (loop, loops, e)))
{ {
loop_loc = find_loop_location (loop); loop_loc = find_loop_location (loop);
if (vect_debug_stats (loop_loc) if (dump_file && (dump_flags & TDF_DETAILS))
|| vect_debug_details (loop_loc)) {
if (loop_loc != UNKNOWN_LOC)
fprintf (dump_file, "\n%s:%d: note: ",
LOC_FILE (loop_loc), LOC_LINE (loop_loc));
fprintf (dump_file, "tree_duplicate_loop_to_edge_cfg failed.\n"); fprintf (dump_file, "tree_duplicate_loop_to_edge_cfg failed.\n");
}
return NULL; return NULL;
} }
...@@ -1160,6 +1178,83 @@ find_loop_location (struct loop *loop) ...@@ -1160,6 +1178,83 @@ find_loop_location (struct loop *loop)
} }
/*************************************************************************
Vectorization Debug Information.
*************************************************************************/
/* Function vect_set_verbosity_level.
Called from toplev.c upon detection of the
-ftree-vectorizer-verbose=N option. */
void
vect_set_verbosity_level (const char *val)
{
unsigned int vl;
vl = atoi (val);
if (vl < MAX_VERBOSITY_LEVEL)
vect_verbosity_level = vl;
else
vect_verbosity_level = MAX_VERBOSITY_LEVEL - 1;
}
/* Function vect_set_dump_settings.
Fix the verbosity level of the vectorizer if the
requested level was not set explicitly using the flag
-ftree-vectorizer-verbose=N.
Decide where to print the debugging information (dump_file/stderr).
If the user defined the verbosity level, but there is no dump file,
print to stderr, otherwise print to the dump file. */
static void
vect_set_dump_settings (void)
{
vect_dump = dump_file;
/* Check if the verbosity level was defined by the user: */
if (vect_verbosity_level != MAX_VERBOSITY_LEVEL)
{
/* If there is no dump file, print to stderr. */
if (!dump_file)
vect_dump = stderr;
return;
}
/* User didn't specify verbosity level: */
if (dump_flags & TDF_DETAILS)
vect_verbosity_level = REPORT_DETAILS;
else if (dump_flags & TDF_STATS)
vect_verbosity_level = REPORT_UNVECTORIZED_LOOPS;
else
vect_verbosity_level = REPORT_NONE;
}
/* Function debug_loop_details.
For vectorization debug dumps. */
static bool
vect_print_dump_info (enum verbosity_levels vl, LOC loc)
{
if (vl > vect_verbosity_level)
return false;
if (loc == UNKNOWN_LOC)
fprintf (vect_dump, "\n%s:%d: note: ",
DECL_SOURCE_FILE (current_function_decl),
DECL_SOURCE_LINE (current_function_decl));
else
fprintf (vect_dump, "\n%s:%d: note: ", LOC_FILE (loc), LOC_LINE (loc));
return true;
}
/* Here the proper Vectorizer starts. */ /* Here the proper Vectorizer starts. */
...@@ -1288,46 +1383,6 @@ destroy_loop_vec_info (loop_vec_info loop_vinfo) ...@@ -1288,46 +1383,6 @@ destroy_loop_vec_info (loop_vec_info loop_vinfo)
} }
/* Function debug_loop_stats.
For vectorization statistics dumps. */
static bool
vect_debug_stats (LOC loc)
{
if (!dump_file || !(dump_flags & TDF_STATS))
return false;
if (loc == UNKNOWN_LOC)
fprintf (dump_file, "\n");
else
fprintf (dump_file, "\nloop at %s:%d: ",
LOC_FILE (loc), LOC_LINE (loc));
return true;
}
/* Function debug_loop_details.
For vectorization debug dumps. */
static bool
vect_debug_details (LOC loc)
{
if (!dump_file || !(dump_flags & TDF_DETAILS))
return false;
if (loc == UNKNOWN_LOC)
fprintf (dump_file, "\n");
else
fprintf (dump_file, "\nloop at %s:%d: ",
LOC_FILE (loc), LOC_LINE (loc));
return true;
}
/* Function vect_get_ptr_offset /* Function vect_get_ptr_offset
Compute the OFFSET modulo vector-type alignment of pointer REF in bits. */ Compute the OFFSET modulo vector-type alignment of pointer REF in bits. */
...@@ -1477,10 +1532,10 @@ vect_analyze_offset_expr (tree expr, ...@@ -1477,10 +1532,10 @@ vect_analyze_offset_expr (tree expr,
if (!BINARY_CLASS_P (expr)) if (!BINARY_CLASS_P (expr))
{ {
/* We expect to get binary expressions (PLUS/MINUS and MULT). */ /* We expect to get binary expressions (PLUS/MINUS and MULT). */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Not binary expression "); fprintf (vect_dump, "Not binary expression ");
print_generic_expr (dump_file, expr, TDF_SLIM); print_generic_expr (vect_dump, expr, TDF_SLIM);
} }
return false; return false;
} }
...@@ -1722,8 +1777,8 @@ vect_get_base_and_offset (struct data_reference *dr, ...@@ -1722,8 +1777,8 @@ vect_get_base_and_offset (struct data_reference *dr,
/* Check that there is no remainder in bits. */ /* Check that there is no remainder in bits. */
if (pbitpos%BITS_PER_UNIT) if (pbitpos%BITS_PER_UNIT)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "bit offset alignment."); fprintf (vect_dump, "bit offset alignment.");
return NULL_TREE; return NULL_TREE;
} }
this_offset = size_binop (PLUS_EXPR, bit_pos_in_bytes, this_offset = size_binop (PLUS_EXPR, bit_pos_in_bytes,
...@@ -1751,15 +1806,15 @@ vect_get_base_and_offset (struct data_reference *dr, ...@@ -1751,15 +1806,15 @@ vect_get_base_and_offset (struct data_reference *dr,
*initial_offset = size_binop (PLUS_EXPR, *initial_offset, this_offset); *initial_offset = size_binop (PLUS_EXPR, *initial_offset, this_offset);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
print_generic_expr (dump_file, expr, TDF_SLIM); print_generic_expr (vect_dump, expr, TDF_SLIM);
fprintf (dump_file, "\n --> total offset for ref: "); fprintf (vect_dump, "\n --> total offset for ref: ");
print_generic_expr (dump_file, *initial_offset, TDF_SLIM); print_generic_expr (vect_dump, *initial_offset, TDF_SLIM);
fprintf (dump_file, "\n --> total misalign for ref: "); fprintf (vect_dump, "\n --> total misalign for ref: ");
print_generic_expr (dump_file, *misalign, TDF_SLIM); print_generic_expr (vect_dump, *misalign, TDF_SLIM);
fprintf (dump_file, "\n --> total step for ref: "); fprintf (vect_dump, "\n --> total step for ref: ");
print_generic_expr (dump_file, *step, TDF_SLIM); print_generic_expr (vect_dump, *step, TDF_SLIM);
} }
} }
return base; return base;
...@@ -1972,11 +2027,10 @@ vect_create_addr_base_for_vector_ref (tree stmt, ...@@ -1972,11 +2027,10 @@ vect_create_addr_base_for_vector_ref (tree stmt,
TREE_OPERAND (vec_stmt, 0) = new_temp; TREE_OPERAND (vec_stmt, 0) = new_temp;
append_to_statement_list_force (vec_stmt, new_stmt_list); append_to_statement_list_force (vec_stmt, new_stmt_list);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "created "); fprintf (vect_dump, "created ");
print_generic_expr (dump_file, vec_stmt, TDF_SLIM); print_generic_expr (vect_dump, vec_stmt, TDF_SLIM);
fprintf (dump_file, "\n");
} }
return new_temp; return new_temp;
} }
...@@ -2003,19 +2057,19 @@ get_vectype_for_scalar_type (tree scalar_type) ...@@ -2003,19 +2057,19 @@ get_vectype_for_scalar_type (tree scalar_type)
nunits = UNITS_PER_SIMD_WORD / nbytes; nunits = UNITS_PER_SIMD_WORD / nbytes;
vectype = build_vector_type (scalar_type, nunits); vectype = build_vector_type (scalar_type, nunits);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "get vectype with %d units of type ", nunits); fprintf (vect_dump, "get vectype with %d units of type ", nunits);
print_generic_expr (dump_file, scalar_type, TDF_SLIM); print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
} }
if (!vectype) if (!vectype)
return NULL_TREE; return NULL_TREE;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "vectype: "); fprintf (vect_dump, "vectype: ");
print_generic_expr (dump_file, vectype, TDF_SLIM); print_generic_expr (vect_dump, vectype, TDF_SLIM);
} }
if (!VECTOR_MODE_P (TYPE_MODE (vectype))) if (!VECTOR_MODE_P (TYPE_MODE (vectype)))
...@@ -2023,8 +2077,8 @@ get_vectype_for_scalar_type (tree scalar_type) ...@@ -2023,8 +2077,8 @@ get_vectype_for_scalar_type (tree scalar_type)
/* TODO: tree-complex.c sometimes can parallelize operations /* TODO: tree-complex.c sometimes can parallelize operations
on generic vectors. We can vectorize the loop in that case, on generic vectors. We can vectorize the loop in that case,
but then we should re-run the lowering pass. */ but then we should re-run the lowering pass. */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "mode not supported by target."); fprintf (vect_dump, "mode not supported by target.");
return NULL_TREE; return NULL_TREE;
} }
...@@ -2127,20 +2181,20 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset, ...@@ -2127,20 +2181,20 @@ vect_create_data_ref_ptr (tree stmt, block_stmt_iterator *bsi, tree offset,
tree type, tmp, size; tree type, tmp, size;
base_name = unshare_expr (DR_BASE_NAME (dr)); base_name = unshare_expr (DR_BASE_NAME (dr));
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
tree data_ref_base = base_name; tree data_ref_base = base_name;
fprintf (dump_file, "create array_ref of type: "); fprintf (vect_dump, "create array_ref of type: ");
print_generic_expr (dump_file, vectype, TDF_SLIM); print_generic_expr (vect_dump, vectype, TDF_SLIM);
if (TREE_CODE (data_ref_base) == VAR_DECL) if (TREE_CODE (data_ref_base) == VAR_DECL)
fprintf (dump_file, "\nvectorizing a one dimensional array ref: "); fprintf (vect_dump, " vectorizing a one dimensional array ref: ");
else if (TREE_CODE (data_ref_base) == ARRAY_REF) else if (TREE_CODE (data_ref_base) == ARRAY_REF)
fprintf (dump_file, "\nvectorizing a multidimensional array ref: "); fprintf (vect_dump, " vectorizing a multidimensional array ref: ");
else if (TREE_CODE (data_ref_base) == COMPONENT_REF) else if (TREE_CODE (data_ref_base) == COMPONENT_REF)
fprintf (dump_file, "\nvectorizing a record based array ref: "); fprintf (vect_dump, " vectorizing a record based array ref: ");
else if (TREE_CODE (data_ref_base) == SSA_NAME) else if (TREE_CODE (data_ref_base) == SSA_NAME)
fprintf (dump_file, "\nvectorizing a pointer ref: "); fprintf (vect_dump, " vectorizing a pointer ref: ");
print_generic_expr (dump_file, base_name, TDF_SLIM); print_generic_expr (vect_dump, base_name, TDF_SLIM);
} }
/** (1) Create the new vector-pointer variable: **/ /** (1) Create the new vector-pointer variable: **/
...@@ -2294,10 +2348,10 @@ vect_init_vector (tree stmt, tree vector_var) ...@@ -2294,10 +2348,10 @@ vect_init_vector (tree stmt, tree vector_var)
new_bb = bsi_insert_on_edge_immediate (pe, init_stmt); new_bb = bsi_insert_on_edge_immediate (pe, init_stmt);
gcc_assert (!new_bb); gcc_assert (!new_bb);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "created new init_stmt: "); fprintf (vect_dump, "created new init_stmt: ");
print_generic_expr (dump_file, init_stmt, TDF_SLIM); print_generic_expr (vect_dump, init_stmt, TDF_SLIM);
} }
vec_oprnd = TREE_OPERAND (init_stmt, 0); vec_oprnd = TREE_OPERAND (init_stmt, 0);
...@@ -2334,10 +2388,10 @@ vect_get_vec_def_for_operand (tree op, tree stmt) ...@@ -2334,10 +2388,10 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
tree def; tree def;
int i; int i;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "vect_get_vec_def_for_operand: "); fprintf (vect_dump, "vect_get_vec_def_for_operand: ");
print_generic_expr (dump_file, op, TDF_SLIM); print_generic_expr (vect_dump, op, TDF_SLIM);
} }
/** ===> Case 1: operand is a constant. **/ /** ===> Case 1: operand is a constant. **/
...@@ -2349,8 +2403,8 @@ vect_get_vec_def_for_operand (tree op, tree stmt) ...@@ -2349,8 +2403,8 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
tree vec_cst; tree vec_cst;
/* Build a tree with vector elements. */ /* Build a tree with vector elements. */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "Create vector_cst. nunits = %d", nunits); fprintf (vect_dump, "Create vector_cst. nunits = %d", nunits);
for (i = nunits - 1; i >= 0; --i) for (i = nunits - 1; i >= 0; --i)
{ {
...@@ -2367,10 +2421,10 @@ vect_get_vec_def_for_operand (tree op, tree stmt) ...@@ -2367,10 +2421,10 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
def_stmt = SSA_NAME_DEF_STMT (op); def_stmt = SSA_NAME_DEF_STMT (op);
def_stmt_info = vinfo_for_stmt (def_stmt); def_stmt_info = vinfo_for_stmt (def_stmt);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "vect_get_vec_def_for_operand: def_stmt: "); fprintf (vect_dump, "vect_get_vec_def_for_operand: def_stmt: ");
print_generic_expr (dump_file, def_stmt, TDF_SLIM); print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
} }
...@@ -2393,8 +2447,8 @@ vect_get_vec_def_for_operand (tree op, tree stmt) ...@@ -2393,8 +2447,8 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
bb = bb_for_stmt (def_stmt); bb = bb_for_stmt (def_stmt);
if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb)) if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "reduction/induction - unsupported."); fprintf (vect_dump, "reduction/induction - unsupported.");
internal_error ("no support for reduction/induction"); /* FORNOW */ internal_error ("no support for reduction/induction"); /* FORNOW */
} }
...@@ -2416,18 +2470,19 @@ vect_get_vec_def_for_operand (tree op, tree stmt) ...@@ -2416,18 +2470,19 @@ vect_get_vec_def_for_operand (tree op, tree stmt)
def = op; def = op;
break; break;
default: default:
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "unsupported defining stmt: "); fprintf (vect_dump, "unsupported defining stmt: ");
print_generic_expr (dump_file, def_stmt, TDF_SLIM); print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
} }
internal_error ("unsupported defining stmt"); internal_error ("unsupported defining stmt");
} }
/* Build a tree with vector elements. Create 'vec_inv = {inv,inv,..,inv}' */ /* Build a tree with vector elements.
Create 'vec_inv = {inv,inv,..,inv}' */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "Create vector_inv."); fprintf (vect_dump, "Create vector_inv.");
for (i = nunits - 1; i >= 0; --i) for (i = nunits - 1; i >= 0; --i)
{ {
...@@ -2448,10 +2503,10 @@ vect_finish_stmt_generation (tree stmt, tree vec_stmt, block_stmt_iterator *bsi) ...@@ -2448,10 +2503,10 @@ vect_finish_stmt_generation (tree stmt, tree vec_stmt, block_stmt_iterator *bsi)
{ {
bsi_insert_before (bsi, vec_stmt, BSI_SAME_STMT); bsi_insert_before (bsi, vec_stmt, BSI_SAME_STMT);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "add new stmt: "); fprintf (vect_dump, "add new stmt: ");
print_generic_expr (dump_file, vec_stmt, TDF_SLIM); print_generic_expr (vect_dump, vec_stmt, TDF_SLIM);
} }
#ifdef ENABLE_CHECKING #ifdef ENABLE_CHECKING
...@@ -2498,8 +2553,8 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2498,8 +2553,8 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
op = TREE_OPERAND (stmt, 1); op = TREE_OPERAND (stmt, 1);
if (!vect_is_simple_use (op, loop_vinfo, NULL)) if (!vect_is_simple_use (op, loop_vinfo, NULL))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "use not simple."); fprintf (vect_dump, "use not simple.");
return false; return false;
} }
...@@ -2510,8 +2565,8 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2510,8 +2565,8 @@ vectorizable_assignment (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
} }
/** Transform. **/ /** Transform. **/
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "transform assignment."); fprintf (vect_dump, "transform assignment.");
/* Handle def. */ /* Handle def. */
vec_dest = vect_create_destination_var (scalar_dest, vectype); vec_dest = vect_create_destination_var (scalar_dest, vectype);
...@@ -2571,8 +2626,8 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2571,8 +2626,8 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
op_type = TREE_CODE_LENGTH (code); op_type = TREE_CODE_LENGTH (code);
if (op_type != unary_op && op_type != binary_op) if (op_type != unary_op && op_type != binary_op)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "num. args = %d (not unary/binary op).", op_type); fprintf (vect_dump, "num. args = %d (not unary/binary op).", op_type);
return false; return false;
} }
...@@ -2581,8 +2636,8 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2581,8 +2636,8 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
op = TREE_OPERAND (operation, i); op = TREE_OPERAND (operation, i);
if (!vect_is_simple_use (op, loop_vinfo, NULL)) if (!vect_is_simple_use (op, loop_vinfo, NULL))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "use not simple."); fprintf (vect_dump, "use not simple.");
return false; return false;
} }
} }
...@@ -2590,15 +2645,15 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2590,15 +2645,15 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
/* Supportable by target? */ /* Supportable by target? */
if (!optab) if (!optab)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "no optab."); fprintf (vect_dump, "no optab.");
return false; return false;
} }
vec_mode = TYPE_MODE (vectype); vec_mode = TYPE_MODE (vectype);
if (optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing) if (optab->handlers[(int) vec_mode].insn_code == CODE_FOR_nothing)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "op not supported by target."); fprintf (vect_dump, "op not supported by target.");
return false; return false;
} }
...@@ -2610,8 +2665,8 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2610,8 +2665,8 @@ vectorizable_operation (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
/** Transform. **/ /** Transform. **/
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "transform binary/unary operation."); fprintf (vect_dump, "transform binary/unary operation.");
/* Handle def. */ /* Handle def. */
scalar_dest = TREE_OPERAND (stmt, 0); scalar_dest = TREE_OPERAND (stmt, 0);
...@@ -2679,8 +2734,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2679,8 +2734,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
op = TREE_OPERAND (stmt, 1); op = TREE_OPERAND (stmt, 1);
if (!vect_is_simple_use (op, loop_vinfo, NULL)) if (!vect_is_simple_use (op, loop_vinfo, NULL))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "use not simple."); fprintf (vect_dump, "use not simple.");
return false; return false;
} }
...@@ -2702,8 +2757,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2702,8 +2757,8 @@ vectorizable_store (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
/** Transform. **/ /** Transform. **/
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "transform store"); fprintf (vect_dump, "transform store");
alignment_support_cheme = vect_supportable_dr_alignment (dr); alignment_support_cheme = vect_supportable_dr_alignment (dr);
gcc_assert (alignment_support_cheme); gcc_assert (alignment_support_cheme);
...@@ -2777,8 +2832,8 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2777,8 +2832,8 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
(e.g. - data copies). */ (e.g. - data copies). */
if (mov_optab->handlers[mode].insn_code == CODE_FOR_nothing) if (mov_optab->handlers[mode].insn_code == CODE_FOR_nothing)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "Aligned load, but unsupported type."); fprintf (vect_dump, "Aligned load, but unsupported type.");
return false; return false;
} }
...@@ -2790,8 +2845,8 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt) ...@@ -2790,8 +2845,8 @@ vectorizable_load (tree stmt, block_stmt_iterator *bsi, tree *vec_stmt)
/** Transform. **/ /** Transform. **/
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "transform load."); fprintf (vect_dump, "transform load.");
alignment_support_cheme = vect_supportable_dr_alignment (dr); alignment_support_cheme = vect_supportable_dr_alignment (dr);
gcc_assert (alignment_support_cheme); gcc_assert (alignment_support_cheme);
...@@ -2997,8 +3052,8 @@ vect_transform_stmt (tree stmt, block_stmt_iterator *bsi) ...@@ -2997,8 +3052,8 @@ vect_transform_stmt (tree stmt, block_stmt_iterator *bsi)
is_store = true; is_store = true;
break; break;
default: default:
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "stmt not supported."); fprintf (vect_dump, "stmt not supported.");
gcc_unreachable (); gcc_unreachable ();
} }
...@@ -3170,8 +3225,8 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, tree niters, ...@@ -3170,8 +3225,8 @@ vect_update_ivs_after_vectorizer (loop_vec_info loop_vinfo, tree niters,
/* Skip virtual phi's. */ /* Skip virtual phi's. */
if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi)))) if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "virtual phi. skip."); fprintf (vect_dump, "virtual phi. skip.");
continue; continue;
} }
...@@ -3234,8 +3289,8 @@ vect_do_peeling_for_loop_bound (loop_vec_info loop_vinfo, tree *ratio, ...@@ -3234,8 +3289,8 @@ vect_do_peeling_for_loop_bound (loop_vec_info loop_vinfo, tree *ratio,
int loop_num; int loop_num;
#endif #endif
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_transtorm_for_unknown_loop_bound>>\n"); fprintf (vect_dump, "=== vect_transtorm_for_unknown_loop_bound ===");
/* Generate the following variables on the preheader of original loop: /* Generate the following variables on the preheader of original loop:
...@@ -3403,8 +3458,8 @@ vect_update_inits_of_drs (loop_vec_info loop_vinfo, tree niters) ...@@ -3403,8 +3458,8 @@ vect_update_inits_of_drs (loop_vec_info loop_vinfo, tree niters)
varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo); varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo); varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
if (dump_file && (dump_flags & TDF_DETAILS)) if (vect_dump && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "\n<<vect_update_inits_of_dr>>\n"); fprintf (vect_dump, "=== vect_update_inits_of_dr ===");
for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++) for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
{ {
...@@ -3436,8 +3491,8 @@ vect_do_peeling_for_alignment (loop_vec_info loop_vinfo, struct loops *loops) ...@@ -3436,8 +3491,8 @@ vect_do_peeling_for_alignment (loop_vec_info loop_vinfo, struct loops *loops)
tree n_iters; tree n_iters;
struct loop *new_loop; struct loop *new_loop;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_do_peeling_for_alignment>>\n"); fprintf (vect_dump, "=== vect_do_peeling_for_alignment ===");
ni_name = vect_build_loop_niters (loop_vinfo); ni_name = vect_build_loop_niters (loop_vinfo);
niters_of_prolog_loop = vect_gen_niters_for_prolog_loop (loop_vinfo, ni_name); niters_of_prolog_loop = vect_gen_niters_for_prolog_loop (loop_vinfo, ni_name);
...@@ -3484,8 +3539,8 @@ vect_transform_loop (loop_vec_info loop_vinfo, ...@@ -3484,8 +3539,8 @@ vect_transform_loop (loop_vec_info loop_vinfo,
tree ratio = NULL; tree ratio = NULL;
int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo); int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vec_transform_loop>>\n"); fprintf (vect_dump, "=== vec_transform_loop ===");
/* Peel the loop if there are data refs with unknown alignment. /* Peel the loop if there are data refs with unknown alignment.
...@@ -3533,10 +3588,10 @@ vect_transform_loop (loop_vec_info loop_vinfo, ...@@ -3533,10 +3588,10 @@ vect_transform_loop (loop_vec_info loop_vinfo,
stmt_vec_info stmt_info; stmt_vec_info stmt_info;
bool is_store; bool is_store;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "------>vectorizing statement: "); fprintf (vect_dump, "------>vectorizing statement: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
stmt_info = vinfo_for_stmt (stmt); stmt_info = vinfo_for_stmt (stmt);
gcc_assert (stmt_info); gcc_assert (stmt_info);
...@@ -3553,8 +3608,8 @@ vect_transform_loop (loop_vec_info loop_vinfo, ...@@ -3553,8 +3608,8 @@ vect_transform_loop (loop_vec_info loop_vinfo,
== vectorization_factor); == vectorization_factor);
#endif #endif
/* -------- vectorize statement ------------ */ /* -------- vectorize statement ------------ */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "transform statement."); fprintf (vect_dump, "transform statement.");
is_store = vect_transform_stmt (stmt, &si); is_store = vect_transform_stmt (stmt, &si);
if (is_store) if (is_store)
...@@ -3573,10 +3628,8 @@ vect_transform_loop (loop_vec_info loop_vinfo, ...@@ -3573,10 +3628,8 @@ vect_transform_loop (loop_vec_info loop_vinfo,
slpeel_make_loop_iterate_ntimes (loop, ratio); slpeel_make_loop_iterate_ntimes (loop, ratio);
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_VECTORIZED_LOOPS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file,"Success! loop vectorized."); fprintf (vect_dump, "LOOP VECTORIZED.");
if (vect_debug_stats (LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "LOOP VECTORIZED.");
} }
...@@ -3612,8 +3665,8 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, tree *def) ...@@ -3612,8 +3665,8 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, tree *def)
def_stmt = SSA_NAME_DEF_STMT (operand); def_stmt = SSA_NAME_DEF_STMT (operand);
if (def_stmt == NULL_TREE ) if (def_stmt == NULL_TREE )
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "no def_stmt."); fprintf (vect_dump, "no def_stmt.");
return false; return false;
} }
...@@ -3624,10 +3677,10 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, tree *def) ...@@ -3624,10 +3677,10 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, tree *def)
tree arg = TREE_OPERAND (def_stmt, 0); tree arg = TREE_OPERAND (def_stmt, 0);
if (TREE_CODE (arg) == INTEGER_CST || TREE_CODE (arg) == REAL_CST) if (TREE_CODE (arg) == INTEGER_CST || TREE_CODE (arg) == REAL_CST)
return true; return true;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Unexpected empty stmt: "); fprintf (vect_dump, "Unexpected empty stmt: ");
print_generic_expr (dump_file, def_stmt, TDF_SLIM); print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
} }
return false; return false;
} }
...@@ -3637,8 +3690,8 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, tree *def) ...@@ -3637,8 +3690,8 @@ vect_is_simple_use (tree operand, loop_vec_info loop_vinfo, tree *def)
bb = bb_for_stmt (def_stmt); bb = bb_for_stmt (def_stmt);
if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb)) if (TREE_CODE (def_stmt) == PHI_NODE && flow_bb_inside_loop_p (loop, bb))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "reduction/induction - unsupported."); fprintf (vect_dump, "reduction/induction - unsupported.");
return false; /* FORNOW: not supported yet. */ return false; /* FORNOW: not supported yet. */
} }
...@@ -3671,8 +3724,8 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3671,8 +3724,8 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
bool ok; bool ok;
tree scalar_type; tree scalar_type;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_analyze_operations>>\n"); fprintf (vect_dump, "=== vect_analyze_operations ===");
for (i = 0; i < nbbs; i++) for (i = 0; i < nbbs; i++)
{ {
...@@ -3685,10 +3738,10 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3685,10 +3738,10 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
stmt_vec_info stmt_info = vinfo_for_stmt (stmt); stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
tree vectype; tree vectype;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "==> examining statement: "); fprintf (vect_dump, "==> examining statement: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
gcc_assert (stmt_info); gcc_assert (stmt_info);
...@@ -3702,18 +3755,18 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3702,18 +3755,18 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
if (!STMT_VINFO_RELEVANT_P (stmt_info)) if (!STMT_VINFO_RELEVANT_P (stmt_info))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "irrelevant."); fprintf (vect_dump, "irrelevant.");
continue; continue;
} }
if (VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt)))) if (VECTOR_MODE_P (TYPE_MODE (TREE_TYPE (stmt))))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, "not vectorized: vector stmt in loop:"); fprintf (vect_dump, "not vectorized: vector stmt in loop:");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return false; return false;
} }
...@@ -3725,28 +3778,29 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3725,28 +3778,29 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
else else
scalar_type = TREE_TYPE (stmt); scalar_type = TREE_TYPE (stmt);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "get vectype for scalar type: "); fprintf (vect_dump, "get vectype for scalar type: ");
print_generic_expr (dump_file, scalar_type, TDF_SLIM); print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
} }
vectype = get_vectype_for_scalar_type (scalar_type); vectype = get_vectype_for_scalar_type (scalar_type);
if (!vectype) if (!vectype)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, "not vectorized: unsupported data-type "); fprintf (vect_dump,
print_generic_expr (dump_file, scalar_type, TDF_SLIM); "not vectorized: unsupported data-type ");
print_generic_expr (vect_dump, scalar_type, TDF_SLIM);
} }
return false; return false;
} }
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "vectype: "); fprintf (vect_dump, "vectype: ");
print_generic_expr (dump_file, vectype, TDF_SLIM); print_generic_expr (vect_dump, vectype, TDF_SLIM);
} }
STMT_VINFO_VECTYPE (stmt_info) = vectype; STMT_VINFO_VECTYPE (stmt_info) = vectype;
...@@ -3757,18 +3811,18 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3757,18 +3811,18 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
if (!ok) if (!ok)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, "not vectorized: stmt not supported: "); fprintf (vect_dump, "not vectorized: stmt not supported: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return false; return false;
} }
nunits = GET_MODE_NUNITS (TYPE_MODE (vectype)); nunits = GET_MODE_NUNITS (TYPE_MODE (vectype));
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "nunits = %d", nunits); fprintf (vect_dump, "nunits = %d", nunits);
if (vectorization_factor) if (vectorization_factor)
{ {
...@@ -3776,9 +3830,9 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3776,9 +3830,9 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
This restriction will be relaxed in the future. */ This restriction will be relaxed in the future. */
if (nunits != vectorization_factor) if (nunits != vectorization_factor)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: mixed data-types"); fprintf (vect_dump, "not vectorized: mixed data-types");
return false; return false;
} }
} }
...@@ -3796,46 +3850,47 @@ vect_analyze_operations (loop_vec_info loop_vinfo) ...@@ -3796,46 +3850,47 @@ vect_analyze_operations (loop_vec_info loop_vinfo)
if (vectorization_factor <= 1) if (vectorization_factor <= 1)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unsupported data-type"); fprintf (vect_dump, "not vectorized: unsupported data-type");
return false; return false;
} }
LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor; LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
&& vect_debug_details (UNKNOWN_LOC)) && vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, fprintf (vect_dump,
"vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC, "vectorization_factor = %d, niters = " HOST_WIDE_INT_PRINT_DEC,
vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo)); vectorization_factor, LOOP_VINFO_INT_NITERS (loop_vinfo));
if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
&& LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor) && LOOP_VINFO_INT_NITERS (loop_vinfo) < vectorization_factor)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: iteration count too small."); fprintf (vect_dump, "not vectorized: iteration count too small.");
return false; return false;
} }
if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
|| LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0) || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
|| vect_debug_details (LOOP_LOC (loop_vinfo))) fprintf (vect_dump, "epilog loop required.");
fprintf (dump_file, "epilog loop required.");
if (!vect_can_advance_ivs_p (loop_vinfo)) if (!vect_can_advance_ivs_p (loop_vinfo))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: can't create epilog loop 1."); fprintf (vect_dump,
"not vectorized: can't create epilog loop 1.");
return false; return false;
} }
if (!slpeel_can_duplicate_loop_p (loop, loop->exit_edges[0])) if (!slpeel_can_duplicate_loop_p (loop, loop->exit_edges[0]))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: can't create epilog loop 2."); fprintf (vect_dump,
"not vectorized: can't create epilog loop 2.");
return false; return false;
} }
} }
...@@ -3914,14 +3969,15 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init, ...@@ -3914,14 +3969,15 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init,
return false; return false;
step_expr = evolution_part; step_expr = evolution_part;
init_expr = unshare_expr (initial_condition_in_loop_num (access_fn, loop_nb)); init_expr = unshare_expr (initial_condition_in_loop_num (access_fn,
loop_nb));
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "step: "); fprintf (vect_dump, "step: ");
print_generic_expr (dump_file, step_expr, TDF_SLIM); print_generic_expr (vect_dump, step_expr, TDF_SLIM);
fprintf (dump_file, ", init: "); fprintf (vect_dump, ", init: ");
print_generic_expr (dump_file, init_expr, TDF_SLIM); print_generic_expr (vect_dump, init_expr, TDF_SLIM);
} }
*init = init_expr; *init = init_expr;
...@@ -3929,16 +3985,16 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init, ...@@ -3929,16 +3985,16 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tree access_fn, tree * init,
if (TREE_CODE (step_expr) != INTEGER_CST) if (TREE_CODE (step_expr) != INTEGER_CST)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "step unknown."); fprintf (vect_dump, "step unknown.");
return false; return false;
} }
if (strict) if (strict)
if (!integer_onep (step_expr)) if (!integer_onep (step_expr))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
print_generic_expr (dump_file, step_expr, TDF_SLIM); print_generic_expr (vect_dump, step_expr, TDF_SLIM);
return false; return false;
} }
...@@ -3990,17 +4046,17 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo) ...@@ -3990,17 +4046,17 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
basic_block bb = loop->header; basic_block bb = loop->header;
tree dummy; tree dummy;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_analyze_scalar_cycles>>\n"); fprintf (vect_dump, "=== vect_analyze_scalar_cycles ===");
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{ {
tree access_fn = NULL; tree access_fn = NULL;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Analyze phi: "); fprintf (vect_dump, "Analyze phi: ");
print_generic_expr (dump_file, phi, TDF_SLIM); print_generic_expr (vect_dump, phi, TDF_SLIM);
} }
/* Skip virtual phi's. The data dependences that are associated with /* Skip virtual phi's. The data dependences that are associated with
...@@ -4008,8 +4064,8 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo) ...@@ -4008,8 +4064,8 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi)))) if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "virtual phi. skip."); fprintf (vect_dump, "virtual phi. skip.");
continue; continue;
} }
...@@ -4030,24 +4086,25 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo) ...@@ -4030,24 +4086,25 @@ vect_analyze_scalar_cycles (loop_vec_info loop_vinfo)
if (!access_fn) if (!access_fn)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unsupported scalar cycle."); fprintf (vect_dump, "not vectorized: unsupported scalar cycle.");
return false; return false;
} }
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS,
LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, "Access function of PHI: "); fprintf (vect_dump, "Access function of PHI: ");
print_generic_expr (dump_file, access_fn, TDF_SLIM); print_generic_expr (vect_dump, access_fn, TDF_SLIM);
} }
if (!vect_is_simple_iv_evolution (loop->num, access_fn, &dummy, if (!vect_is_simple_iv_evolution (loop->num, access_fn, &dummy,
&dummy, false)) &dummy, false))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unsupported scalar cycle."); fprintf (vect_dump, "not vectorized: unsupported scalar cycle.");
return false; return false;
} }
} }
...@@ -4071,14 +4128,14 @@ vect_analyze_data_ref_dependence (struct data_reference *dra, ...@@ -4071,14 +4128,14 @@ vect_analyze_data_ref_dependence (struct data_reference *dra,
if (!array_base_name_differ_p (dra, drb, &differ_p)) if (!array_base_name_differ_p (dra, drb, &differ_p))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, fprintf (vect_dump,
"not vectorized: can't determine dependence between: "); "not vectorized: can't determine dependence between: ");
print_generic_expr (dump_file, DR_REF (dra), TDF_SLIM); print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
fprintf (dump_file, " and "); fprintf (vect_dump, " and ");
print_generic_expr (dump_file, DR_REF (drb), TDF_SLIM); print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
} }
return true; return true;
} }
...@@ -4092,14 +4149,14 @@ vect_analyze_data_ref_dependence (struct data_reference *dra, ...@@ -4092,14 +4149,14 @@ vect_analyze_data_ref_dependence (struct data_reference *dra,
if (DDR_ARE_DEPENDENT (ddr) == chrec_known) if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
return false; return false;
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, fprintf (vect_dump,
"not vectorized: possible dependence between data-refs "); "not vectorized: possible dependence between data-refs ");
print_generic_expr (dump_file, DR_REF (dra), TDF_SLIM); print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
fprintf (dump_file, " and "); fprintf (vect_dump, " and ");
print_generic_expr (dump_file, DR_REF (drb), TDF_SLIM); print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
} }
return true; return true;
...@@ -4123,11 +4180,11 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo) ...@@ -4123,11 +4180,11 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo)
/* Examine store-store (output) dependences. */ /* Examine store-store (output) dependences. */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_analyze_dependences>>\n"); fprintf (vect_dump, "=== vect_analyze_dependences ===");
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "compare all store-store pairs."); fprintf (vect_dump, "compare all store-store pairs.");
for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_refs); i++) for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_refs); i++)
{ {
...@@ -4144,8 +4201,8 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo) ...@@ -4144,8 +4201,8 @@ vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo)
/* Examine load-store (true/anti) dependences. */ /* Examine load-store (true/anti) dependences. */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "compare all load-store pairs."); fprintf (vect_dump, "compare all load-store pairs.");
for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_read_refs); i++) for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_read_refs); i++)
{ {
...@@ -4186,8 +4243,8 @@ vect_compute_data_ref_alignment (struct data_reference *dr) ...@@ -4186,8 +4243,8 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
bool base_aligned_p; bool base_aligned_p;
tree misalign; tree misalign;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "vect_compute_data_ref_alignment:"); fprintf (vect_dump, "vect_compute_data_ref_alignment:");
/* Initialize misalignment to unknown. */ /* Initialize misalignment to unknown. */
DR_MISALIGNMENT (dr) = -1; DR_MISALIGNMENT (dr) = -1;
...@@ -4199,10 +4256,10 @@ vect_compute_data_ref_alignment (struct data_reference *dr) ...@@ -4199,10 +4256,10 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
if (!misalign) if (!misalign)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Unknown alignment for access: "); fprintf (vect_dump, "Unknown alignment for access: ");
print_generic_expr (dump_file, base, TDF_SLIM); print_generic_expr (vect_dump, base, TDF_SLIM);
} }
return true; return true;
} }
...@@ -4211,10 +4268,10 @@ vect_compute_data_ref_alignment (struct data_reference *dr) ...@@ -4211,10 +4268,10 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
{ {
if (!vect_can_force_dr_alignment_p (base, TYPE_ALIGN (vectype))) if (!vect_can_force_dr_alignment_p (base, TYPE_ALIGN (vectype)))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "can't force alignment of ref: "); fprintf (vect_dump, "can't force alignment of ref: ");
print_generic_expr (dump_file, ref, TDF_SLIM); print_generic_expr (vect_dump, ref, TDF_SLIM);
} }
return true; return true;
} }
...@@ -4222,8 +4279,8 @@ vect_compute_data_ref_alignment (struct data_reference *dr) ...@@ -4222,8 +4279,8 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
/* Force the alignment of the decl. /* Force the alignment of the decl.
NOTE: This is the only change to the code we make during NOTE: This is the only change to the code we make during
the analysis phase, before deciding to vectorize the loop. */ the analysis phase, before deciding to vectorize the loop. */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "force alignment"); fprintf (vect_dump, "force alignment");
DECL_ALIGN (base) = TYPE_ALIGN (vectype); DECL_ALIGN (base) = TYPE_ALIGN (vectype);
DECL_USER_ALIGN (base) = 1; DECL_USER_ALIGN (base) = 1;
} }
...@@ -4241,15 +4298,15 @@ vect_compute_data_ref_alignment (struct data_reference *dr) ...@@ -4241,15 +4298,15 @@ vect_compute_data_ref_alignment (struct data_reference *dr)
if (tree_int_cst_sgn (misalign) < 0) if (tree_int_cst_sgn (misalign) < 0)
{ {
/* Negative misalignment value. */ /* Negative misalignment value. */
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "unexpected misalign value"); fprintf (vect_dump, "unexpected misalign value");
return false; return false;
} }
DR_MISALIGNMENT (dr) = tree_low_cst (misalign, 1); DR_MISALIGNMENT (dr) = tree_low_cst (misalign, 1);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "misalign = %d", DR_MISALIGNMENT (dr)); fprintf (vect_dump, "misalign = %d bytes", DR_MISALIGNMENT (dr));
return true; return true;
} }
...@@ -4418,13 +4475,13 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4418,13 +4475,13 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
if (!LOOP_VINFO_UNALIGNED_DR (loop_vinfo)) if (!LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "Peeling for alignment will not be applied."); fprintf (vect_dump, "Peeling for alignment will not be applied.");
return; return;
} }
else else
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "Peeling for alignment will be applied."); fprintf (vect_dump, "Peeling for alignment will be applied.");
/* (1.2) Update the alignment info according to the peeling factor. /* (1.2) Update the alignment info according to the peeling factor.
...@@ -4448,9 +4505,8 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4448,9 +4505,8 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo)) if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
{ {
DR_MISALIGNMENT (dr) = 0; DR_MISALIGNMENT (dr) = 0;
if (vect_debug_details (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo)))
|| vect_debug_stats (LOOP_LOC (loop_vinfo))) fprintf (vect_dump, "Alignment of access forced using peeling.");
fprintf (dump_file, "Alignment of access forced using peeling.");
} }
else else
DR_MISALIGNMENT (dr) = -1; DR_MISALIGNMENT (dr) = -1;
...@@ -4461,9 +4517,8 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4461,9 +4517,8 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo)) if (dr == LOOP_VINFO_UNALIGNED_DR (loop_vinfo))
{ {
DR_MISALIGNMENT (dr) = 0; DR_MISALIGNMENT (dr) = 0;
if (vect_debug_details (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo)))
|| vect_debug_stats (LOOP_LOC (loop_vinfo))) fprintf (vect_dump, "Alignment of access forced using peeling.");
fprintf (dump_file, "Alignment of access forced using peeling.");
} }
else else
DR_MISALIGNMENT (dr) = -1; DR_MISALIGNMENT (dr) = -1;
...@@ -4486,8 +4541,8 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4486,8 +4541,8 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo)
enum dr_alignment_support supportable_dr_alignment; enum dr_alignment_support supportable_dr_alignment;
unsigned int i; unsigned int i;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_analyze_data_refs_alignment>>\n"); fprintf (vect_dump, "=== vect_analyze_data_refs_alignment ===");
/* This pass may take place at function granularity instead of at loop /* This pass may take place at function granularity instead of at loop
...@@ -4495,9 +4550,9 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4495,9 +4550,9 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo)
if (!vect_compute_data_refs_alignment (loop_vinfo)) if (!vect_compute_data_refs_alignment (loop_vinfo))
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_stats (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, fprintf (vect_dump,
"not vectorized: can't calculate alignment for data ref."); "not vectorized: can't calculate alignment for data ref.");
return false; return false;
} }
...@@ -4518,15 +4573,14 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4518,15 +4573,14 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo)
supportable_dr_alignment = vect_supportable_dr_alignment (dr); supportable_dr_alignment = vect_supportable_dr_alignment (dr);
if (!supportable_dr_alignment) if (!supportable_dr_alignment)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_stats (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unsupported unaligned load."); fprintf (vect_dump, "not vectorized: unsupported unaligned load.");
return false; return false;
} }
if (supportable_dr_alignment != dr_aligned if (supportable_dr_alignment != dr_aligned
&& (vect_debug_details (LOOP_LOC (loop_vinfo)) && (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo))))
|| vect_debug_stats (LOOP_LOC (loop_vinfo)))) fprintf (vect_dump, "Vectorizing an unaligned access.");
fprintf (dump_file, "Vectorizing an unaligned access.");
} }
for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++) for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
{ {
...@@ -4534,15 +4588,14 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo) ...@@ -4534,15 +4588,14 @@ vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo)
supportable_dr_alignment = vect_supportable_dr_alignment (dr); supportable_dr_alignment = vect_supportable_dr_alignment (dr);
if (!supportable_dr_alignment) if (!supportable_dr_alignment)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_stats (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unsupported unaligned store."); fprintf (vect_dump, "not vectorized: unsupported unaligned store.");
return false; return false;
} }
if (supportable_dr_alignment != dr_aligned if (supportable_dr_alignment != dr_aligned
&& (vect_debug_details (LOOP_LOC (loop_vinfo)) && (vect_print_dump_info (REPORT_ALIGNMENT, LOOP_LOC (loop_vinfo))))
|| vect_debug_stats (LOOP_LOC (loop_vinfo)))) fprintf (vect_dump, "Vectorizing an unaligned access.");
fprintf (dump_file, "Vectorizing an unaligned access.");
} }
return true; return true;
...@@ -4564,8 +4617,8 @@ vect_analyze_data_ref_access (struct data_reference *dr) ...@@ -4564,8 +4617,8 @@ vect_analyze_data_ref_access (struct data_reference *dr)
if (!step || tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type))) if (!step || tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type)))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "not consecutive access"); fprintf (vect_dump, "not consecutive access");
return false; return false;
} }
return true; return true;
...@@ -4588,8 +4641,8 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo) ...@@ -4588,8 +4641,8 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo)
varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo); varray_type loop_write_datarefs = LOOP_VINFO_DATAREF_WRITES (loop_vinfo);
varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo); varray_type loop_read_datarefs = LOOP_VINFO_DATAREF_READS (loop_vinfo);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_analyze_data_ref_accesses>>\n"); fprintf (vect_dump, "=== vect_analyze_data_ref_accesses ===");
for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++) for (i = 0; i < VARRAY_ACTIVE_SIZE (loop_write_datarefs); i++)
{ {
...@@ -4597,9 +4650,9 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo) ...@@ -4597,9 +4650,9 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo)
bool ok = vect_analyze_data_ref_access (dr); bool ok = vect_analyze_data_ref_access (dr);
if (!ok) if (!ok)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: complicated access pattern."); fprintf (vect_dump, "not vectorized: complicated access pattern.");
return false; return false;
} }
} }
...@@ -4610,9 +4663,9 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo) ...@@ -4610,9 +4663,9 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo)
bool ok = vect_analyze_data_ref_access (dr); bool ok = vect_analyze_data_ref_access (dr);
if (!ok) if (!ok)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: complicated access pattern."); fprintf (vect_dump, "not vectorized: complicated access pattern.");
return false; return false;
} }
} }
...@@ -4645,23 +4698,23 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read) ...@@ -4645,23 +4698,23 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read)
if (!access_fn) if (!access_fn)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: complicated pointer access."); fprintf (vect_dump, "not vectorized: complicated pointer access.");
return NULL; return NULL;
} }
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Access function of ptr: "); fprintf (vect_dump, "Access function of ptr: ");
print_generic_expr (dump_file, access_fn, TDF_SLIM); print_generic_expr (vect_dump, access_fn, TDF_SLIM);
} }
if (!vect_is_simple_iv_evolution (loopnum, access_fn, &init, &step, false)) if (!vect_is_simple_iv_evolution (loopnum, access_fn, &init, &step, false))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: pointer access is not simple."); fprintf (vect_dump, "not vectorized: pointer access is not simple.");
return NULL; return NULL;
} }
...@@ -4669,18 +4722,18 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read) ...@@ -4669,18 +4722,18 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read)
if (!expr_invariant_in_loop_p (loop, init)) if (!expr_invariant_in_loop_p (loop, init))
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, fprintf (vect_dump,
"not vectorized: initial condition is not loop invariant."); "not vectorized: initial condition is not loop invariant.");
return NULL; return NULL;
} }
if (TREE_CODE (step) != INTEGER_CST) if (TREE_CODE (step) != INTEGER_CST)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, fprintf (vect_dump,
"not vectorized: non constant step for pointer access."); "not vectorized: non constant step for pointer access.");
return NULL; return NULL;
} }
...@@ -4688,18 +4741,18 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read) ...@@ -4688,18 +4741,18 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read)
reftype = TREE_TYPE (TREE_OPERAND (memref, 0)); reftype = TREE_TYPE (TREE_OPERAND (memref, 0));
if (TREE_CODE (reftype) != POINTER_TYPE) if (TREE_CODE (reftype) != POINTER_TYPE)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unexpected pointer access form."); fprintf (vect_dump, "not vectorized: unexpected pointer access form.");
return NULL; return NULL;
} }
reftype = TREE_TYPE (init); reftype = TREE_TYPE (init);
if (TREE_CODE (reftype) != POINTER_TYPE) if (TREE_CODE (reftype) != POINTER_TYPE)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unexpected pointer access form."); fprintf (vect_dump, "not vectorized: unexpected pointer access form.");
return NULL; return NULL;
} }
...@@ -4707,9 +4760,9 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read) ...@@ -4707,9 +4760,9 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read)
if (tree_int_cst_compare (TYPE_SIZE_UNIT (innertype), step)) if (tree_int_cst_compare (TYPE_SIZE_UNIT (innertype), step))
{ {
/* FORNOW: support only consecutive access */ /* FORNOW: support only consecutive access */
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: non consecutive access."); fprintf (vect_dump, "not vectorized: non consecutive access.");
return NULL; return NULL;
} }
...@@ -4724,10 +4777,10 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read) ...@@ -4724,10 +4777,10 @@ vect_analyze_pointer_ref_access (tree memref, tree stmt, bool is_read)
indx_access_fn = indx_access_fn =
build_polynomial_chrec (loopnum, integer_zero_node, integer_one_node); build_polynomial_chrec (loopnum, integer_zero_node, integer_one_node);
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Access function of ptr indx: "); fprintf (vect_dump, "Access function of ptr indx: ");
print_generic_expr (dump_file, indx_access_fn, TDF_SLIM); print_generic_expr (vect_dump, indx_access_fn, TDF_SLIM);
} }
dr = init_data_ref (stmt, memref, init, indx_access_fn, is_read); dr = init_data_ref (stmt, memref, init, indx_access_fn, is_read);
return dr; return dr;
...@@ -4798,8 +4851,9 @@ vect_get_memtag_and_dr (tree memref, tree stmt, bool is_read, ...@@ -4798,8 +4851,9 @@ vect_get_memtag_and_dr (tree memref, tree stmt, bool is_read,
} }
if (!tag) if (!tag)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
fprintf (dump_file, "not vectorized: no memtag for ref."); UNKNOWN_LOC))
fprintf (vect_dump, "not vectorized: no memtag for ref.");
return NULL_TREE; return NULL_TREE;
} }
return tag; return tag;
...@@ -4956,8 +5010,8 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) ...@@ -4956,8 +5010,8 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo)
int j; int j;
struct data_reference *dr; struct data_reference *dr;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_analyze_data_refs>>\n"); fprintf (vect_dump, "=== vect_analyze_data_refs ===");
for (j = 0; j < nbbs; j++) for (j = 0; j < nbbs; j++)
{ {
...@@ -4988,20 +5042,20 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) ...@@ -4988,20 +5042,20 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo)
if (nvuses && (nv_may_defs || nv_must_defs)) if (nvuses && (nv_may_defs || nv_must_defs))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "unexpected vdefs and vuses in stmt: "); fprintf (vect_dump, "unexpected vdefs and vuses in stmt: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return false; return false;
} }
if (TREE_CODE (stmt) != MODIFY_EXPR) if (TREE_CODE (stmt) != MODIFY_EXPR)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "unexpected vops in stmt: "); fprintf (vect_dump, "unexpected vops in stmt: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return false; return false;
} }
...@@ -5023,12 +5077,12 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) ...@@ -5023,12 +5077,12 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo)
vectype = get_vectype_for_scalar_type (scalar_type); vectype = get_vectype_for_scalar_type (scalar_type);
if (!vectype) if (!vectype)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "no vectype for stmt: "); fprintf (vect_dump, "no vectype for stmt: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
fprintf (dump_file, " scalar_type: "); fprintf (vect_dump, " scalar_type: ");
print_generic_expr (dump_file, scalar_type, TDF_DETAILS); print_generic_expr (vect_dump, scalar_type, TDF_DETAILS);
} }
/* It is not possible to vectorize this data reference. */ /* It is not possible to vectorize this data reference. */
return false; return false;
...@@ -5040,11 +5094,11 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo) ...@@ -5040,11 +5094,11 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo)
vectype, &dr); vectype, &dr);
if (!symbl) if (!symbl)
{ {
if (vect_debug_stats (LOOP_LOC (loop_vinfo)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
|| vect_debug_details (LOOP_LOC (loop_vinfo))) LOOP_LOC (loop_vinfo)))
{ {
fprintf (dump_file, "not vectorized: unhandled data ref: "); fprintf (vect_dump, "not vectorized: unhandled data ref: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return false; return false;
} }
...@@ -5070,8 +5124,8 @@ vect_mark_relevant (varray_type *worklist, tree stmt) ...@@ -5070,8 +5124,8 @@ vect_mark_relevant (varray_type *worklist, tree stmt)
{ {
stmt_vec_info stmt_info; stmt_vec_info stmt_info;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "mark relevant."); fprintf (vect_dump, "mark relevant.");
if (TREE_CODE (stmt) == PHI_NODE) if (TREE_CODE (stmt) == PHI_NODE)
{ {
...@@ -5083,18 +5137,18 @@ vect_mark_relevant (varray_type *worklist, tree stmt) ...@@ -5083,18 +5137,18 @@ vect_mark_relevant (varray_type *worklist, tree stmt)
if (!stmt_info) if (!stmt_info)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "mark relevant: no stmt info!!."); fprintf (vect_dump, "mark relevant: no stmt info!!.");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
return; return;
} }
if (STMT_VINFO_RELEVANT_P (stmt_info)) if (STMT_VINFO_RELEVANT_P (stmt_info))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "already marked relevant."); fprintf (vect_dump, "already marked relevant.");
return; return;
} }
...@@ -5130,14 +5184,17 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo) ...@@ -5130,14 +5184,17 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo)
return true; return true;
/* changing memory. */ /* changing memory. */
if (TREE_CODE (stmt) != PHI_NODE)
{
v_may_defs = STMT_V_MAY_DEF_OPS (stmt); v_may_defs = STMT_V_MAY_DEF_OPS (stmt);
v_must_defs = STMT_V_MUST_DEF_OPS (stmt); v_must_defs = STMT_V_MUST_DEF_OPS (stmt);
if (v_may_defs || v_must_defs) if (v_may_defs || v_must_defs)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "vec_stmt_relevant_p: stmt has vdefs."); fprintf (vect_dump, "vec_stmt_relevant_p: stmt has vdefs.");
return true; return true;
} }
}
/* uses outside the loop. */ /* uses outside the loop. */
df = get_immediate_uses (stmt); df = get_immediate_uses (stmt);
...@@ -5148,8 +5205,8 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo) ...@@ -5148,8 +5205,8 @@ vect_stmt_relevant_p (tree stmt, loop_vec_info loop_vinfo)
basic_block bb = bb_for_stmt (use); basic_block bb = bb_for_stmt (use);
if (!flow_bb_inside_loop_p (loop, bb)) if (!flow_bb_inside_loop_p (loop, bb))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "vec_stmt_relevant_p: used out of loop."); fprintf (vect_dump, "vec_stmt_relevant_p: used out of loop.");
return true; return true;
} }
} }
...@@ -5191,22 +5248,23 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) ...@@ -5191,22 +5248,23 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
basic_block bb; basic_block bb;
tree phi; tree phi;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<vect_mark_stmts_to_be_vectorized>>\n"); fprintf (vect_dump, "=== vect_mark_stmts_to_be_vectorized ===");
bb = loop->header; bb = loop->header;
for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "init: phi relevant? "); fprintf (vect_dump, "init: phi relevant? ");
print_generic_expr (dump_file, phi, TDF_SLIM); print_generic_expr (vect_dump, phi, TDF_SLIM);
} }
if (vect_stmt_relevant_p (phi, loop_vinfo)) if (vect_stmt_relevant_p (phi, loop_vinfo))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
fprintf (dump_file, "unsupported reduction/induction."); LOOP_LOC (loop_vinfo)))
fprintf (vect_dump, "unsupported reduction/induction.");
return false; return false;
} }
} }
...@@ -5222,10 +5280,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) ...@@ -5222,10 +5280,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
{ {
stmt = bsi_stmt (si); stmt = bsi_stmt (si);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "init: stmt relevant? "); fprintf (vect_dump, "init: stmt relevant? ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
stmt_info = vinfo_for_stmt (stmt); stmt_info = vinfo_for_stmt (stmt);
...@@ -5244,10 +5302,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) ...@@ -5244,10 +5302,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
stmt = VARRAY_TOP_TREE (worklist); stmt = VARRAY_TOP_TREE (worklist);
VARRAY_POP (worklist); VARRAY_POP (worklist);
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "worklist: examine stmt: "); fprintf (vect_dump, "worklist: examine stmt: ");
print_generic_expr (dump_file, stmt, TDF_SLIM); print_generic_expr (vect_dump, stmt, TDF_SLIM);
} }
/* Examine the USES in this statement. Mark all the statements which /* Examine the USES in this statement. Mark all the statements which
...@@ -5264,18 +5322,19 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) ...@@ -5264,18 +5322,19 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
basic_block bb; basic_block bb;
if (!vect_is_simple_use (arg, loop_vinfo, &def_stmt)) if (!vect_is_simple_use (arg, loop_vinfo, &def_stmt))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
fprintf (dump_file, "worklist: unsupported use."); LOOP_LOC (loop_vinfo)))
fprintf (vect_dump, "not vectorized: unsupported use in stmt.");
varray_clear (worklist); varray_clear (worklist);
return false; return false;
} }
if (!def_stmt) if (!def_stmt)
continue; continue;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "worklist: def_stmt: "); fprintf (vect_dump, "worklist: def_stmt: ");
print_generic_expr (dump_file, def_stmt, TDF_SLIM); print_generic_expr (vect_dump, def_stmt, TDF_SLIM);
} }
bb = bb_for_stmt (def_stmt); bb = bb_for_stmt (def_stmt);
...@@ -5300,8 +5359,9 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) ...@@ -5300,8 +5359,9 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
basic_block bb; basic_block bb;
if (!vect_is_simple_use (use, loop_vinfo, &def_stmt)) if (!vect_is_simple_use (use, loop_vinfo, &def_stmt))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS,
fprintf (dump_file, "worklist: unsupported use."); LOOP_LOC (loop_vinfo)))
fprintf (vect_dump, "not vectorized: unsupported use in stmt.");
varray_clear (worklist); varray_clear (worklist);
return false; return false;
} }
...@@ -5309,10 +5369,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo) ...@@ -5309,10 +5369,10 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info loop_vinfo)
if (!def_stmt) if (!def_stmt)
continue; continue;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "worklist: examine use %d: ", i); fprintf (vect_dump, "worklist: examine use %d: ", i);
print_generic_expr (dump_file, use, TDF_SLIM); print_generic_expr (vect_dump, use, TDF_SLIM);
} }
bb = bb_for_stmt (def_stmt); bb = bb_for_stmt (def_stmt);
...@@ -5350,10 +5410,10 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo) ...@@ -5350,10 +5410,10 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
tree access_fn = NULL; tree access_fn = NULL;
tree evolution_part; tree evolution_part;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Analyze phi: "); fprintf (vect_dump, "Analyze phi: ");
print_generic_expr (dump_file, phi, TDF_SLIM); print_generic_expr (vect_dump, phi, TDF_SLIM);
} }
/* Skip virtual phi's. The data dependences that are associated with /* Skip virtual phi's. The data dependences that are associated with
...@@ -5361,8 +5421,8 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo) ...@@ -5361,8 +5421,8 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi)))) if (!is_gimple_reg (SSA_NAME_VAR (PHI_RESULT (phi))))
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "virtual phi. skip."); fprintf (vect_dump, "virtual phi. skip.");
continue; continue;
} }
...@@ -5373,15 +5433,15 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo) ...@@ -5373,15 +5433,15 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
if (!access_fn) if (!access_fn)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "No Access function."); fprintf (vect_dump, "No Access function.");
return false; return false;
} }
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "Access function of PHI: "); fprintf (vect_dump, "Access function of PHI: ");
print_generic_expr (dump_file, access_fn, TDF_SLIM); print_generic_expr (vect_dump, access_fn, TDF_SLIM);
} }
evolution_part = evolution_part_in_loop_num (access_fn, loop->num); evolution_part = evolution_part_in_loop_num (access_fn, loop->num);
...@@ -5412,8 +5472,8 @@ vect_get_loop_niters (struct loop *loop, tree *number_of_iterations) ...@@ -5412,8 +5472,8 @@ vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
{ {
tree niters; tree niters;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<get_loop_niters>>\n"); fprintf (vect_dump, "=== get_loop_niters ===");
niters = number_of_iterations_in_loop (loop); niters = number_of_iterations_in_loop (loop);
...@@ -5422,10 +5482,10 @@ vect_get_loop_niters (struct loop *loop, tree *number_of_iterations) ...@@ -5422,10 +5482,10 @@ vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
{ {
*number_of_iterations = niters; *number_of_iterations = niters;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
{ {
fprintf (dump_file, "==> get_loop_niters:" ); fprintf (vect_dump, "==> get_loop_niters:" );
print_generic_expr (dump_file, *number_of_iterations, TDF_SLIM); print_generic_expr (vect_dump, *number_of_iterations, TDF_SLIM);
} }
} }
...@@ -5454,28 +5514,31 @@ vect_analyze_loop_form (struct loop *loop) ...@@ -5454,28 +5514,31 @@ vect_analyze_loop_form (struct loop *loop)
loop_loc = find_loop_location (loop); loop_loc = find_loop_location (loop);
if (vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_DETAILS, loop_loc))
fprintf (dump_file, "\n<<vect_analyze_loop_form>>\n"); fprintf (vect_dump, "=== vect_analyze_loop_form ===");
if (loop->inner if (loop->inner)
|| !loop->single_exit {
if (vect_print_dump_info (REPORT_OUTER_LOOPS, loop_loc))
fprintf (vect_dump, "not vectorized: nested loop.");
return NULL;
}
if (!loop->single_exit
|| loop->num_nodes != 2 || loop->num_nodes != 2
|| EDGE_COUNT (loop->header->preds) != 2 || EDGE_COUNT (loop->header->preds) != 2
|| loop->num_entries != 1) || loop->num_entries != 1)
{ {
if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
{ {
fprintf (dump_file, "not vectorized: bad loop form. "); if (!loop->single_exit)
if (loop->inner) fprintf (vect_dump, "not vectorized: multiple exits.");
fprintf (dump_file, "nested loop.");
else if (!loop->single_exit)
fprintf (dump_file, "multiple exits.");
else if (loop->num_nodes != 2) else if (loop->num_nodes != 2)
fprintf (dump_file, "too many BBs in loop."); fprintf (vect_dump, "not vectorized: too many BBs in loop.");
else if (EDGE_COUNT (loop->header->preds) != 2) else if (EDGE_COUNT (loop->header->preds) != 2)
fprintf (dump_file, "too many incoming edges."); fprintf (vect_dump, "not vectorized: too many incoming edges.");
else if (loop->num_entries != 1) else if (loop->num_entries != 1)
fprintf (dump_file, "too many entries."); fprintf (vect_dump, "not vectorized: too many entries.");
} }
return NULL; return NULL;
...@@ -5487,8 +5550,8 @@ vect_analyze_loop_form (struct loop *loop) ...@@ -5487,8 +5550,8 @@ vect_analyze_loop_form (struct loop *loop)
executable statements, and the latch is empty. */ executable statements, and the latch is empty. */
if (!empty_block_p (loop->latch)) if (!empty_block_p (loop->latch))
{ {
if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
fprintf (dump_file, "not vectorized: unexpectd loop form."); fprintf (vect_dump, "not vectorized: unexpectd loop form.");
return NULL; return NULL;
} }
...@@ -5515,31 +5578,31 @@ vect_analyze_loop_form (struct loop *loop) ...@@ -5515,31 +5578,31 @@ vect_analyze_loop_form (struct loop *loop)
if (empty_block_p (loop->header)) if (empty_block_p (loop->header))
{ {
if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
fprintf (dump_file, "not vectorized: empty loop."); fprintf (vect_dump, "not vectorized: empty loop.");
return NULL; return NULL;
} }
loop_cond = vect_get_loop_niters (loop, &number_of_iterations); loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
if (!loop_cond) if (!loop_cond)
{ {
if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
fprintf (dump_file, "not vectorized: complicated exit condition."); fprintf (vect_dump, "not vectorized: complicated exit condition.");
return NULL; return NULL;
} }
if (!number_of_iterations) if (!number_of_iterations)
{ {
if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
fprintf (dump_file, fprintf (vect_dump,
"not vectorized: number of iterations cannot be computed."); "not vectorized: number of iterations cannot be computed.");
return NULL; return NULL;
} }
if (chrec_contains_undetermined (number_of_iterations)) if (chrec_contains_undetermined (number_of_iterations))
{ {
if (vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_BAD_FORM_LOOPS, loop_loc))
fprintf (dump_file, "Infinite number of iterations."); fprintf (vect_dump, "Infinite number of iterations.");
return false; return false;
} }
...@@ -5548,18 +5611,17 @@ vect_analyze_loop_form (struct loop *loop) ...@@ -5548,18 +5611,17 @@ vect_analyze_loop_form (struct loop *loop)
if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)) if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
{ {
if (vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_DETAILS, loop_loc))
{ {
fprintf (dump_file, "loop bound unknown.\n"); fprintf (vect_dump, "Symbolic number of iterations is ");
fprintf (dump_file, "Symbolic number of iterations is "); print_generic_expr (vect_dump, number_of_iterations, TDF_DETAILS);
print_generic_expr (dump_file, number_of_iterations, TDF_DETAILS);
} }
} }
else else
if (LOOP_VINFO_INT_NITERS (loop_vinfo) == 0) if (LOOP_VINFO_INT_NITERS (loop_vinfo) == 0)
{ {
if (vect_debug_stats (loop_loc) || vect_debug_details (loop_loc)) if (vect_print_dump_info (REPORT_UNVECTORIZED_LOOPS, loop_loc))
fprintf (dump_file, "not vectorized: number of iterations = 0."); fprintf (vect_dump, "not vectorized: number of iterations = 0.");
return NULL; return NULL;
} }
...@@ -5582,16 +5644,16 @@ vect_analyze_loop (struct loop *loop) ...@@ -5582,16 +5644,16 @@ vect_analyze_loop (struct loop *loop)
bool ok; bool ok;
loop_vec_info loop_vinfo; loop_vec_info loop_vinfo;
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "\n<<<<<<< analyze_loop_nest >>>>>>>\n"); fprintf (vect_dump, "===== analyze_loop_nest =====");
/* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */ /* Check the CFG characteristics of the loop (nesting, entry/exit, etc. */
loop_vinfo = vect_analyze_loop_form (loop); loop_vinfo = vect_analyze_loop_form (loop);
if (!loop_vinfo) if (!loop_vinfo)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "bad loop form."); fprintf (vect_dump, "bad loop form.");
return NULL; return NULL;
} }
...@@ -5604,8 +5666,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5604,8 +5666,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_analyze_data_refs (loop_vinfo); ok = vect_analyze_data_refs (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "bad data references."); fprintf (vect_dump, "bad data references.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5615,10 +5677,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5615,10 +5677,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_mark_stmts_to_be_vectorized (loop_vinfo); ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "unexpected pattern."); fprintf (vect_dump, "unexpected pattern.");
if (vect_debug_stats (LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "not vectorized: unexpected pattern.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5629,8 +5689,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5629,8 +5689,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_analyze_scalar_cycles (loop_vinfo); ok = vect_analyze_scalar_cycles (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "bad scalar cycle."); fprintf (vect_dump, "bad scalar cycle.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5641,8 +5701,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5641,8 +5701,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_analyze_data_ref_dependences (loop_vinfo); ok = vect_analyze_data_ref_dependences (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "bad data dependence."); fprintf (vect_dump, "bad data dependence.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5653,8 +5713,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5653,8 +5713,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_analyze_data_ref_accesses (loop_vinfo); ok = vect_analyze_data_ref_accesses (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "bad data access."); fprintf (vect_dump, "bad data access.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5665,8 +5725,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5665,8 +5725,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_analyze_data_refs_alignment (loop_vinfo); ok = vect_analyze_data_refs_alignment (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "bad data alignment."); fprintf (vect_dump, "bad data alignment.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5677,8 +5737,8 @@ vect_analyze_loop (struct loop *loop) ...@@ -5677,8 +5737,8 @@ vect_analyze_loop (struct loop *loop)
ok = vect_analyze_operations (loop_vinfo); ok = vect_analyze_operations (loop_vinfo);
if (!ok) if (!ok)
{ {
if (vect_debug_details (LOOP_LOC (loop_vinfo))) if (vect_print_dump_info (REPORT_DETAILS, LOOP_LOC (loop_vinfo)))
fprintf (dump_file, "bad operation or unsupported loop bound."); fprintf (vect_dump, "bad operation or unsupported loop bound.");
destroy_loop_vec_info (loop_vinfo); destroy_loop_vec_info (loop_vinfo);
return NULL; return NULL;
} }
...@@ -5712,12 +5772,15 @@ vectorize_loops (struct loops *loops) ...@@ -5712,12 +5772,15 @@ vectorize_loops (struct loops *loops)
unsigned int i, loops_num; unsigned int i, loops_num;
unsigned int num_vectorized_loops = 0; unsigned int num_vectorized_loops = 0;
/* Fix the verbosity level if not defined explicitly by the user. */
vect_set_dump_settings ();
/* Does the target support SIMD? */ /* Does the target support SIMD? */
/* FORNOW: until more sophisticated machine modelling is in place. */ /* FORNOW: until more sophisticated machine modelling is in place. */
if (!UNITS_PER_SIMD_WORD) if (!UNITS_PER_SIMD_WORD)
{ {
if (vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_DETAILS, UNKNOWN_LOC))
fprintf (dump_file, "vectorizer: target vector size is not defined."); fprintf (vect_dump, "vectorizer: target vector size is not defined.");
return; return;
} }
...@@ -5751,8 +5814,8 @@ vectorize_loops (struct loops *loops) ...@@ -5751,8 +5814,8 @@ vectorize_loops (struct loops *loops)
num_vectorized_loops++; num_vectorized_loops++;
} }
if (vect_debug_stats (UNKNOWN_LOC) || vect_debug_details (UNKNOWN_LOC)) if (vect_print_dump_info (REPORT_VECTORIZED_LOOPS, UNKNOWN_LOC))
fprintf (dump_file, "\nvectorized %u loops in function.\n", fprintf (vect_dump, "vectorized %u loops in function.\n",
num_vectorized_loops); num_vectorized_loops);
/* ----------- Finalize. ----------- */ /* ----------- Finalize. ----------- */
......
gcc/tree-vectorizer.h
...@@ -56,6 +56,19 @@ enum dr_alignment_support { ...@@ -56,6 +56,19 @@ enum dr_alignment_support {
dr_aligned dr_aligned
}; };
/* Define verbosity levels. */
enum verbosity_levels {
REPORT_NONE,
REPORT_VECTORIZED_LOOPS,
REPORT_UNVECTORIZED_LOOPS,
REPORT_ALIGNMENT,
REPORT_BAD_FORM_LOOPS,
REPORT_OUTER_LOOPS,
REPORT_DETAILS,
/* New verbosity levels should be added before this one. */
MAX_VERBOSITY_LEVEL
};
/*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/
/* Info on vectorized loops. */ /* Info on vectorized loops. */
/*-----------------------------------------------------------------*/ /*-----------------------------------------------------------------*/
......
gcc/tree.h
...@@ -3917,4 +3917,7 @@ extern bool thread_through_all_blocks (void); ...@@ -3917,4 +3917,7 @@ extern bool thread_through_all_blocks (void);
/* In tree-gimple.c. */ /* In tree-gimple.c. */
extern tree get_base_address (tree t); extern tree get_base_address (tree t);
/* In tree-vectorizer.c. */
extern void vect_set_verbosity_level (const char *);
#endif /* GCC_TREE_H */ #endif /* GCC_TREE_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment