Patchwork vectorization passes clean up for dump info

login
register
mail settings
Submitter Sharad Singhai
Date Oct. 24, 2012, 12:53 a.m.
Message ID <CAKxPW65RS5caBn49H=BuJ+tKXhDJMmVSpor4ykCRokxrTNOTjw@mail.gmail.com>
Download mbox | patch
Permalink /patch/193610/
State New
Headers show

Comments

Sharad Singhai - Oct. 24, 2012, 12:53 a.m.
Okay, I have updated the patch (attached) to allow inlining of
dump_enabled_p. I needed to make alt_dump_file extern to for this
(dump_file was already extern). Also, I moved dump_file definition
from toplev.c to dumpfile.c, where it seems to logically belong.

Bootstrapped and tested on x86_64. Okay for trunk?

Thanks,
Sharad

2012-10-24  Sharad Singhai  <singhai@google.com>

        * dumpfile.c (dump_enabled_p): Make it inline and move the definition
        to dumpfile.h.
        (dump_kind_p): Deleted. Functionality replaced by dump_enabled_p.
        Make alt_dump_file extern.
        * dumpfile.h (dump_enabled_p): Move inline definition here.
        (dump_kind_p): Delete declaration.
        Add extern declaration of alt_dump_file.
        * toplev.c: Move dump_file and dump_file_name to dumpfile.c.
        * tree-vect-loop-manip.c: Replace all uses of dump_kind_p with
        dump_enabled_p.
        * tree-vectorizer.c: Likewise.
        * tree-vect-loop.c: Likewise.
        * tree-vect-data-refs.c: Likewise.
        * tree-vect-patterns.c: Likewise.
        * tree-vect-stmts.c: Likewise.
        * tree-vect-slp.c: Likewise.

   FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
@@ -1798,7 +1798,7 @@ vect_make_slp_decision (loop_vec_info loop_vinfo)

   LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo) = unrolling_factor;

-  if (decided_to_slp && dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (decided_to_slp && dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
      "Decided to SLP %d instances. Unrolling factor %d",
      decided_to_slp, unrolling_factor);
@@ -1863,7 +1863,7 @@ vect_detect_hybrid_slp (loop_vec_info loop_vinfo)
   VEC (slp_instance, heap) *slp_instances = LOOP_VINFO_SLP_INSTANCES
(loop_vinfo);
   slp_instance instance;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "===
vect_detect_hybrid_slp ===");

   FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
@@ -2060,7 +2060,7 @@ vect_bb_vectorization_profitable_p (bb_vec_info bb

   vec_outside_cost = vec_prologue_cost + vec_epilogue_cost;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "Cost model analysis: \n");
       dump_printf (MSG_NOTE, "  Vector inside of basic block cost: %d\n",
@@ -2097,7 +2097,7 @@ vect_slp_analyze_bb_1 (basic_block bb)

   if (!vect_analyze_data_refs (NULL, bb_vinfo, &min_vf))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: unhandled data-ref in basic "
  "block.\n");
@@ -2109,7 +2109,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
   ddrs = BB_VINFO_DDRS (bb_vinfo);
   if (!VEC_length (ddr_p, ddrs))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: not enough data-refs in "
  "basic block.\n");
@@ -2123,7 +2123,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
   if (!vect_analyze_data_ref_dependences (NULL, bb_vinfo, &max_vf)
        || min_vf > max_vf)
      {
-       if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+       if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
   "not vectorized: unhandled data dependence "
   "in basic block.\n");
@@ -2134,7 +2134,7 @@ vect_slp_analyze_bb_1 (basic_block bb)

   if (!vect_analyze_data_refs_alignment (NULL, bb_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: bad data alignment in basic "
  "block.\n");
@@ -2145,7 +2145,7 @@ vect_slp_analyze_bb_1 (basic_block bb)

   if (!vect_analyze_data_ref_accesses (NULL, bb_vinfo))
     {
-     if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+     if (dump_enabled_p ())
        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: unhandled data access in "
  "basic block.\n");
@@ -2158,7 +2158,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
      trees.  */
   if (!vect_analyze_slp (NULL, bb_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: failed to find SLP opportunities "
  "in basic block.\n");
@@ -2179,7 +2179,7 @@ vect_slp_analyze_bb_1 (basic_block bb)

   if (!vect_verify_datarefs_alignment (NULL, bb_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not vectorized: unsupported alignment in basic "
                          "block.\n");
@@ -2189,7 +2189,7 @@ vect_slp_analyze_bb_1 (basic_block bb)

   if (!vect_slp_analyze_operations (bb_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: bad operation in basic block.\n");

@@ -2201,7 +2201,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
   if (flag_vect_cost_model
       && !vect_bb_vectorization_profitable_p (bb_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: vectorization is not "
  "profitable.\n");
@@ -2210,7 +2210,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
       return NULL;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "Basic block will be vectorized using SLP\n");

@@ -2226,7 +2226,7 @@ vect_slp_analyze_bb (basic_block bb)
   gimple_stmt_iterator gsi;
   unsigned int vector_sizes;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "===vect_slp_analyze_bb===\n");

   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
@@ -2240,7 +2240,7 @@ vect_slp_analyze_bb (basic_block bb)

   if (insns > PARAM_VALUE (PARAM_SLP_MAX_INSNS_IN_BB))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: too many instructions in "
  "basic block.\n");
@@ -2267,7 +2267,7 @@ vect_slp_analyze_bb (basic_block bb)

       /* Try the next biggest vector size.  */
       current_vector_size = 1 << floor_log2 (vector_sizes);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "***** Re-trying analysis with "
  "vector size %d\n", current_vector_size);
@@ -2292,7 +2292,7 @@ vect_update_slp_costs_according_to_vf (loop_vec_in
   stmt_info_for_cost *si;
   void *data = LOOP_VINFO_TARGET_COST_DATA (loop_vinfo);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "=== vect_update_slp_costs_according_to_vf ===");

@@ -2800,7 +2800,7 @@ vect_get_mask_element (gimple stmt, int first_mask
      the next vector as well.  */
   if (only_one_vec && *current_mask_element >= mask_nunits)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "permutation requires at least two vectors ");
@@ -2818,7 +2818,7 @@ vect_get_mask_element (gimple stmt, int first_mask
           /* We either need the first vector too or have already moved to the
              next vector. In both cases, this permutation needs three
              vectors.  */
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "permutation requires at "
@@ -2884,7 +2884,7 @@ vect_transform_slp_perm_load (gimple stmt, VEC (tr

   if (!can_vec_perm_p (mode, false, NULL))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "no vect permute for ");
@@ -2964,7 +2964,7 @@ vect_transform_slp_perm_load (gimple stmt, VEC (tr

   if (!can_vec_perm_p (mode, false, mask))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION,
    vect_location,
@@ -3068,7 +3068,7 @@ vect_schedule_slp_instance (slp_tree node, slp_ins
       SLP_TREE_NUMBER_OF_VEC_STMTS (node) = vec_stmts_size;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE,vect_location,
        "------>vectorizing SLP node starting from: ");
@@ -3177,7 +3177,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_ve
       /* Schedule the tree of INSTANCE.  */
       is_store = vect_schedule_slp_instance (SLP_INSTANCE_TREE (instance),
                                              instance, vf);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "vectorizing stmts using SLP.");
     }
@@ -3222,7 +3222,7 @@ vect_slp_transform_bb (basic_block bb)

   gcc_assert (bb_vinfo);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "SLPing BB\n");

   for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
@@ -3230,7 +3230,7 @@ vect_slp_transform_bb (basic_block bb)
       gimple stmt = gsi_stmt (si);
       stmt_vec_info stmt_info;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
                            "------>SLPing statement: ");
@@ -3248,7 +3248,7 @@ vect_slp_transform_bb (basic_block bb)
         }
     }

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf (MSG_OPTIMIZED_LOCATIONS, "BASIC BLOCK VECTORIZED\n");

   destroy_bb_vec_info (bb_vinfo);
Richard Guenther - Oct. 24, 2012, 10:09 a.m.
On Wed, Oct 24, 2012 at 2:53 AM, Sharad Singhai <singhai@google.com> wrote:
> Okay, I have updated the patch (attached) to allow inlining of
> dump_enabled_p. I needed to make alt_dump_file extern to for this
> (dump_file was already extern). Also, I moved dump_file definition
> from toplev.c to dumpfile.c, where it seems to logically belong.
>
> Bootstrapped and tested on x86_64. Okay for trunk?

Ok!

Thanks for keeping up with our changing minds ;)

Richard.

> Thanks,
> Sharad
>
> 2012-10-24  Sharad Singhai  <singhai@google.com>
>
>         * dumpfile.c (dump_enabled_p): Make it inline and move the definition
>         to dumpfile.h.
>         (dump_kind_p): Deleted. Functionality replaced by dump_enabled_p.
>         Make alt_dump_file extern.
>         * dumpfile.h (dump_enabled_p): Move inline definition here.
>         (dump_kind_p): Delete declaration.
>         Add extern declaration of alt_dump_file.
>         * toplev.c: Move dump_file and dump_file_name to dumpfile.c.
>         * tree-vect-loop-manip.c: Replace all uses of dump_kind_p with
>         dump_enabled_p.
>         * tree-vectorizer.c: Likewise.
>         * tree-vect-loop.c: Likewise.
>         * tree-vect-data-refs.c: Likewise.
>         * tree-vect-patterns.c: Likewise.
>         * tree-vect-stmts.c: Likewise.
>         * tree-vect-slp.c: Likewise.
>
> Index: dumpfile.c
> ===================================================================
> --- dumpfile.c (revision 192695)
> +++ dumpfile.c (working copy)
> @@ -32,12 +32,18 @@ along with GCC; see the file COPYING3.  If not see
>
>  static int pflags;                   /* current dump_flags */
>  static int alt_flags;                /* current opt_info flags */
> -static FILE *alt_dump_file = NULL;
>
>  static void dump_loc (int, FILE *, source_location);
>  static int dump_phase_enabled_p (int);
>  static FILE *dump_open_alternate_stream (struct dump_file_info *);
>
> +/* These are currently used for communicating between passes.
> +   However, instead of accessing them directly, the passes can use
> +   dump_printf () for dumps.  */
> +FILE *dump_file = NULL;
> +FILE *alt_dump_file = NULL;
> +const char *dump_file_name;
> +
>  /* Table of tree dump switches. This must be consistent with the
>     TREE_DUMP_INDEX enumeration in dumpfile.h.  */
>  static struct dump_file_info dump_files[TDI_end] =
> @@ -514,14 +520,6 @@ dump_phase_enabled_p (int phase)
>      }
>  }
>
> -/* Return true if any of the dumps are enabled, false otherwise. */
> -
> -inline bool
> -dump_enabled_p (void)
> -{
> -  return (dump_file || alt_dump_file);
> -}
> -
>  /* Returns nonzero if tree dump PHASE has been initialized.  */
>
>  int
> @@ -836,16 +834,6 @@ opt_info_switch_p (const char *arg)
>    return opt_info_enable_all ((TDF_TREE | TDF_RTL | TDF_IPA), flags, filename);
>  }
>
> -/* Return true if any dumps are enabled for the given MSG_TYPE, false
> -   otherwise.  */
> -
> -bool
> -dump_kind_p (int msg_type)
> -{
> -  return (dump_file && (msg_type & pflags))
> -    || (alt_dump_file && (msg_type & alt_flags));
> -}
> -
>  /* Print basic block on the dump streams.  */
>
>  void
> Index: dumpfile.h
> ===================================================================
> --- dumpfile.h (revision 192695)
> +++ dumpfile.h (working copy)
> @@ -108,7 +108,6 @@ struct dump_file_info
>    int num;                      /* dump file number */
>  };
>
> -
>  /* In dumpfile.c */
>  extern char *get_dump_file_name (int);
>  extern int dump_initialized_p (int);
> @@ -120,8 +119,6 @@ extern void dump_node (const_tree, int, FILE *);
>  extern int dump_switch_p (const char *);
>  extern int opt_info_switch_p (const char *);
>  extern const char *dump_flag_name (int);
> -extern bool dump_kind_p (int);
> -extern inline bool dump_enabled_p (void);
>  extern void dump_printf (int, const char *, ...) ATTRIBUTE_PRINTF_2;
>  extern void dump_printf_loc (int, source_location,
>                               const char *, ...) ATTRIBUTE_PRINTF_3;
> @@ -142,10 +139,19 @@ extern void dump_bb (FILE *, basic_block, int, int
>
>  /* Global variables used to communicate with passes.  */
>  extern FILE *dump_file;
> +extern FILE *alt_dump_file;
>  extern int dump_flags;
>  extern const char *dump_file_name;
>
>  /* Return the dump_file_info for the given phase.  */
>  extern struct dump_file_info *get_dump_file_info (int);
>
> +/* Return true if any of the dumps are enabled, false otherwise. */
> +
> +static inline bool
> +dump_enabled_p (void)
> +{
> +  return (dump_file || alt_dump_file);
> +}
> +
>  #endif /* GCC_DUMPFILE_H */
> Index: toplev.c
> ===================================================================
> --- toplev.c (revision 192695)
> +++ toplev.c (working copy)
> @@ -169,8 +169,6 @@ const char *user_label_prefix;
>  FILE *asm_out_file;
>  FILE *aux_info_file;
>  FILE *stack_usage_file = NULL;
> -FILE *dump_file = NULL;
> -const char *dump_file_name;
>
>  /* The current working directory of a translation.  It's generally the
>     directory from which compilation was initiated, but a preprocessed
> Index: tree-vect-loop-manip.c
> ===================================================================
> --- tree-vect-loop-manip.c (revision 192695)
> +++ tree-vect-loop-manip.c (working copy)
> @@ -792,7 +792,7 @@ slpeel_make_loop_iterate_ntimes (struct loop *loop
>    free_stmt_vec_info (orig_cond);
>
>    loop_loc = find_loop_location (loop);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        if (LOCATION_LOCUS (loop_loc) != UNKNOWN_LOC)
>   dump_printf (MSG_NOTE, "\nloop at %s:%d: ", LOC_FILE (loop_loc),
> @@ -1683,7 +1683,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
>
>    /* Analyze phi functions of the loop header.  */
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "vect_can_advance_ivs_p:");
>    for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
>      {
> @@ -1691,7 +1691,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
>        tree evolution_part;
>
>        phi = gsi_stmt (gsi);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>            dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
>            dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
> @@ -1702,7 +1702,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
>
>        if (virtual_operand_p (PHI_RESULT (phi)))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "virtual phi. skip.");
>    continue;
> @@ -1712,7 +1712,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
>
>        if (STMT_VINFO_DEF_TYPE (vinfo_for_stmt (phi)) == vect_reduction_def)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "reduc phi. skip.");
>            continue;
> @@ -1725,13 +1725,13 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
>
>        if (!access_fn)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "No Access function.");
>    return false;
>   }
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                             "Access function of PHI: ");
> @@ -1742,7 +1742,7 @@ vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
>
>        if (evolution_part == NULL_TREE)
>          {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf (MSG_MISSED_OPTIMIZATION, "No evolution.");
>    return false;
>          }
> @@ -1827,7 +1827,7 @@ vect_update_ivs_after_vectorizer (loop_vec_info lo
>
>        phi = gsi_stmt (gsi);
>        phi1 = gsi_stmt (gsi1);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_update_ivs_after_vectorizer: phi: ");
> @@ -1837,7 +1837,7 @@ vect_update_ivs_after_vectorizer (loop_vec_info lo
>        /* Skip virtual phi's.  */
>        if (virtual_operand_p (PHI_RESULT (phi)))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "virtual phi. skip.");
>    continue;
> @@ -1847,7 +1847,7 @@ vect_update_ivs_after_vectorizer (loop_vec_info lo
>        stmt_info = vinfo_for_stmt (phi);
>        if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
>          {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "reduc phi. skip.");
>            continue;
> @@ -1910,7 +1910,7 @@ vect_do_peeling_for_loop_bound (loop_vec_info loop
>    tree cond_expr = NULL_TREE;
>    gimple_seq cond_expr_stmt_list = NULL;
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "=== vect_do_peeling_for_loop_bound ===");
>
> @@ -2022,7 +2022,7 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loo
>      {
>        int npeel = LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo);
>
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                           "known peeling = %d.", npeel);
>
> @@ -2076,7 +2076,7 @@ vect_gen_niters_for_prolog_loop (loop_vec_info loo
>    if (TREE_CODE (loop_niters) != INTEGER_CST)
>      iters = fold_build2 (MIN_EXPR, niters_type, iters, loop_niters);
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                         "niters for prolog loop: ");
> @@ -2134,7 +2134,7 @@ vect_update_inits_of_drs (loop_vec_info loop_vinfo
>    VEC (data_reference_p, heap) *datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
>    struct data_reference *dr;
>
> - if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> + if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "=== vect_update_inits_of_dr ===");
>
> @@ -2163,7 +2163,7 @@ vect_do_peeling_for_alignment (loop_vec_info loop_
>    int max_iter;
>    int bound = 0;
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "=== vect_do_peeling_for_alignment ===");
>
> @@ -2475,7 +2475,7 @@ vect_create_cond_for_alias_checks (loop_vec_info l
>        segment_length_a = vect_vfa_segment_size (dr_a, length_factor);
>        segment_length_b = vect_vfa_segment_size (dr_b, length_factor);
>
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                             "create runtime check for data references ");
> @@ -2506,7 +2506,7 @@ vect_create_cond_for_alias_checks (loop_vec_info l
>   *cond_expr = part_cond_expr;
>      }
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>       "created %u versioning for alias checks.\n",
>       VEC_length (ddr_p, may_alias_ddrs));
> Index: tree-vectorizer.c
> ===================================================================
> --- tree-vectorizer.c (revision 192695)
> +++ tree-vectorizer.c (working copy)
> @@ -107,7 +107,7 @@ vectorize_loops (void)
>   loop_vec_info loop_vinfo;
>   vect_location = find_loop_location (loop);
>          if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC
> -    && dump_kind_p (MSG_ALL))
> +    && dump_enabled_p ())
>    dump_printf (MSG_ALL, "\nAnalyzing loop at %s:%d\n",
>                         LOC_FILE (vect_location), LOC_LINE (vect_location));
>
> @@ -118,7 +118,7 @@ vectorize_loops (void)
>    continue;
>
>          if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC
> -    && dump_kind_p (MSG_ALL))
> +    && dump_enabled_p ())
>            dump_printf (MSG_ALL, "\n\nVectorizing loop at %s:%d\n",
>                         LOC_FILE (vect_location), LOC_LINE (vect_location));
>   vect_transform_loop (loop_vinfo);
> @@ -128,8 +128,8 @@ vectorize_loops (void)
>    vect_location = UNKNOWN_LOC;
>
>    statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);
> -  if (dump_kind_p (MSG_ALL)
> -      || (num_vectorized_loops > 0 && dump_kind_p (MSG_ALL)))
> +  if (dump_enabled_p ()
> +      || (num_vectorized_loops > 0 && dump_enabled_p ()))
>      dump_printf_loc (MSG_ALL, vect_location,
>                       "vectorized %u loops in function.\n",
>                       num_vectorized_loops);
> @@ -170,7 +170,7 @@ execute_vect_slp (void)
>        if (vect_slp_analyze_bb (bb))
>          {
>            vect_slp_transform_bb (bb);
> -          if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>       "basic block vectorized using SLP\n");
>          }
> Index: tree-vect-loop.c
> ===================================================================
> --- tree-vect-loop.c (revision 192695)
> +++ tree-vect-loop.c (working copy)
> @@ -187,7 +187,7 @@ vect_determine_vectorization_factor (loop_vec_info
>    gimple_stmt_iterator pattern_def_si = gsi_none ();
>    bool analyze_pattern_stmt = false;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_determine_vectorization_factor ===");
>
> @@ -199,7 +199,7 @@ vect_determine_vectorization_factor (loop_vec_info
>   {
>    phi = gsi_stmt (si);
>    stmt_info = vinfo_for_stmt (phi);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "==> examining phi: ");
>        dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
> @@ -212,7 +212,7 @@ vect_determine_vectorization_factor (loop_vec_info
>        gcc_assert (!STMT_VINFO_VECTYPE (stmt_info));
>                scalar_type = TREE_TYPE (PHI_RESULT (phi));
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                                     "get vectype for scalar type:  ");
> @@ -222,7 +222,7 @@ vect_determine_vectorization_factor (loop_vec_info
>        vectype = get_vectype_for_scalar_type (scalar_type);
>        if (!vectype)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                         "not vectorized: unsupported "
> @@ -234,14 +234,14 @@ vect_determine_vectorization_factor (loop_vec_info
>   }
>        STMT_VINFO_VECTYPE (stmt_info) = vectype;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
>    dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
>   }
>
>        nunits = TYPE_VECTOR_SUBPARTS (vectype);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location, "nunits = %d", nunits);
>
>        if (!vectorization_factor
> @@ -261,7 +261,7 @@ vect_determine_vectorization_factor (loop_vec_info
>
>            stmt_info = vinfo_for_stmt (stmt);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "==> examining statement: ");
> @@ -281,7 +281,7 @@ vect_determine_vectorization_factor (loop_vec_info
>                  {
>                    stmt = pattern_stmt;
>                    stmt_info = vinfo_for_stmt (pattern_stmt);
> -                  if (dump_kind_p (MSG_NOTE))
> +                  if (dump_enabled_p ())
>                      {
>                        dump_printf_loc (MSG_NOTE, vect_location,
>                                         "==> examining pattern statement: ");
> @@ -290,7 +290,7 @@ vect_determine_vectorization_factor (loop_vec_info
>                  }
>                else
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location, "skip.");
>                    gsi_next (&si);
>            continue;
> @@ -330,7 +330,7 @@ vect_determine_vectorization_factor (loop_vec_info
>
>    if (!gsi_end_p (pattern_def_si))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                                             "==> examining pattern def stmt: ");
> @@ -353,7 +353,7 @@ vect_determine_vectorization_factor (loop_vec_info
>
>    if (gimple_get_lhs (stmt) == NULL_TREE)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: irregular stmt.");
> @@ -365,7 +365,7 @@ vect_determine_vectorization_factor (loop_vec_info
>
>    if (VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: vector stmt in loop:");
> @@ -389,7 +389,7 @@ vect_determine_vectorization_factor (loop_vec_info
>      {
>        gcc_assert (!STMT_VINFO_DATA_REF (stmt_info));
>        scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                                     "get vectype for scalar type:  ");
> @@ -398,7 +398,7 @@ vect_determine_vectorization_factor (loop_vec_info
>        vectype = get_vectype_for_scalar_type (scalar_type);
>        if (!vectype)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                         "not vectorized: unsupported "
> @@ -417,7 +417,7 @@ vect_determine_vectorization_factor (loop_vec_info
>       support one vector size per loop).  */
>    scalar_type = vect_get_smallest_scalar_type (stmt, &dummy,
>         &dummy);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "get vectype for scalar type:  ");
> @@ -426,7 +426,7 @@ vect_determine_vectorization_factor (loop_vec_info
>    vf_vectype = get_vectype_for_scalar_type (scalar_type);
>    if (!vf_vectype)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: unsupported data-type ");
> @@ -439,7 +439,7 @@ vect_determine_vectorization_factor (loop_vec_info
>    if ((GET_MODE_SIZE (TYPE_MODE (vectype))
>         != GET_MODE_SIZE (TYPE_MODE (vf_vectype))))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: different sized vector "
> @@ -453,14 +453,14 @@ vect_determine_vectorization_factor (loop_vec_info
>        return false;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
>        dump_generic_expr (MSG_NOTE, TDF_SLIM, vf_vectype);
>      }
>
>    nunits = TYPE_VECTOR_SUBPARTS (vf_vectype);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "nunits = %d", nunits);
>    if (!vectorization_factor
>        || (nunits > vectorization_factor))
> @@ -475,12 +475,12 @@ vect_determine_vectorization_factor (loop_vec_info
>      }
>
>    /* TODO: Analyze cost. Decide if worth while to vectorize.  */
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "vectorization factor = %d",
>                       vectorization_factor);
>    if (vectorization_factor <= 1)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not vectorized: unsupported data-type");
>        return false;
> @@ -517,7 +517,7 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tre
>    step_expr = evolution_part;
>    init_expr = unshare_expr (initial_condition_in_loop_num (access_fn,
> loop_nb));
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "step: ");
>        dump_generic_expr (MSG_NOTE, TDF_SLIM, step_expr);
> @@ -530,7 +530,7 @@ vect_is_simple_iv_evolution (unsigned loop_nb, tre
>
>    if (TREE_CODE (step_expr) != INTEGER_CST)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "step unknown.");
>        return false;
> @@ -555,7 +555,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>    gimple_stmt_iterator gsi;
>    bool double_reduc;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_analyze_scalar_cycles ===");
>
> @@ -569,7 +569,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>        tree def = PHI_RESULT (phi);
>        stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
>    dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
> @@ -587,7 +587,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>        if (access_fn)
>   {
>    STRIP_NOPS (access_fn);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "Access function of PHI: ");
> @@ -606,7 +606,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>
>        gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) !=
> NULL_TREE);
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location, "Detected induction.");
>        STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
>      }
> @@ -621,7 +621,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>        gimple reduc_stmt;
>        bool nested_cycle;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
>            dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
> @@ -637,7 +637,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>          {
>            if (double_reduc)
>              {
> -              if (dump_kind_p (MSG_NOTE))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_NOTE, vect_location,
>   "Detected double reduction.");
>
> @@ -649,7 +649,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>              {
>                if (nested_cycle)
>                  {
> -                  if (dump_kind_p (MSG_NOTE))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_NOTE, vect_location,
>       "Detected vectorizable nested cycle.");
>
> @@ -659,7 +659,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>                  }
>                else
>                  {
> -                  if (dump_kind_p (MSG_NOTE))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_NOTE, vect_location,
>       "Detected reduction.");
>
> @@ -675,7 +675,7 @@ vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
>              }
>          }
>        else
> -        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Unknown def-use cycle pattern.");
>      }
> @@ -737,7 +737,7 @@ vect_get_loop_niters (struct loop *loop, tree *num
>  {
>    tree niters;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "=== get_loop_niters ===");
>    niters = number_of_exit_cond_executions (loop);
> @@ -747,7 +747,7 @@ vect_get_loop_niters (struct loop *loop, tree *num
>      {
>        *number_of_iterations = niters;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location, "==> get_loop_niters:");
>            dump_generic_expr (MSG_NOTE, TDF_SLIM, *number_of_iterations);
> @@ -995,7 +995,7 @@ vect_analyze_loop_1 (struct loop *loop)
>  {
>    loop_vec_info loop_vinfo;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "===== analyze_loop_nest_1 =====");
>
> @@ -1004,7 +1004,7 @@ vect_analyze_loop_1 (struct loop *loop)
>    loop_vinfo = vect_analyze_loop_form (loop);
>    if (!loop_vinfo)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad inner-loop form.");
>        return NULL;
> @@ -1030,7 +1030,7 @@ vect_analyze_loop_form (struct loop *loop)
>    tree number_of_iterations = NULL;
>    loop_vec_info inner_loop_vinfo = NULL;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "=== vect_analyze_loop_form ===");
>
> @@ -1054,7 +1054,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>        if (loop->num_nodes != 2)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: control flow in loop.");
>            return NULL;
> @@ -1062,7 +1062,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>        if (empty_block_p (loop->header))
>      {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: empty loop.");
>        return NULL;
> @@ -1092,7 +1092,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>        if ((loop->inner)->inner || (loop->inner)->next)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: multiple nested loops.");
>    return NULL;
> @@ -1102,7 +1102,7 @@ vect_analyze_loop_form (struct loop *loop)
>        inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
>        if (!inner_loop_vinfo)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: Bad inner loop.");
>    return NULL;
> @@ -1111,7 +1111,7 @@ vect_analyze_loop_form (struct loop *loop)
>        if (!expr_invariant_in_loop_p (loop,
>   LOOP_VINFO_NITERS (inner_loop_vinfo)))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: inner-loop count not invariant.");
>    destroy_loop_vec_info (inner_loop_vinfo, true);
> @@ -1120,7 +1120,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>        if (loop->num_nodes != 5)
>          {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: control flow in loop.");
>    destroy_loop_vec_info (inner_loop_vinfo, true);
> @@ -1136,14 +1136,14 @@ vect_analyze_loop_form (struct loop *loop)
>    || !single_exit (innerloop)
>    || single_exit (innerloop)->dest !=  EDGE_PRED (loop->latch, 0)->src)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: unsupported outerloop form.");
>    destroy_loop_vec_info (inner_loop_vinfo, true);
>    return NULL;
>   }
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "Considering outer-loop vectorization.");
>      }
> @@ -1151,7 +1151,7 @@ vect_analyze_loop_form (struct loop *loop)
>    if (!single_exit (loop)
>        || EDGE_COUNT (loop->header->preds) != 2)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            if (!single_exit (loop))
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -1172,7 +1172,7 @@ vect_analyze_loop_form (struct loop *loop)
>    if (!empty_block_p (loop->latch)
>          || !gimple_seq_empty_p (phi_nodes (loop->latch)))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: unexpected loop form.");
>        if (inner_loop_vinfo)
> @@ -1187,12 +1187,12 @@ vect_analyze_loop_form (struct loop *loop)
>        if (!(e->flags & EDGE_ABNORMAL))
>   {
>    split_loop_exit_edge (e);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf (MSG_NOTE, "split exit edge.");
>   }
>        else
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: abnormal loop exit edge.");
>    if (inner_loop_vinfo)
> @@ -1204,7 +1204,7 @@ vect_analyze_loop_form (struct loop *loop)
>    loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
>    if (!loop_cond)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: complicated exit condition.");
>        if (inner_loop_vinfo)
> @@ -1214,7 +1214,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>    if (!number_of_iterations)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: number of iterations cannot be "
>   "computed.");
> @@ -1225,7 +1225,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>    if (chrec_contains_undetermined (number_of_iterations))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "Infinite number of iterations.");
>        if (inner_loop_vinfo)
> @@ -1235,7 +1235,7 @@ vect_analyze_loop_form (struct loop *loop)
>
>    if (!NITERS_KNOWN_P (number_of_iterations))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>     "Symbolic number of iterations is ");
> @@ -1244,7 +1244,7 @@ vect_analyze_loop_form (struct loop *loop)
>      }
>    else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: number of iterations = 0.");
>        if (inner_loop_vinfo)
> @@ -1292,7 +1292,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>    HOST_WIDE_INT estimated_niter;
>    int min_profitable_estimate;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "=== vect_analyze_loop_operations ===");
>
> @@ -1328,7 +1328,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>   LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));
>
>        LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>   "Updating vectorization factor to %d ",
>   vectorization_factor);
> @@ -1344,7 +1344,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>            ok = true;
>
>            stmt_info = vinfo_for_stmt (phi);
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_NOTE, vect_location, "examining phi: ");
>                dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
> @@ -1363,7 +1363,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>                    && STMT_VINFO_DEF_TYPE (stmt_info)
>                       != vect_double_reduction_def)
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "Unsupported loop-closed phi in "
>       "outer-loop.");
> @@ -1405,7 +1405,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>            if (STMT_VINFO_LIVE_P (stmt_info))
>              {
>                /* FORNOW: not yet supported.  */
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: value used after loop.");
>                return false;
> @@ -1415,7 +1415,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>                && STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
>              {
>                /* A scalar-dependence cycle that we don't support.  */
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: scalar dependence cycle.");
>                return false;
> @@ -1430,7 +1430,7 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>
>            if (!ok)
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "not vectorized: relevant phi not "
> @@ -1456,18 +1456,17 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>       touching this loop.  */
>    if (!need_to_vectorize)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "All the computation can be taken out of the loop.");
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: redundant loop. no profit to "
>   "vectorize.");
>        return false;
>      }
>
> -  if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
> -      && dump_kind_p (MSG_NOTE))
> +  if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) && dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "vectorization_factor = %d, niters = "
>       HOST_WIDE_INT_PRINT_DEC, vectorization_factor,
> @@ -1478,10 +1477,10 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>        || ((max_niter = max_stmt_executions_int (loop)) != -1
>    && (unsigned HOST_WIDE_INT) max_niter < vectorization_factor))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: iteration count too small.");
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: iteration count smaller than "
>   "vectorization factor.");
> @@ -1500,10 +1499,10 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>
>    if (min_profitable_iters < 0)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: vectorization not profitable.");
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: vector version will never be "
>   "profitable.");
> @@ -1526,10 +1525,10 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>    if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
>        && LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: vectorization not profitable.");
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "not vectorized: iteration count smaller than user "
>   "specified loop bound parameter or minimum profitable "
> @@ -1541,11 +1540,11 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>        && ((unsigned HOST_WIDE_INT) estimated_niter
>            <= MAX (th, (unsigned)min_profitable_estimate)))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: estimated iteration count too "
>                           "small.");
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "not vectorized: estimated iteration count smaller "
>                           "than specified loop bound parameter or minimum "
> @@ -1558,18 +1557,18 @@ vect_analyze_loop_operations (loop_vec_info loop_v
>        || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
>        || LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location, "epilog loop required.");
>        if (!vect_can_advance_ivs_p (loop_vinfo))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: can't create epilog loop 1.");
>            return false;
>          }
>        if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not vectorized: can't create epilog loop 2.");
>            return false;
> @@ -1602,7 +1601,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad data references.");
>        return false;
> @@ -1620,7 +1619,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "unexpected pattern.");
>        return false;
> @@ -1635,7 +1634,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    if (!ok
>        || max_vf < min_vf)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "bad data dependence.");
>        return false;
> @@ -1644,14 +1643,14 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_determine_vectorization_factor (loop_vinfo);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "can't determine vectorization factor.");
>        return false;
>      }
>    if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad data dependence.");
>        return false;
> @@ -1663,7 +1662,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad data alignment.");
>        return false;
> @@ -1675,7 +1674,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad data access.");
>        return false;
> @@ -1687,7 +1686,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_prune_runtime_alias_test_list (loop_vinfo);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "too long list of versioning for alias "
>   "run-time tests.");
> @@ -1700,7 +1699,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_enhance_data_refs_alignment (loop_vinfo);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad data alignment.");
>        return false;
> @@ -1725,7 +1724,7 @@ vect_analyze_loop_2 (loop_vec_info loop_vinfo)
>    ok = vect_analyze_loop_operations (loop_vinfo, slp);
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "bad operation or unsupported loop bound.");
>        return false;
> @@ -1749,7 +1748,7 @@ vect_analyze_loop (struct loop *loop)
>    current_vector_size = 0;
>    vector_sizes = targetm.vectorize.autovectorize_vector_sizes ();
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "===== analyze_loop_nest =====");
>
> @@ -1757,7 +1756,7 @@ vect_analyze_loop (struct loop *loop)
>        && loop_vec_info_for_loop (loop_outer (loop))
>        && LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop
> (loop_outer (loop))))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>   "outer-loop already vectorized.");
>        return NULL;
> @@ -1769,7 +1768,7 @@ vect_analyze_loop (struct loop *loop)
>        loop_vinfo = vect_analyze_loop_form (loop);
>        if (!loop_vinfo)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "bad loop form.");
>    return NULL;
> @@ -1791,7 +1790,7 @@ vect_analyze_loop (struct loop *loop)
>
>        /* Try the next biggest vector size.  */
>        current_vector_size = 1 << floor_log2 (vector_sizes);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>   "***** Re-trying analysis with "
>   "vector size %d\n", current_vector_size);
> @@ -2023,7 +2022,7 @@ vect_is_slp_reduction (loop_vec_info loop_info, gi
>                                    == vect_internal_def
>                        && !is_loop_header_bb_p (gimple_bb (def_stmt)))))
>        {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location, "swapping oprnds: ");
>    dump_gimple_stmt (MSG_NOTE, TDF_SLIM, next_stmt, 0);
> @@ -2125,7 +2124,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>
>        if (!flow_bb_inside_loop_p (loop, gimple_bb (use_stmt)))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "intermediate value used outside loop.");
>
> @@ -2137,7 +2136,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>          nloop_uses++;
>        if (nloop_uses > 1)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "reduction used in loop.");
>            return NULL;
> @@ -2146,7 +2145,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>
>    if (TREE_CODE (loop_arg) != SSA_NAME)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "reduction: not ssa_name: ");
> @@ -2158,7 +2157,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>    def_stmt = SSA_NAME_DEF_STMT (loop_arg);
>    if (!def_stmt)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "reduction: no def_stmt.");
>        return NULL;
> @@ -2166,7 +2165,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>
>    if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_gimple_stmt (MSG_NOTE, TDF_SLIM, def_stmt, 0);
>        return NULL;
>      }
> @@ -2194,7 +2193,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>   nloop_uses++;
>        if (nloop_uses > 1)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "reduction used in loop.");
>    return NULL;
> @@ -2210,7 +2209,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>        if (gimple_phi_num_args (def_stmt) != 1
>            || TREE_CODE (op1) != SSA_NAME)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "unsupported phi node definition.");
>
> @@ -2223,7 +2222,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>            && flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
>            && is_gimple_assign (def1))
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              report_vect_op (MSG_NOTE, def_stmt,
>      "detected double reduction: ");
>
> @@ -2250,7 +2249,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>    if (check_reduction
>        && (!commutative_tree_code (code) || !associative_tree_code (code)))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>   "reduction: not commutative/associative: ");
>        return NULL;
> @@ -2260,7 +2259,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>      {
>        if (code != COND_EXPR)
>          {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>      "reduction: not binary operation: ");
>
> @@ -2279,7 +2278,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>
>        if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>      "reduction: uses not ssa_names: ");
>
> @@ -2293,7 +2292,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>
>        if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>      "reduction: uses not ssa_names: ");
>
> @@ -2311,7 +2310,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>        || (op4 && TREE_CODE (op4) == SSA_NAME
>            && !types_compatible_p (type, TREE_TYPE (op4))))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>     "reduction: multiple types: operation type: ");
> @@ -2353,7 +2352,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>        && check_reduction)
>      {
>        /* Changing the order of operations changes the semantics.  */
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>   "reduction: unsafe fp math optimization: ");
>        return NULL;
> @@ -2362,7 +2361,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>     && check_reduction)
>      {
>        /* Changing the order of operations changes the semantics.  */
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>   "reduction: unsafe int math optimization: ");
>        return NULL;
> @@ -2370,7 +2369,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>    else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
>      {
>        /* Changing the order of operations changes the semantics.  */
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>   "reduction: unsafe fixed-point math optimization: ");
>        return NULL;
> @@ -2407,7 +2406,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>    if (code != COND_EXPR
>        && ((!def1 || gimple_nop_p (def1)) && (!def2 || gimple_nop_p (def2))))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   report_vect_op (MSG_NOTE, def_stmt, "reduction: no defs for operands: ");
>        return NULL;
>      }
> @@ -2429,7 +2428,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>                            == vect_internal_def
>                && !is_loop_header_bb_p (gimple_bb (def1)))))))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
>        return def_stmt;
>      }
> @@ -2452,7 +2451,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>            /* Swap operands (just for simplicity - so that the rest of the code
>       can assume that the reduction variable is always the last (second)
>       argument).  */
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>      report_vect_op (MSG_NOTE, def_stmt,
>                "detected reduction: need to swap operands: ");
>
> @@ -2464,7 +2463,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>          }
>        else
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
>          }
>
> @@ -2474,14 +2473,14 @@ vect_is_simple_reduction_1 (loop_vec_info loop_inf
>    /* Try to find SLP reduction chain.  */
>    if (check_reduction && vect_is_slp_reduction (loop_info, phi, def_stmt))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          report_vect_op (MSG_NOTE, def_stmt,
>   "reduction: detected reduction chain: ");
>
>        return def_stmt;
>      }
>
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
>      "reduction: unknown pattern: ");
>
> @@ -2589,7 +2588,7 @@ vect_get_known_peeling_cost (loop_vec_info loop_vi
>    if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
>      {
>        *peel_iters_epilogue = vf/2;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "cost model: epilogue peel iters set to vf/2 "
>   "because loop iterations are unknown .");
> @@ -2882,7 +2881,7 @@ vect_estimate_min_profitable_iters (loop_vec_info
>    /* vector version will never be profitable.  */
>    else
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "cost model: the vector iteration cost = %d "
>   "divided by the scalar iteration cost = %d "
> @@ -2893,7 +2892,7 @@ vect_estimate_min_profitable_iters (loop_vec_info
>        return;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "Cost model analysis: \n");
>        dump_printf (MSG_NOTE, "  Vector inside of loop cost: %d\n",
> @@ -2925,7 +2924,7 @@ vect_estimate_min_profitable_iters (loop_vec_info
>         then skip the vectorized loop.  */
>    min_profitable_iters--;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "  Runtime profitability threshold = %d\n",
> min_profitable_iters);
>
> @@ -2950,7 +2949,7 @@ vect_estimate_min_profitable_iters (loop_vec_info
>      }
>    min_profitable_estimate --;
>    min_profitable_estimate = MAX (min_profitable_estimate,
> min_profitable_iters);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "  Static estimate profitability threshold = %d\n",
>                        min_profitable_iters);
> @@ -3010,7 +3009,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info
>    vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
>    if (!vectype)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "unsupported data-type ");
> @@ -3081,7 +3080,7 @@ vect_model_reduction_cost (stmt_vec_info stmt_info
>   }
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf (MSG_NOTE,
>                   "vect_model_reduction_cost: inside_cost = %d, "
>                   "prologue_cost = %d, epilogue_cost = %d .", inside_cost,
> @@ -3110,7 +3109,7 @@ vect_model_induction_cost (stmt_vec_info stmt_info
>    prologue_cost = add_stmt_cost (target_cost_data, 2, scalar_to_vec,
>   stmt_info, 0, vect_prologue);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_model_induction_cost: inside_cost = %d, "
>                       "prologue_cost = %d .", inside_cost, prologue_cost);
> @@ -3239,7 +3238,7 @@ get_initial_def_for_induction (gimple iv_phi)
>    new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
>    gcc_assert (!new_bb);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>         "created new init_stmt: ");
> @@ -3382,7 +3381,7 @@ get_initial_def_for_induction (gimple iv_phi)
>        && !STMT_VINFO_LIVE_P (stmt_vinfo));
>
>    STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>         "vector of inductions after inner-loop:");
> @@ -3392,7 +3391,7 @@ get_initial_def_for_induction (gimple iv_phi)
>      }
>
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>         "transform induction: created def-use cycle: ");
> @@ -3800,7 +3799,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap)
>
>            add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_NOTE, vect_location,
>         "transform reduction: created def-use cycle: ");
> @@ -4001,7 +4000,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap)
>        /*** Case 1:  Create:
>             v_out2 = reduc_expr <v_out1>  */
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "Reduce using direct vector reduction.");
>
> @@ -4052,7 +4051,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap)
>                    Create:  va = vop <va, va'>
>                  }  */
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>       "Reduce using vector shifts");
>
> @@ -4093,7 +4092,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap)
>                   Create:  s = op <s, s'>  // For non SLP cases
>                 }  */
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>       "Reduce using scalar code. ");
>
> @@ -4184,7 +4183,7 @@ vect_create_epilog_for_reduction (VEC (tree, heap)
>      {
>        tree rhs;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "extract scalar result");
>
> @@ -4423,7 +4422,7 @@ vect_finalize_reduction:
>                                 UNKNOWN_LOCATION);
>                    add_phi_arg (vect_phi, PHI_RESULT (inner_phi),
>                                 loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
> -                  if (dump_kind_p (MSG_NOTE))
> +                  if (dump_enabled_p ())
>                      {
>                        dump_printf_loc (MSG_NOTE, vect_location,
>         "created double reduction phi node: ");
> @@ -4773,7 +4772,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>      {
>        if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0, NULL))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "unsupported condition in reduction");
>
> @@ -4788,7 +4787,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>        optab = optab_for_tree_code (code, vectype_in, optab_default);
>        if (!optab)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "no optab.");
>
> @@ -4797,7 +4796,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>
>        if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf (MSG_NOTE, "op not supported by target.");
>
>            if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
> @@ -4805,7 +4804,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>            < vect_min_worthwhile_factor (code))
>              return false;
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>        dump_printf (MSG_NOTE, "proceeding using word mode.");
>          }
>
> @@ -4814,7 +4813,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>            && LOOP_VINFO_VECT_FACTOR (loop_vinfo)
>         < vect_min_worthwhile_factor (code))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "not worthwhile without SIMD support.");
>
> @@ -4895,7 +4894,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>                                           optab_default);
>        if (!reduc_optab)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "no optab for reduction.");
>
> @@ -4905,7 +4904,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>        if (reduc_optab
>            && optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "reduc op not supported by target.");
>
> @@ -4916,7 +4915,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>      {
>        if (!nested_cycle || double_reduc)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "no reduc code for scalar code.");
>
> @@ -4926,7 +4925,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>
>    if (double_reduc && ncopies > 1)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "multiple types in double reduction");
>
> @@ -4945,7 +4944,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>          ops[1] = fold_convert (TREE_TYPE (ops[0]), ops[1]);
>        else
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "invalid types in dot-prod");
>
> @@ -4963,7 +4962,7 @@ vectorizable_reduction (gimple stmt, gimple_stmt_i
>
>    /** Transform.  **/
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "transform reduction.");
>
>    /* FORNOW: Multiple types are not supported for condition.  */
> @@ -5249,7 +5248,7 @@ vectorizable_induction (gimple phi, gimple_stmt_it
>
>        if (ncopies > 1)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "multiple types in nested loop.");
>    return false;
> @@ -5273,7 +5272,7 @@ vectorizable_induction (gimple phi, gimple_stmt_it
>    if (!(STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
>   && !STMT_VINFO_LIVE_P (exit_phi_vinfo)))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "inner-loop induction only used outside "
>   "of the outer vectorized loop.");
> @@ -5297,7 +5296,7 @@ vectorizable_induction (gimple phi, gimple_stmt_it
>    if (!vec_stmt) /* transformation not required.  */
>      {
>        STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "=== vectorizable_induction ===");
>        vect_model_induction_cost (stmt_info, ncopies);
> @@ -5306,7 +5305,7 @@ vectorizable_induction (gimple phi, gimple_stmt_it
>
>    /** Transform.  **/
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "transform induction phi.");
>
>    vec_def = get_initial_def_for_induction (phi);
> @@ -5371,7 +5370,7 @@ vectorizable_live_operation (gimple stmt,
>            && !vect_is_simple_use (op, stmt, loop_vinfo, NULL, &def_stmt, &def,
>    &dt))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "use not simple.");
>            return false;
> @@ -5410,7 +5409,7 @@ vect_loop_kill_debug_uses (struct loop *loop, gimp
>      {
>        if (gimple_debug_bind_p (ustmt))
>   {
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                                       "killing debug use");
>
> @@ -5450,7 +5449,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>    bool check_profitability = false;
>    int th;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "=== vec_transform_loop ===");
>
>    /* Use the more conservative vectorization threshold.  If the number
> @@ -5464,7 +5463,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>    if (th >= LOOP_VINFO_VECT_FACTOR (loop_vinfo) - 1
>        && !LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>   "Profitability threshold is %d loop iterations.", th);
>        check_profitability = true;
> @@ -5525,7 +5524,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>        for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
>          {
>    phi = gsi_stmt (si);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "------>vectorizing phi: ");
> @@ -5544,12 +5543,12 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>
>    if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
>          != (unsigned HOST_WIDE_INT) vectorization_factor)
> -      && dump_kind_p (MSG_NOTE))
> +      && dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "multiple-types.");
>
>    if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location, "transform phi.");
>        vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
>      }
> @@ -5565,7 +5564,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>            else
>              stmt = gsi_stmt (si);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>         "------>vectorizing statement: ");
> @@ -5637,7 +5636,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>
>    if (!gsi_end_p (pattern_def_si))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>     "==> vectorizing pattern def "
> @@ -5664,7 +5663,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>                                                 STMT_VINFO_VECTYPE (stmt_info));
>    if (!STMT_SLP_TYPE (stmt_info)
>        && nunits != (unsigned int) vectorization_factor
> -              && dump_kind_p (MSG_NOTE))
> +              && dump_enabled_p ())
>      /* For SLP VF is set according to unrolling factor, and not to
>         vector size, hence for SLP this print is not valid.  */
>              dump_printf_loc (MSG_NOTE, vect_location,
> @@ -5678,7 +5677,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>   {
>    slp_scheduled = true;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "=== scheduling SLP instances ===");
>
> @@ -5698,7 +5697,7 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>      }
>
>    /* -------- vectorize statement ------------ */
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "transform statement.");
>
>    grouped_store = false;
> @@ -5741,9 +5740,9 @@ vect_transform_loop (loop_vec_info loop_vinfo)
>       until all the loops have been transformed?  */
>    update_ssa (TODO_update_ssa);
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location, "LOOP
> VECTORIZED.");
> -  if (loop->inner && dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (loop->inner && dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>       "OUTER LOOP VECTORIZED.");
>  }
> Index: tree-vect-data-refs.c
> ===================================================================
> --- tree-vect-data-refs.c (revision 192695)
> +++ tree-vect-data-refs.c (working copy)
> @@ -60,7 +60,7 @@ vect_lanes_optab_supported_p (const char *name, co
>
>    if (array_mode == BLKmode)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "no array mode for %s[" HOST_WIDE_INT_PRINT_DEC "]",
>                           GET_MODE_NAME (mode), count);
> @@ -69,14 +69,14 @@ vect_lanes_optab_supported_p (const char *name, co
>
>    if (convert_optab_handler (optab, array_mode, mode) == CODE_FOR_nothing)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "cannot use %s<%s><%s>", name,
>                           GET_MODE_NAME (array_mode), GET_MODE_NAME (mode));
>        return false;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "can use %s<%s><%s>", name, GET_MODE_NAME (array_mode),
>                       GET_MODE_NAME (mode));
> @@ -439,7 +439,7 @@ vect_check_interleaving (struct data_reference *dr
>        if (diff_mod_size == 0)
>   {
>    vect_update_interleaving_chain (drb, dra);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "Detected interleaving ");
> @@ -462,7 +462,7 @@ vect_check_interleaving (struct data_reference *dr
>        if (diff_mod_size == 0)
>   {
>    vect_update_interleaving_chain (dra, drb);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "Detected interleaving ");
> @@ -524,7 +524,7 @@ vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
>    if ((unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS) == 0)
>      return false;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                         "mark for run-time aliasing test between ");
> @@ -535,7 +535,7 @@ vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
>
>    if (optimize_loop_nest_for_size_p (loop))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "versioning not supported when optimizing for size.");
>        return false;
> @@ -544,7 +544,7 @@ vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
>    /* FORNOW: We don't support versioning with outer-loop vectorization.  */
>    if (loop->inner)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "versioning not yet supported for outer-loops.");
>        return false;
> @@ -555,7 +555,7 @@ vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
>    if (TREE_CODE (DR_STEP (DDR_A (ddr))) != INTEGER_CST
>        || TREE_CODE (DR_STEP (DDR_B (ddr))) != INTEGER_CST)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "versioning not yet supported for non-constant "
>                           "step");
> @@ -611,7 +611,7 @@ vect_analyze_data_ref_dependence (struct data_depe
>
>        if (loop_vinfo)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "versioning for alias required: "
> @@ -637,7 +637,7 @@ vect_analyze_data_ref_dependence (struct data_depe
>        if (DR_IS_READ (dra) && DR_IS_READ (drb))
>          return false;
>
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "can't determine dependence between ");
> @@ -666,7 +666,7 @@ vect_analyze_data_ref_dependence (struct data_depe
>        if (dra != drb && vect_check_interleaving (dra, drb))
>          return false;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "determined dependence between ");
> @@ -686,7 +686,7 @@ vect_analyze_data_ref_dependence (struct data_depe
>    /* Loop-based vectorization and known data dependence.  */
>    if (DDR_NUM_DIST_VECTS (ddr) == 0)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "versioning for alias required: "
> @@ -704,13 +704,13 @@ vect_analyze_data_ref_dependence (struct data_depe
>      {
>        int dist = dist_v[loop_depth];
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "dependence distance  = %d.", dist);
>
>        if (dist == 0)
>   {
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "dependence distance == 0 between ");
> @@ -737,7 +737,7 @@ vect_analyze_data_ref_dependence (struct data_depe
>    /* If DDR_REVERSED_P the order of the data-refs in DDR was
>       reversed (to make distance vector positive), and the actual
>       distance is negative.  */
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "dependence distance negative.");
>    continue;
> @@ -749,7 +749,7 @@ vect_analyze_data_ref_dependence (struct data_depe
>    /* The dependence distance requires reduction of the maximal
>       vectorization factor.  */
>    *max_vf = abs (dist);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                               "adjusting maximal vectorization factor to %i",
>                               *max_vf);
> @@ -759,13 +759,13 @@ vect_analyze_data_ref_dependence (struct data_depe
>   {
>    /* Dependence distance does not create dependence, as far as
>       vectorization is concerned, in this case.  */
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                               "dependence distance >= VF.");
>    continue;
>   }
>
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                         "not vectorized, possible dependence "
> @@ -795,7 +795,7 @@ vect_analyze_data_ref_dependences (loop_vec_info l
>    VEC (ddr_p, heap) *ddrs = NULL;
>    struct data_dependence_relation *ddr;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_analyze_dependences ===");
>    if (loop_vinfo)
> @@ -837,7 +837,7 @@ vect_compute_data_ref_alignment (struct data_refer
>    tree misalign;
>    tree aligned_to, alignment;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_compute_data_ref_alignment:");
>
> @@ -870,7 +870,7 @@ vect_compute_data_ref_alignment (struct data_refer
>
>        if (dr_step % GET_MODE_SIZE (TYPE_MODE (vectype)) == 0)
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>                               "inner step divides the vector-size.");
>    misalign = STMT_VINFO_DR_INIT (stmt_info);
> @@ -879,7 +879,7 @@ vect_compute_data_ref_alignment (struct data_refer
>          }
>        else
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "inner step doesn't divide the vector-size.");
>    misalign = NULL_TREE;
> @@ -898,7 +898,7 @@ vect_compute_data_ref_alignment (struct data_refer
>
>        if (dr_step % GET_MODE_SIZE (TYPE_MODE (vectype)) != 0)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "SLP: step doesn't divide the vector-size.");
>    misalign = NULL_TREE;
> @@ -911,7 +911,7 @@ vect_compute_data_ref_alignment (struct data_refer
>    if ((aligned_to && tree_int_cst_compare (aligned_to, alignment) < 0)
>        || !misalign)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "Unknown alignment for access: ");
> @@ -941,7 +941,7 @@ vect_compute_data_ref_alignment (struct data_refer
>        if (!vect_can_force_dr_alignment_p (base, TYPE_ALIGN (vectype))
>    || (TREE_STATIC (base) && flag_section_anchors))
>   {
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "can't force alignment of ref: ");
> @@ -953,7 +953,7 @@ vect_compute_data_ref_alignment (struct data_refer
>        /* Force the alignment of the decl.
>   NOTE: This is the only change to the code we make during
>   the analysis phase, before deciding to vectorize the loop.  */
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location, "force alignment of ");
>            dump_generic_expr (MSG_NOTE, TDF_SLIM, ref);
> @@ -987,7 +987,7 @@ vect_compute_data_ref_alignment (struct data_refer
>    if (!host_integerp (misalign, 1))
>      {
>        /* Negative or overflowed misalignment value.  */
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "unexpected misalign value");
>        return false;
> @@ -995,7 +995,7 @@ vect_compute_data_ref_alignment (struct data_refer
>
>    SET_DR_MISALIGNMENT (dr, TREE_INT_CST_LOW (misalign));
>
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                         "misalign = %d bytes of ref ", DR_MISALIGNMENT (dr));
> @@ -1095,7 +1095,7 @@ vect_update_misalignment_for_peel (struct data_ref
>        return;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "Setting misalignment to -1.");
>    SET_DR_MISALIGNMENT (dr, -1);
>  }
> @@ -1142,7 +1142,7 @@ vect_verify_datarefs_alignment (loop_vec_info loop
>        supportable_dr_alignment = vect_supportable_dr_alignment (dr, false);
>        if (!supportable_dr_alignment)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                if (DR_IS_READ (dr))
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> @@ -1157,8 +1157,7 @@ vect_verify_datarefs_alignment (loop_vec_info loop
>              }
>            return false;
>          }
> -      if (supportable_dr_alignment != dr_aligned
> -          && dump_kind_p (MSG_NOTE))
> +      if (supportable_dr_alignment != dr_aligned && dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "Vectorizing an unaligned access.");
>      }
> @@ -1215,7 +1214,7 @@ vector_alignment_reachable_p (struct data_referenc
>      {
>        HOST_WIDE_INT elmsize =
>   int_cst_value (TYPE_SIZE_UNIT (TREE_TYPE (vectype)));
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                             "data size =" HOST_WIDE_INT_PRINT_DEC, elmsize);
> @@ -1224,7 +1223,7 @@ vector_alignment_reachable_p (struct data_referenc
>   }
>        if (DR_MISALIGNMENT (dr) % elmsize)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "data size does not divide the misalignment.\n");
>    return false;
> @@ -1235,7 +1234,7 @@ vector_alignment_reachable_p (struct data_referenc
>      {
>        tree type = TREE_TYPE (DR_REF (dr));
>        bool is_packed = not_size_aligned (DR_REF (dr));
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "Unknown misalignment, is_packed = %d",is_packed);
>        if (targetm.vectorize.vector_alignment_reachable (type, is_packed))
> @@ -1269,7 +1268,7 @@ vect_get_data_access_cost (struct data_reference *
>    else
>      vect_get_store_cost (dr, ncopies, inside_cost, body_cost_vec);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_get_data_access_cost: inside_cost = %d, "
>                       "outside_cost = %d.", *inside_cost, *outside_cost);
> @@ -1567,7 +1566,7 @@ vect_enhance_data_refs_alignment (loop_vec_info lo
>    unsigned int nelements, mis, same_align_drs_max = 0;
>    stmt_vector_for_cost body_cost_vec = NULL;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_enhance_data_refs_alignment ===");
>
> @@ -1622,7 +1621,7 @@ vect_enhance_data_refs_alignment (loop_vec_info lo
>   and so we can't generate the new base for the pointer.  */
>        if (STMT_VINFO_STRIDE_LOAD_P (stmt_info))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "strided load prevents peeling");
>    do_peeling = false;
> @@ -1738,7 +1737,7 @@ vect_enhance_data_refs_alignment (loop_vec_info lo
>          {
>            if (!aligned_access_p (dr))
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "vector alignment may not be reachable");
>                break;
> @@ -1879,7 +1878,7 @@ vect_enhance_data_refs_alignment (loop_vec_info lo
>    if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
>      npeel /= GROUP_SIZE (stmt_info);
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>                               "Try peeling by %d", npeel);
>          }
> @@ -1951,7 +1950,7 @@ vect_enhance_data_refs_alignment (loop_vec_info lo
>            else
>              LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo) = DR_MISALIGNMENT (dr0);
>    SET_DR_MISALIGNMENT (dr0, 0);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_NOTE, vect_location,
>                                 "Alignment of access forced using peeling.");
> @@ -2077,12 +2076,12 @@ vect_enhance_data_refs_alignment (loop_vec_info lo
>            stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
>            dr = STMT_VINFO_DATA_REF (stmt_info);
>    SET_DR_MISALIGNMENT (dr, 0);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>                               "Alignment of access forced using versioning.");
>          }
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "Versioning for alignment will be applied.");
>
> @@ -2148,7 +2147,7 @@ vect_find_same_alignment_drs (struct data_dependen
>      {
>        int dist = dist_v[loop_depth];
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "dependence distance  = %d.", dist);
>
> @@ -2159,7 +2158,7 @@ vect_find_same_alignment_drs (struct data_dependen
>    /* Two references with distance zero have the same alignment.  */
>    VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_a), drb);
>    VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_b), dra);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>                dump_printf_loc (MSG_NOTE, vect_location,
>                                 "accesses have the same alignment.");
> @@ -2183,7 +2182,7 @@ bool
>  vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo,
>                                    bb_vec_info bb_vinfo)
>  {
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_analyze_data_refs_alignment ===");
>
> @@ -2201,7 +2200,7 @@ vect_analyze_data_refs_alignment (loop_vec_info lo
>
>    if (!vect_compute_data_refs_alignment (loop_vinfo, bb_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not vectorized: can't calculate alignment "
>                           "for data ref.");
> @@ -2254,7 +2253,7 @@ vect_analyze_group_access (struct data_reference *
>   {
>    GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) = stmt;
>    GROUP_SIZE (vinfo_for_stmt (stmt)) = groupsize;
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "Detected single element interleaving ");
> @@ -2265,13 +2264,13 @@ vect_analyze_group_access (struct data_reference *
>
>    if (loop_vinfo)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                                   "Data access with gaps requires scalar "
>                                   "epilogue loop");
>                if (loop->inner)
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                       "Peeling for outer loop is not"
>                                       " supported");
> @@ -2284,7 +2283,7 @@ vect_analyze_group_access (struct data_reference *
>    return true;
>   }
>
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "not consecutive access ");
> @@ -2324,7 +2323,7 @@ vect_analyze_group_access (struct data_reference *
>              {
>                if (DR_IS_WRITE (data_ref))
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                       "Two store stmts share the same dr.");
>                    return false;
> @@ -2335,7 +2334,7 @@ vect_analyze_group_access (struct data_reference *
>                if (GROUP_READ_WRITE_DEPENDENCE (vinfo_for_stmt (next))
>                    || GROUP_READ_WRITE_DEPENDENCE (vinfo_for_stmt (prev)))
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                       "READ_WRITE dependence in interleaving.");
>                    return false;
> @@ -2355,7 +2354,7 @@ vect_analyze_group_access (struct data_reference *
>            next_step = DR_STEP (STMT_VINFO_DATA_REF (vinfo_for_stmt (next)));
>            if (tree_int_cst_compare (step, next_step))
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "not consecutive access in interleaving");
>                return false;
> @@ -2372,7 +2371,7 @@ vect_analyze_group_access (struct data_reference *
>        slp_impossible = true;
>        if (DR_IS_WRITE (data_ref))
>   {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                       "interleaved store with gaps");
>    return false;
> @@ -2401,7 +2400,7 @@ vect_analyze_group_access (struct data_reference *
>           greater than STEP.  */
>        if (dr_step && dr_step < count_in_bytes + gaps * type_size)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "interleaving size is greater than step for ");
> @@ -2424,7 +2423,7 @@ vect_analyze_group_access (struct data_reference *
>              }
>            else
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "interleaved store with gaps");
>                return false;
> @@ -2434,7 +2433,7 @@ vect_analyze_group_access (struct data_reference *
>        /* Check that STEP is a multiple of type size.  */
>        if (dr_step && (dr_step % type_size) != 0)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "step is not a multiple of type size: step ");
> @@ -2450,7 +2449,7 @@ vect_analyze_group_access (struct data_reference *
>          groupsize = count;
>
>        GROUP_SIZE (vinfo_for_stmt (stmt)) = groupsize;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "Detected interleaving of size %d", (int)groupsize);
>
> @@ -2469,13 +2468,13 @@ vect_analyze_group_access (struct data_reference *
>        /* There is a gap in the end of the group.  */
>        if (groupsize - last_accessed_element > 0 && loop_vinfo)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "Data access with gaps requires scalar "
>                               "epilogue loop");
>            if (loop->inner)
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "Peeling for outer loop is not supported");
>                return false;
> @@ -2508,7 +2507,7 @@ vect_analyze_data_ref_access (struct data_referenc
>
>    if (loop_vinfo && !step)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "bad data-ref access in loop");
>        return false;
> @@ -2531,7 +2530,7 @@ vect_analyze_data_ref_access (struct data_referenc
>        step = STMT_VINFO_DR_STEP (stmt_info);
>        if (integer_zerop (step))
>   {
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                               "zero step in outer loop.");
>    if (DR_IS_READ (dr))
> @@ -2557,7 +2556,7 @@ vect_analyze_data_ref_access (struct data_referenc
>
>    if (loop && nested_in_vect_loop_p (loop, stmt))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "grouped access in outer loop.");
>        return false;
> @@ -2588,7 +2587,7 @@ vect_analyze_data_ref_accesses (loop_vec_info loop
>    VEC (data_reference_p, heap) *datarefs;
>    struct data_reference *dr;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_analyze_data_ref_accesses ===");
>
> @@ -2601,7 +2600,7 @@ vect_analyze_data_ref_accesses (loop_vec_info loop
>      if (STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr)))
>          && !vect_analyze_data_ref_access (dr))
>        {
> - if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> + if (dump_enabled_p ())
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "not vectorized: complicated access pattern.");
>
> @@ -2631,7 +2630,7 @@ vect_prune_runtime_alias_test_list (loop_vec_info
>      LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo);
>    unsigned i, j;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_prune_runtime_alias_test_list ===");
>
> @@ -2649,7 +2648,7 @@ vect_prune_runtime_alias_test_list (loop_vec_info
>
>    if (vect_vfa_range_equal (ddr_i, ddr_j))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                                     "found equal ranges ");
> @@ -2677,7 +2676,7 @@ vect_prune_runtime_alias_test_list (loop_vec_info
>    if (VEC_length (ddr_p, ddrs) >
>         (unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION,  vect_location,
>                             "disable versioning for alias - max number of "
> @@ -2964,7 +2963,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>    tree scalar_type;
>    bool res, stop_bb_analysis = false;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_analyze_data_refs ===\n");
>
> @@ -2979,7 +2978,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (!res)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "not vectorized: loop contains function calls"
>                               " or data references that cannot be analyzed");
> @@ -3011,7 +3010,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>        if (!compute_all_dependences (BB_VINFO_DATAREFS (bb_vinfo),
>      &BB_VINFO_DDRS (bb_vinfo), NULL, true))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "not vectorized: basic block contains function"
>                               " calls or data references that cannot be"
> @@ -3035,7 +3034,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (!dr || !DR_REF (dr))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "not vectorized: unhandled data-ref ");
>            return false;
> @@ -3081,7 +3080,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>    if (!gather)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: data ref analysis "
> @@ -3102,7 +3101,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (TREE_CODE (DR_BASE_ADDRESS (dr)) == INTEGER_CST)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "not vectorized: base addr of dr is a "
>                               "constant");
> @@ -3121,7 +3120,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (TREE_THIS_VOLATILE (DR_REF (dr)))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "not vectorized: volatile type ");
> @@ -3140,7 +3139,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (stmt_can_throw_internal (stmt))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "not vectorized: statement can throw an "
> @@ -3163,7 +3162,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>        if (TREE_CODE (DR_REF (dr)) == COMPONENT_REF
>    && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (dr), 1)))
>   {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "not vectorized: statement is bitfield "
> @@ -3189,7 +3188,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (is_gimple_call (stmt))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION,  vect_location,
>                                 "not vectorized: dr in a call ");
> @@ -3232,7 +3231,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>            tree inner_base = build_fold_indirect_ref
>                                  (fold_build_pointer_plus (base, init));
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "analyze in outer-loop: ");
> @@ -3245,7 +3244,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>    if (pbitpos % BITS_PER_UNIT != 0)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "failed: bit offset alignment.\n");
>        return false;
> @@ -3255,7 +3254,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>    if (!simple_iv (loop, loop_containing_stmt (stmt), outer_base,
>                            &base_iv, false))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "failed: evolution of base is not affine.\n");
>        return false;
> @@ -3278,7 +3277,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>    else if (!simple_iv (loop, loop_containing_stmt (stmt), poffset,
>                                 &offset_iv, false))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "evolution of offset is not affine.\n");
>        return false;
> @@ -3303,7 +3302,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>    STMT_VINFO_DR_ALIGNED_TO (stmt_info) =
>   size_int (highest_pow2_factor (offset_iv.base));
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                                 "\touter base_address: ");
> @@ -3327,7 +3326,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>        if (STMT_VINFO_DATA_REF (stmt_info))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "not vectorized: more than one data ref "
> @@ -3355,7 +3354,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>                  get_vectype_for_scalar_type (scalar_type);
>        if (!STMT_VINFO_VECTYPE (stmt_info))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                 "not vectorized: no vectype for stmt: ");
> @@ -3406,7 +3405,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>      {
>        STMT_VINFO_DATA_REF (stmt_info) = NULL;
>        free_data_ref (dr);
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: not suitable for gather "
> @@ -3459,7 +3458,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>
>    if (bad)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: data dependence conflict"
> @@ -3480,7 +3479,7 @@ vect_analyze_data_refs (loop_vec_info loop_vinfo,
>        = vect_check_strided_load (stmt, loop_vinfo, NULL, NULL);
>    if (!strided_load)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "not vectorized: not suitable for strided "
> @@ -3668,7 +3667,7 @@ vect_create_addr_base_for_vector_ref (gimple stmt,
>   mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (vec_stmt));
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "created ");
>        dump_generic_expr (MSG_NOTE, TDF_SLIM, vec_stmt);
> @@ -3790,7 +3789,7 @@ vect_create_data_ref_ptr (gimple stmt, tree aggr_t
>       in LOOP.  */
>    base_name = build_fold_indirect_ref (unshare_expr (DR_BASE_ADDRESS (dr)));
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        tree data_ref_base = base_name;
>        dump_printf_loc (MSG_NOTE, vect_location,
> @@ -4120,7 +4119,7 @@ vect_grouped_store_supported (tree vectype, unsign
>    /* vect_permute_store_chain requires the group size to be a power of two.  */
>    if (exact_log2 (count) == -1)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "the size of the group of accesses"
>                           " is not a power of 2");
> @@ -4146,7 +4145,7 @@ vect_grouped_store_supported (tree vectype, unsign
>   }
>      }
>
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf (MSG_MISSED_OPTIMIZATION,
>                   "interleave op not supported by target.");
>    return false;
> @@ -4564,7 +4563,7 @@ vect_grouped_load_supported (tree vectype, unsigne
>    /* vect_permute_load_chain requires the group size to be a power of two.  */
>    if (exact_log2 (count) == -1)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "the size of the group of accesses"
>                           " is not a power of 2");
> @@ -4588,7 +4587,7 @@ vect_grouped_load_supported (tree vectype, unsigne
>   }
>      }
>
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                       "extract even/odd not supported by target");
>    return false;
> Index: tree-vect-patterns.c
> ===================================================================
> --- tree-vect-patterns.c (revision 192695)
> +++ tree-vect-patterns.c (working copy)
> @@ -416,7 +416,7 @@ vect_recog_dot_prod_pattern (VEC (gimple, heap) **
>    pattern_stmt = gimple_build_assign_with_ops (DOT_PROD_EXPR, var,
>         oprnd00, oprnd01, oprnd1);
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                         "vect_recog_dot_prod_pattern: detected: ");
> @@ -676,7 +676,7 @@ vect_recog_widen_mult_pattern (VEC (gimple, heap)
>      return NULL;
>
>    /* Pattern detected.  */
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "vect_recog_widen_mult_pattern: detected: ");
>
> @@ -699,7 +699,7 @@ vect_recog_widen_mult_pattern (VEC (gimple, heap)
>    pattern_stmt = gimple_build_assign_with_ops (WIDEN_MULT_EXPR, var, oprnd0,
>         oprnd1);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);
>
>    VEC_safe_push (gimple, heap, *stmts, last_stmt);
> @@ -912,7 +912,7 @@ vect_recog_widen_sum_pattern (VEC (gimple, heap) *
>    pattern_stmt = gimple_build_assign_with_ops (WIDEN_SUM_EXPR, var,
>         oprnd0, oprnd1);
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                         "vect_recog_widen_sum_pattern: detected: ");
> @@ -1217,7 +1217,7 @@ vect_recog_over_widening_pattern (VEC (gimple, hea
>        STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)) = pattern_stmt;
>        new_pattern_def_seq (vinfo_for_stmt (stmt), new_def_stmt);
>
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                             "created pattern stmt: ");
> @@ -1285,7 +1285,7 @@ vect_recog_over_widening_pattern (VEC (gimple, hea
>      return NULL;
>
>    /* Pattern detected.  */
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                         "vect_recog_over_widening_pattern: detected: ");
> @@ -1421,7 +1421,7 @@ vect_recog_widen_shift_pattern (VEC (gimple, heap)
>      return NULL;
>
>    /* Pattern detected.  */
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "vect_recog_widen_shift_pattern: detected: ");
>
> @@ -1445,7 +1445,7 @@ vect_recog_widen_shift_pattern (VEC (gimple, heap)
>    pattern_stmt =
>      gimple_build_assign_with_ops (WIDEN_LSHIFT_EXPR, var, oprnd0, oprnd1);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);
>
>    VEC_safe_push (gimple, heap, *stmts, last_stmt);
> @@ -1567,7 +1567,7 @@ vect_recog_vector_vector_shift_pattern (VEC (gimpl
>      }
>
>    /* Pattern detected.  */
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "vect_recog_vector_vector_shift_pattern: detected: ");
>
> @@ -1575,7 +1575,7 @@ vect_recog_vector_vector_shift_pattern (VEC (gimpl
>    var = vect_recog_temp_ssa_var (TREE_TYPE (oprnd0), NULL);
>    pattern_stmt = gimple_build_assign_with_ops (rhs_code, var, oprnd0, def);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);
>
>    VEC_safe_push (gimple, heap, *stmts, last_stmt);
> @@ -1685,7 +1685,7 @@ vect_recog_divmod_pattern (VEC (gimple, heap) **st
>   return NULL;
>
>        /* Pattern detected.  */
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                           "vect_recog_divmod_pattern: detected: ");
>
> @@ -1789,7 +1789,7 @@ vect_recog_divmod_pattern (VEC (gimple, heap) **st
>      signmask);
>   }
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt,
>                                0);
>
> @@ -2031,7 +2031,7 @@ vect_recog_divmod_pattern (VEC (gimple, heap) **st
>      }
>
>    /* Pattern detected.  */
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                         "vect_recog_divmod_pattern: detected: ");
> @@ -2199,7 +2199,7 @@ vect_recog_mixed_size_cond_pattern (VEC (gimple, h
>    *type_in = vecitype;
>    *type_out = vectype;
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                       "vect_recog_mixed_size_cond_pattern: detected: ");
>
> @@ -2592,7 +2592,7 @@ vect_recog_bool_pattern (VEC (gimple, heap) **stmt
>        *type_out = vectype;
>        *type_in = vectype;
>        VEC_safe_push (gimple, heap, *stmts, last_stmt);
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                           "vect_recog_bool_pattern: detected: ");
>
> @@ -2638,7 +2638,7 @@ vect_recog_bool_pattern (VEC (gimple, heap) **stmt
>        *type_out = vectype;
>        *type_in = vectype;
>        VEC_safe_push (gimple, heap, *stmts, last_stmt);
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                           "vect_recog_bool_pattern: detected: ");
>        return pattern_stmt;
> @@ -2788,7 +2788,7 @@ vect_pattern_recog_1 (vect_recog_func_ptr vect_rec
>      }
>
>    /* Found a vectorizable pattern.  */
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                         "pattern recognized: ");
> @@ -2814,7 +2814,7 @@ vect_pattern_recog_1 (vect_recog_func_ptr vect_rec
>      {
>        stmt_info = vinfo_for_stmt (stmt);
>        pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
> -      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>                             "additional pattern stmt: ");
> @@ -2915,7 +2915,7 @@ vect_pattern_recog (loop_vec_info loop_vinfo, bb_v
>    VEC (gimple, heap) *stmts_to_replace = VEC_alloc (gimple, heap, 1);
>    gimple stmt;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_pattern_recog ===");
>
> Index: tree-vect-stmts.c
> ===================================================================
> --- tree-vect-stmts.c (revision 192695)
> +++ tree-vect-stmts.c (working copy)
> @@ -190,7 +190,7 @@ vect_mark_relevant (VEC(gimple,heap) **worklist, g
>    bool save_live_p = STMT_VINFO_LIVE_P (stmt_info);
>    gimple pattern_stmt;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "mark relevant %d, live %d.", relevant, live_p);
>
> @@ -246,7 +246,7 @@ vect_mark_relevant (VEC(gimple,heap) **worklist, g
>
>            pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
>
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>                               "last stmt in pattern. don't mark"
>                               " relevant/live.");
> @@ -265,7 +265,7 @@ vect_mark_relevant (VEC(gimple,heap) **worklist, g
>    if (STMT_VINFO_RELEVANT (stmt_info) == save_relevant
>        && STMT_VINFO_LIVE_P (stmt_info) == save_live_p)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "already marked relevant/live.");
>        return;
> @@ -310,7 +310,7 @@ vect_stmt_relevant_p (gimple stmt, loop_vec_info l
>    if (gimple_code (stmt) != GIMPLE_PHI)
>      if (gimple_vdef (stmt))
>        {
> - if (dump_kind_p (MSG_NOTE))
> + if (dump_enabled_p ())
>    dump_printf_loc (MSG_NOTE, vect_location,
>                             "vec_stmt_relevant_p: stmt has vdefs.");
>   *relevant = vect_used_in_scope;
> @@ -324,7 +324,7 @@ vect_stmt_relevant_p (gimple stmt, loop_vec_info l
>    basic_block bb = gimple_bb (USE_STMT (use_p));
>    if (!flow_bb_inside_loop_p (loop, bb))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                                   "vec_stmt_relevant_p: used out of loop.");
>
> @@ -437,7 +437,7 @@ process_use (gimple stmt, tree use, loop_vec_info
>
>    if (!vect_is_simple_use (use, stmt, loop_vinfo, NULL, &def_stmt, &def, &dt))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not vectorized: unsupported use in stmt.");
>        return false;
> @@ -449,7 +449,7 @@ process_use (gimple stmt, tree use, loop_vec_info
>    def_bb = gimple_bb (def_stmt);
>    if (!flow_bb_inside_loop_p (loop, def_bb))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location, "def_stmt is out of loop.");
>        return true;
>      }
> @@ -467,7 +467,7 @@ process_use (gimple stmt, tree use, loop_vec_info
>        && STMT_VINFO_DEF_TYPE (dstmt_vinfo) == vect_reduction_def
>        && bb->loop_father == def_bb->loop_father)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "reduc-stmt defining reduc-phi in the same nest.");
>        if (STMT_VINFO_IN_PATTERN_P (dstmt_vinfo))
> @@ -487,7 +487,7 @@ process_use (gimple stmt, tree use, loop_vec_info
>   ...  */
>    if (flow_loop_nested_p (def_bb->loop_father, bb->loop_father))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "outer-loop def-stmt defining inner-loop stmt.");
>
> @@ -525,7 +525,7 @@ process_use (gimple stmt, tree use, loop_vec_info
>   stmt # use (d) */
>    else if (flow_loop_nested_p (bb->loop_father, def_bb->loop_father))
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "inner-loop def-stmt defining outer-loop stmt.");
>
> @@ -589,7 +589,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>    enum vect_relevant relevant, tmp_relevant;
>    enum vect_def_type def_type;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "=== vect_mark_stmts_to_be_vectorized ===");
>
> @@ -602,7 +602,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>        for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
>   {
>    phi = gsi_stmt (si);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "init: phi relevant? ");
>        dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
> @@ -614,7 +614,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>        for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
>   {
>    stmt = gsi_stmt (si);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "init: stmt relevant? ");
>        dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
> @@ -632,7 +632,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>        ssa_op_iter iter;
>
>        stmt = VEC_pop (gimple, worklist);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>            dump_printf_loc (MSG_NOTE, vect_location, "worklist:
> examine stmt: ");
>            dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
> @@ -677,7 +677,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>              /* fall through */
>
>          default:
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                       "unsupported use of reduction.");
>              VEC_free (gimple, heap, worklist);
> @@ -692,7 +692,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>                  && tmp_relevant != vect_used_in_outer_by_reduction
>                  && tmp_relevant != vect_used_in_outer)
>                {
> -                if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                if (dump_enabled_p ())
>                    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "unsupported use of nested cycle.");
>
> @@ -707,7 +707,7 @@ vect_mark_stmts_to_be_vectorized (loop_vec_info lo
>              if (tmp_relevant != vect_unused_in_scope
>                  && tmp_relevant != vect_used_by_reduction)
>                {
> -                if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                if (dump_enabled_p ())
>                    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                     "unsupported use of double reduction.");
>
> @@ -830,7 +830,7 @@ vect_model_simple_cost (stmt_vec_info stmt_info, i
>    inside_cost = record_stmt_cost (body_cost_vec, ncopies, vector_stmt,
>    stmt_info, 0, vect_body);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_model_simple_cost: inside_cost = %d, "
>                       "prologue_cost = %d .", inside_cost, prologue_cost);
> @@ -876,7 +876,7 @@ vect_model_promotion_demotion_cost (stmt_vec_info
>        prologue_cost += add_stmt_cost (target_cost_data, 1, vector_stmt,
>        stmt_info, 0, vect_prologue);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_model_promotion_demotion_cost: inside_cost = %d, "
>                       "prologue_cost = %d .", inside_cost, prologue_cost);
> @@ -960,7 +960,7 @@ vect_model_store_cost (stmt_vec_info stmt_info, in
>        inside_cost = record_stmt_cost (body_cost_vec, nstmts, vec_perm,
>        stmt_info, 0, vect_body);
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "vect_model_store_cost: strided group_size = %d .",
>                           group_size);
> @@ -969,7 +969,7 @@ vect_model_store_cost (stmt_vec_info stmt_info, in
>    /* Costs of the stores.  */
>    vect_get_store_cost (first_dr, ncopies, &inside_cost, body_cost_vec);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_model_store_cost: inside_cost = %d, "
>                       "prologue_cost = %d .", inside_cost, prologue_cost);
> @@ -994,7 +994,7 @@ vect_get_store_cost (struct data_reference *dr, in
>    vector_store, stmt_info, 0,
>    vect_body);
>
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_store_cost: aligned.");
>          break;
> @@ -1006,7 +1006,7 @@ vect_get_store_cost (struct data_reference *dr, in
>   *inside_cost += record_stmt_cost (body_cost_vec, ncopies,
>    unaligned_store, stmt_info,
>    DR_MISALIGNMENT (dr), vect_body);
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_store_cost: unaligned supported by "
>                             "hardware.");
> @@ -1017,7 +1017,7 @@ vect_get_store_cost (struct data_reference *dr, in
>        {
>          *inside_cost = VECT_MAX_COST;
>
> -        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "vect_model_store_cost: unsupported access.");
>          break;
> @@ -1076,7 +1076,7 @@ vect_model_load_cost (stmt_vec_info stmt_info, int
>        inside_cost += record_stmt_cost (body_cost_vec, nstmts, vec_perm,
>         stmt_info, 0, vect_body);
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "vect_model_load_cost: strided group_size = %d .",
>                           group_size);
> @@ -1100,7 +1100,7 @@ vect_model_load_cost (stmt_vec_info stmt_info, int
>   &inside_cost, &prologue_cost,
>   prologue_cost_vec, body_cost_vec, true);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "vect_model_load_cost: inside_cost = %d, "
>                       "prologue_cost = %d .", inside_cost, prologue_cost);
> @@ -1127,7 +1127,7 @@ vect_get_load_cost (struct data_reference *dr, int
>   *inside_cost += record_stmt_cost (body_cost_vec, ncopies, vector_load,
>    stmt_info, 0, vect_body);
>
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_load_cost: aligned.");
>
> @@ -1140,7 +1140,7 @@ vect_get_load_cost (struct data_reference *dr, int
>    unaligned_load, stmt_info,
>    DR_MISALIGNMENT (dr), vect_body);
>
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_load_cost: unaligned supported by "
>                             "hardware.");
> @@ -1161,7 +1161,7 @@ vect_get_load_cost (struct data_reference *dr, int
>    *inside_cost += record_stmt_cost (body_cost_vec, 1, vector_stmt,
>      stmt_info, 0, vect_body);
>
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_load_cost: explicit realign");
>
> @@ -1169,7 +1169,7 @@ vect_get_load_cost (struct data_reference *dr, int
>        }
>      case dr_explicit_realign_optimized:
>        {
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_load_cost: unaligned software "
>                             "pipelined.");
> @@ -1197,7 +1197,7 @@ vect_get_load_cost (struct data_reference *dr, int
>   *inside_cost += record_stmt_cost (body_cost_vec, ncopies, vec_perm,
>    stmt_info, 0, vect_body);
>
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "vect_model_load_cost: explicit realign optimized");
>
> @@ -1208,7 +1208,7 @@ vect_get_load_cost (struct data_reference *dr, int
>        {
>          *inside_cost = VECT_MAX_COST;
>
> -        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "vect_model_load_cost: unsupported access.");
>          break;
> @@ -1258,7 +1258,7 @@ vect_init_vector_1 (gimple stmt, gimple new_stmt,
>         }
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                         "created new init_stmt: ");
> @@ -1340,7 +1340,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt
>    bool is_simple_use;
>    tree vector_type;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                         "vect_get_vec_def_for_operand: ");
> @@ -1350,7 +1350,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt
>    is_simple_use = vect_is_simple_use (op, stmt, loop_vinfo, NULL,
>        &def_stmt, &def, &dt);
>    gcc_assert (is_simple_use);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        int loc_printed = 0;
>        if (def)
> @@ -1382,7 +1382,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt
>    *scalar_def = op;
>
>          /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "Create vector_cst. nunits = %d", nunits);
>
> @@ -1399,7 +1399,7 @@ vect_get_vec_def_for_operand (tree op, gimple stmt
>    *scalar_def = def;
>
>          /* Create 'vec_inv = {inv,inv,..,inv}'  */
> -        if (dump_kind_p (MSG_NOTE))
> +        if (dump_enabled_p ())
>            dump_printf_loc (MSG_NOTE, vect_location, "Create vector_inv.");
>
>          return vect_init_vector (stmt, def, vector_type, NULL);
> @@ -1661,7 +1661,7 @@ vect_finish_stmt_generation (gimple stmt, gimple v
>    set_vinfo_for_stmt (vec_stmt, new_stmt_vec_info (vec_stmt, loop_vinfo,
>                                                     bb_vinfo));
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "add new stmt: ");
>        dump_gimple_stmt (MSG_NOTE, TDF_SLIM, vec_stmt, 0);
> @@ -1764,7 +1764,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>        if (rhs_type
>    && !types_compatible_p (rhs_type, TREE_TYPE (op)))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "argument types differ.");
>    return false;
> @@ -1775,7 +1775,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>        if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
>   &def_stmt, &def, &dt[i], &opvectype))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "use not simple.");
>    return false;
> @@ -1786,7 +1786,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>        else if (opvectype
>         && opvectype != vectype_in)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "argument vector types differ.");
>    return false;
> @@ -1800,7 +1800,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>      gcc_assert (vectype_in);
>    if (!vectype_in)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "no vectype for scalar type ");
> @@ -1829,7 +1829,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>    fndecl = vectorizable_function (stmt, vectype_out, vectype_in);
>    if (fndecl == NULL_TREE)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "function is not vectorizable.");
>
> @@ -1852,7 +1852,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>    if (!vec_stmt) /* transformation not required.  */
>      {
>        STMT_VINFO_TYPE (stmt_info) = call_vec_info_type;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location, "=== vectorizable_call ===");
>        vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
>        return true;
> @@ -1860,7 +1860,7 @@ vectorizable_call (gimple stmt, gimple_stmt_iterat
>
>    /** Transform.  **/
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "transform call.");
>
>    /* Handle def.  */
> @@ -2375,7 +2375,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>    && (TYPE_PRECISION (rhs_type)
>        != GET_MODE_PRECISION (TYPE_MODE (rhs_type)))))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "type conversion to/from bit-precision unsupported.");
>        return false;
> @@ -2385,7 +2385,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>    if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
>       &def_stmt, &def, &dt[0], &vectype_in))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "use not simple.");
>        return false;
> @@ -2407,7 +2407,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>
>        if (!ok)
>   {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "use not simple.");
>    return false;
> @@ -2422,7 +2422,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>      gcc_assert (vectype_in);
>    if (!vectype_in)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "no vectype for scalar type ");
> @@ -2466,7 +2466,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>   break;
>        /* FALLTHRU */
>      unsupported:
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "conversion not supported by target.");
>        return false;
> @@ -2565,7 +2565,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>
>    if (!vec_stmt) /* transformation not required.  */
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "=== vectorizable_conversion ===");
>        if (code == FIX_TRUNC_EXPR || code == FLOAT_EXPR)
> @@ -2588,7 +2588,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_
>      }
>
>    /** Transform.  **/
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "transform conversion. ncopies = %d.", ncopies);
>
> @@ -2941,7 +2941,7 @@ vectorizable_assignment (gimple stmt, gimple_stmt_
>    if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
>       &def_stmt, &def, &dt[0], &vectype_in))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "use not simple.");
>        return false;
> @@ -2970,7 +2970,7 @@ vectorizable_assignment (gimple stmt, gimple_stmt_
>      > TYPE_PRECISION (TREE_TYPE (op)))
>     && TYPE_UNSIGNED (TREE_TYPE (op))))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "type conversion to/from bit-precision "
>                           "unsupported.");
> @@ -2980,7 +2980,7 @@ vectorizable_assignment (gimple stmt, gimple_stmt_
>    if (!vec_stmt) /* transformation not required.  */
>      {
>        STMT_VINFO_TYPE (stmt_info) = assignment_vec_info_type;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "=== vectorizable_assignment ===");
>        vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
> @@ -2988,7 +2988,7 @@ vectorizable_assignment (gimple stmt, gimple_stmt_
>      }
>
>    /** Transform.  **/
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "transform assignment.");
>
>    /* Handle def.  */
> @@ -3135,7 +3135,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    if (TYPE_PRECISION (TREE_TYPE (scalar_dest))
>        != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (scalar_dest))))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "bit-precision shifts not supported.");
>        return false;
> @@ -3145,7 +3145,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
>                               &def_stmt, &def, &dt[0], &vectype))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "use not simple.");
>        return false;
> @@ -3158,7 +3158,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>      gcc_assert (vectype);
>    if (!vectype)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "no vectype for scalar type ");
>        return false;
> @@ -3173,7 +3173,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    if (!vect_is_simple_use_1 (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
>       &def, &dt[1], &op1_vectype))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "use not simple.");
>        return false;
> @@ -3218,7 +3218,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>      }
>    else
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "operand mode requires invariant argument.");
>        return false;
> @@ -3228,7 +3228,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    if (!scalar_shift_arg)
>      {
>        optab = optab_for_tree_code (code, vectype, optab_vector);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "vector/vector shift/rotate found.");
>
> @@ -3237,7 +3237,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>        if (op1_vectype == NULL_TREE
>    || TYPE_MODE (op1_vectype) != TYPE_MODE (vectype))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "unusable type for last operand in"
>                               " vector/vector shift/rotate.");
> @@ -3252,7 +3252,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>        if (optab
>            && optab_handler (optab, TYPE_MODE (vectype)) != CODE_FOR_nothing)
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location,
>                               "vector/scalar shift/rotate found.");
>          }
> @@ -3265,7 +3265,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>              {
>        scalar_shift_arg = false;
>
> -              if (dump_kind_p (MSG_NOTE))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_NOTE, vect_location,
>                                   "vector/vector shift/rotate found.");
>
> @@ -3282,7 +3282,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>        && TYPE_MODE (TREE_TYPE (vectype))
>   != TYPE_MODE (TREE_TYPE (op1)))
>      {
> -                      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                      if (dump_enabled_p ())
>                          dump_printf_loc (MSG_MISSED_OPTIMIZATION,
> vect_location,
>                                           "unusable type for last operand in"
>                                           " vector/vector shift/rotate.");
> @@ -3302,7 +3302,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    /* Supportable by target?  */
>    if (!optab)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "no optab.");
>        return false;
> @@ -3311,7 +3311,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    icode = (int) optab_handler (optab, vec_mode);
>    if (icode == CODE_FOR_nothing)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "op not supported by target.");
>        /* Check only during analysis.  */
> @@ -3319,7 +3319,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>            || (vf < vect_min_worthwhile_factor (code)
>                && !vec_stmt))
>          return false;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location, "proceeding using
> word mode.");
>      }
>
> @@ -3328,7 +3328,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>        && vf < vect_min_worthwhile_factor (code)
>        && !vec_stmt)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not worthwhile without SIMD support.");
>        return false;
> @@ -3337,7 +3337,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>    if (!vec_stmt) /* transformation not required.  */
>      {
>        STMT_VINFO_TYPE (stmt_info) = shift_vec_info_type;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location, "===
> vectorizable_shift ===");
>        vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
>        return true;
> @@ -3345,7 +3345,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>
>    /** Transform.  **/
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "transform binary/unary operation.");
>
> @@ -3382,7 +3382,7 @@ vectorizable_shift (gimple stmt, gimple_stmt_itera
>                optab_op2_mode = insn_data[icode].operand[2].mode;
>                if (!VECTOR_MODE_P (optab_op2_mode))
>                  {
> -                  if (dump_kind_p (MSG_NOTE))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_NOTE, vect_location,
>                                       "operand 1 using scalar mode.");
>                    vec_oprnd1 = op1;
> @@ -3510,7 +3510,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>    op_type = TREE_CODE_LENGTH (code);
>    if (op_type != unary_op && op_type != binary_op && op_type != ternary_op)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "num. args = %d (not unary/binary/ternary op).",
>                           op_type);
> @@ -3529,7 +3529,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>        && code != BIT_XOR_EXPR
>        && code != BIT_AND_EXPR)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "bit-precision arithmetic not supported.");
>        return false;
> @@ -3539,7 +3539,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>    if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
>       &def_stmt, &def, &dt[0], &vectype))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "use not simple.");
>        return false;
> @@ -3552,7 +3552,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>      gcc_assert (vectype);
>    if (!vectype)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "no vectype for scalar type ");
> @@ -3574,7 +3574,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>        if (!vect_is_simple_use (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
>         &def, &dt[1]))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "use not simple.");
>    return false;
> @@ -3586,7 +3586,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>        if (!vect_is_simple_use (op2, stmt, loop_vinfo, bb_vinfo, &def_stmt,
>         &def, &dt[2]))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "use not simple.");
>    return false;
> @@ -3628,7 +3628,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>        optab = optab_for_tree_code (code, vectype, optab_default);
>        if (!optab)
>   {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "no optab.");
>    return false;
> @@ -3638,14 +3638,14 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>
>    if (icode == CODE_FOR_nothing)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "op not supported by target.");
>        /* Check only during analysis.  */
>        if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
>    || (!vec_stmt && vf < vect_min_worthwhile_factor (code)))
>          return false;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location, "proceeding using word mode.");
>      }
>
> @@ -3654,7 +3654,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>        && !vec_stmt
>        && vf < vect_min_worthwhile_factor (code))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not worthwhile without SIMD support.");
>        return false;
> @@ -3663,7 +3663,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>    if (!vec_stmt) /* transformation not required.  */
>      {
>        STMT_VINFO_TYPE (stmt_info) = op_vec_info_type;
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "=== vectorizable_operation ===");
>        vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
> @@ -3672,7 +3672,7 @@ vectorizable_operation (gimple stmt, gimple_stmt_i
>
>    /** Transform.  **/
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "transform binary/unary operation.");
>
> @@ -3860,7 +3860,7 @@ vectorizable_store (gimple stmt, gimple_stmt_itera
>    /* FORNOW. This restriction should be relaxed.  */
>    if (loop && nested_in_vect_loop_p (loop, stmt) && ncopies > 1)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "multiple types in nested loop.");
>        return false;
> @@ -3894,7 +3894,7 @@ vectorizable_store (gimple stmt, gimple_stmt_itera
>    if (!vect_is_simple_use (op, stmt, loop_vinfo, bb_vinfo, &def_stmt,
>     &def, &dt))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "use not simple.");
>        return false;
> @@ -3915,7 +3915,7 @@ vectorizable_store (gimple stmt, gimple_stmt_itera
>      ? STMT_VINFO_DR_STEP (stmt_info) : DR_STEP (dr),
>      size_zero_node) < 0)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "negative step for store.");
>        return false;
> @@ -3946,7 +3946,7 @@ vectorizable_store (gimple stmt, gimple_stmt_itera
>                if (!vect_is_simple_use (op, next_stmt, loop_vinfo, bb_vinfo,
>         &def_stmt, &def, &dt))
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                       "use not simple.");
>                    return false;
> @@ -4008,7 +4008,7 @@ vectorizable_store (gimple stmt, gimple_stmt_itera
>        group_size = vec_num = 1;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "transform store. ncopies = %d", ncopies);
>
> @@ -4396,7 +4396,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterat
>    /* FORNOW. This restriction should be relaxed.  */
>    if (nested_in_vect_loop && ncopies > 1)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "multiple types in nested loop.");
>        return false;
> @@ -4436,7 +4436,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterat
>      (e.g. - data copies).  */
>    if (optab_handler (mov_optab, mode) == CODE_FOR_nothing)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "Aligned load, but unsupported type.");
>        return false;
> @@ -4472,7 +4472,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterat
>   &def_stmt, &def, &gather_dt,
>   &gather_off_vectype))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "gather index use not simple.");
>    return false;
> @@ -4492,7 +4492,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterat
>         size_zero_node) < 0;
>        if (negative && ncopies > 1)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "multiple types with negative step.");
>    return false;
> @@ -4505,14 +4505,14 @@ vectorizable_load (gimple stmt, gimple_stmt_iterat
>    if (alignment_support_scheme != dr_aligned
>        && alignment_support_scheme != dr_unaligned_supported)
>      {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "negative step but alignment required.");
>        return false;
>      }
>    if (!perm_mask_for_reverse (vectype))
>      {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                   "negative step and reversing not supported.");
>        return false;
> @@ -4527,7 +4527,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterat
>        return true;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>                       "transform load. ncopies = %d", ncopies);
>
> @@ -5334,7 +5334,7 @@ vectorizable_condition (gimple stmt, gimple_stmt_i
>    /* FORNOW: not yet supported.  */
>    if (STMT_VINFO_LIVE_P (stmt_info))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "value used after loop.");
>        return false;
> @@ -5534,7 +5534,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>    gimple pattern_stmt;
>    gimple_seq pattern_def_seq;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "==> examining statement: ");
>        dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
> @@ -5542,7 +5542,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>
>    if (gimple_has_volatile_ops (stmt))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not vectorized: stmt has volatile operands");
>
> @@ -5575,7 +5575,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>            /* Analyze PATTERN_STMT instead of the original stmt.  */
>            stmt = pattern_stmt;
>            stmt_info = vinfo_for_stmt (pattern_stmt);
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_NOTE, vect_location,
>                                 "==> examining pattern statement: ");
> @@ -5584,7 +5584,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>          }
>        else
>          {
> -          if (dump_kind_p (MSG_NOTE))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_NOTE, vect_location, "irrelevant.");
>
>            return true;
> @@ -5597,7 +5597,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>                 || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt))))
>      {
>        /* Analyze PATTERN_STMT too.  */
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "==> examining pattern statement: ");
> @@ -5621,7 +5621,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>        || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_def_stmt)))
>      {
>        /* Analyze def stmt of STMT if it's a pattern stmt.  */
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location,
>                                     "==> examining pattern def statement: ");
> @@ -5660,7 +5660,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>        gcc_assert (PURE_SLP_STMT (stmt_info));
>
>        scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "get vectype for scalar type:  ");
> @@ -5670,7 +5670,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>        vectype = get_vectype_for_scalar_type (scalar_type);
>        if (!vectype)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                                  "not SLPed: unsupported data-type ");
> @@ -5680,7 +5680,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>            return false;
>          }
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location, "vectype:  ");
>            dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
> @@ -5724,7 +5724,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "not vectorized: relevant stmt not ");
> @@ -5746,7 +5746,7 @@ vect_analyze_stmt (gimple stmt, bool *need_to_vect
>
>    if (!ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                             "not vectorized: live stmt not ");
> @@ -5846,7 +5846,7 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iter
>      default:
>        if (!STMT_VINFO_LIVE_P (stmt_info))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                               "stmt not supported.");
>    gcc_unreachable ();
> @@ -5871,7 +5871,7 @@ vect_transform_stmt (gimple stmt, gimple_stmt_iter
>        tree scalar_dest;
>        gimple exit_phi;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>                           "Record the vdef for outer-loop vectorization.");
>
> @@ -6108,7 +6108,7 @@ get_vectype_for_scalar_type_and_size (tree scalar_
>      return NULL_TREE;
>
>    vectype = build_vector_type (scalar_type, nunits);
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                         "get vectype with %d units of type ", nunits);
> @@ -6118,7 +6118,7 @@ get_vectype_for_scalar_type_and_size (tree scalar_
>    if (!vectype)
>      return NULL_TREE;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
>        dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
> @@ -6127,7 +6127,7 @@ get_vectype_for_scalar_type_and_size (tree scalar_
>    if (!VECTOR_MODE_P (TYPE_MODE (vectype))
>        && !INTEGRAL_MODE_P (TYPE_MODE (vectype)))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "mode not supported by target.");
>        return NULL_TREE;
> @@ -6198,7 +6198,7 @@ vect_is_simple_use (tree operand, gimple stmt, loo
>    *def_stmt = NULL;
>    *def = NULL_TREE;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location,
>                         "vect_is_simple_use: operand ");
> @@ -6220,14 +6220,14 @@ vect_is_simple_use (tree operand, gimple stmt, loo
>
>    if (TREE_CODE (operand) == PAREN_EXPR)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location, "non-associatable copy.");
>        operand = TREE_OPERAND (operand, 0);
>      }
>
>    if (TREE_CODE (operand) != SSA_NAME)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not ssa-name.");
>        return false;
> @@ -6236,13 +6236,13 @@ vect_is_simple_use (tree operand, gimple stmt, loo
>    *def_stmt = SSA_NAME_DEF_STMT (operand);
>    if (*def_stmt == NULL)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "no def_stmt.");
>        return false;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "def_stmt: ");
>        dump_gimple_stmt (MSG_NOTE, TDF_SLIM, *def_stmt, 0);
> @@ -6274,13 +6274,13 @@ vect_is_simple_use (tree operand, gimple stmt, loo
>    && *dt == vect_double_reduction_def
>    && gimple_code (stmt) != GIMPLE_PHI))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "Unsupported pattern.");
>        return false;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "type of def: %d.", *dt);
>
>    switch (gimple_code (*def_stmt))
> @@ -6299,7 +6299,7 @@ vect_is_simple_use (tree operand, gimple stmt, loo
>   break;
>        /* FALLTHRU */
>      default:
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "unsupported defining stmt: ");
>        return false;
> Index: tree-vect-slp.c
> ===================================================================
> --- tree-vect-slp.c (revision 192695)
> +++ tree-vect-slp.c (working copy)
> @@ -238,7 +238,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>         &def, &dt)
>    || (!def_stmt && dt != vect_constant_def))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: can't find def for ");
> @@ -263,7 +263,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>            pattern = true;
>            if (!first && !oprnd_info->first_pattern)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: some of the stmts"
> @@ -279,7 +279,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>
>            if (dt == vect_unknown_def_type)
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "Unsupported pattern.");
>                return false;
> @@ -296,7 +296,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>                  break;
>
>                default:
> -                if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                if (dump_enabled_p ())
>                    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "unsupported defining stmt: ");
>                  return false;
> @@ -361,7 +361,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>      {
>        if (number_of_oprnds != 2)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "Build SLP failed: different types ");
>
> @@ -388,7 +388,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>                             && !types_compatible_p (oprnd_info->first_def_type,
>                                                     TREE_TYPE (def_op0))))
>                      {
> -                      if (dump_kind_p (MSG_NOTE))
> +                      if (dump_enabled_p ())
>                  {
>    dump_printf_loc (MSG_NOTE, vect_location,
>     "Swapping operands of ");
> @@ -400,7 +400,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>      }
>                    else
>                      {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "Build SLP failed: different types ");
>
> @@ -435,7 +435,7 @@ vect_get_and_check_slp_defs (loop_vec_info loop_vi
>
>   default:
>    /* FORNOW: Not supported.  */
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: illegal type of def ");
> @@ -504,7 +504,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>    /* For every stmt in NODE find its def stmt/s.  */
>    FOR_EACH_VEC_ELT (gimple, stmts, i, stmt)
>      {
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_NOTE, vect_location, "Build SLP for ");
>    dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
> @@ -513,7 +513,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>        /* Fail to vectorize statements marked as unvectorizable.  */
>        if (!STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (stmt)))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: unvectorizable statement ");
> @@ -527,7 +527,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>        lhs = gimple_get_lhs (stmt);
>        if (lhs == NULL_TREE)
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: not GIMPLE_ASSIGN nor "
> @@ -544,7 +544,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>             && (cond = gimple_assign_rhs1 (stmt))
>             && !COMPARISON_CLASS_P (cond))
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: condition is not "
> @@ -560,7 +560,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>        vectype = get_vectype_for_scalar_type (scalar_type);
>        if (!vectype)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: unsupported data-type ");
> @@ -591,7 +591,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>        || !gimple_call_nothrow_p (stmt)
>        || gimple_call_chain (stmt))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: unsupported call type ");
> @@ -631,7 +631,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>
>    if (!optab)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "Build SLP failed: no optab.");
>          vect_free_oprnd_info (&oprnds_info);
> @@ -640,7 +640,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>    icode = (int) optab_handler (optab, vec_mode);
>    if (icode == CODE_FOR_nothing)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "Build SLP failed: "
>   "op not supported by target.");
> @@ -674,7 +674,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>                         || first_stmt_code == COMPONENT_REF
>                         || first_stmt_code == MEM_REF)))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: different operation "
> @@ -689,7 +689,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>    if (need_same_oprnds
>        && !operand_equal_p (first_op1, gimple_assign_rhs2 (stmt), 0))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: different shift "
> @@ -710,7 +710,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>    || gimple_call_fntype (first_stmt)
>       != gimple_call_fntype (stmt))
>   {
> -  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: different calls in ");
> @@ -749,7 +749,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>                    || (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) != stmt
>                        && GROUP_GAP (vinfo_for_stmt (stmt)) != 1))
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      {
>                        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: grouped "
> @@ -767,7 +767,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>                if (loop_vinfo
>                    && GROUP_SIZE (vinfo_for_stmt (stmt)) > ncopies * group_size)
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      {
>                        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: the number "
> @@ -792,7 +792,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>                        && rhs_code != REALPART_EXPR
>                        && rhs_code != IMAGPART_EXPR)
>                      {
> -                      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                      if (dump_enabled_p ())
>                          {
>                            dump_printf_loc (MSG_MISSED_OPTIMIZATION,
>     vect_location,
> @@ -817,7 +817,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>                    if (vect_supportable_dr_alignment (first_dr, false)
>                        == dr_unaligned_unsupported)
>                      {
> -                      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                      if (dump_enabled_p ())
>                          {
>                            dump_printf_loc (MSG_MISSED_OPTIMIZATION,
>     vect_location,
> @@ -857,7 +857,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>    if (TREE_CODE_CLASS (rhs_code) == tcc_reference)
>      {
>        /* Not grouped load.  */
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: not grouped load ");
> @@ -875,7 +875,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>        && rhs_code != COND_EXPR
>        && rhs_code != CALL_EXPR)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: operation");
> @@ -895,7 +895,7 @@ vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
>   first_cond_code = TREE_CODE (cond_expr);
>                else if (first_cond_code != TREE_CODE (cond_expr))
>                  {
> -                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +                  if (dump_enabled_p ())
>                      {
>                        dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: different"
> @@ -1080,7 +1080,7 @@ vect_supported_slp_permutation_p (slp_instance ins
>        /* Check that the loads are all in the same interleaving chain.  */
>        if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (scalar_stmt)) != first_load)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "Build SLP failed: unsupported data "
> @@ -1169,7 +1169,7 @@ vect_supported_load_permutation_p (slp_instance sl
>    if (!slp_instn)
>      return false;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "Load permutation ");
>        FOR_EACH_VEC_ELT (int, load_permutation, i, next)
> @@ -1376,7 +1376,7 @@ vect_supported_load_permutation_p (slp_instance sl
>                    if (vect_supportable_dr_alignment (dr, false)
>                 == dr_unaligned_unsupported)
>                      {
> -        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +        if (dump_enabled_p ())
>          {
>                      dump_printf_loc (MSG_MISSED_OPTIMIZATION,
>     vect_location,
> @@ -1536,7 +1536,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinf
>
>    if (!vectype)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: unsupported data-type ");
> @@ -1556,7 +1556,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinf
>    unrolling_factor = least_common_multiple (nunits, group_size) / group_size;
>    if (unrolling_factor != 1 && !loop_vinfo)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "Build SLP failed: unrolling required in basic"
>   " block SLP");
> @@ -1618,7 +1618,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinf
>
>        if (unrolling_factor != 1 && !loop_vinfo)
>          {
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>       "Build SLP failed: unrolling required in basic"
>       " block SLP");
> @@ -1645,7 +1645,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinf
>            if (!vect_supported_load_permutation_p (new_instance, group_size,
>                                                    load_permutation))
>              {
> -              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +              if (dump_enabled_p ())
>                  {
>                    dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "Build SLP failed: unsupported load "
> @@ -1685,7 +1685,7 @@ vect_analyze_slp_instance (loop_vec_info loop_vinf
>          VEC_safe_push (slp_instance, heap, BB_VINFO_SLP_INSTANCES (bb_vinfo),
>                         new_instance);
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   vect_print_slp_tree (MSG_NOTE, node);
>
>        return true;
> @@ -1717,7 +1717,7 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec
>    gimple first_element;
>    bool ok = false;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "=== vect_analyze_slp ===");
>
>    if (loop_vinfo)
> @@ -1736,7 +1736,7 @@ vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec
>
>    if (bb_vinfo && !ok)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "Failed to SLP the basic block.");
>
> @@ -1780,7 +1780,7 @@ vect_make_slp_decision (loop_vec_info loop_vinfo)
>    slp_instance instance;
>    int decided_to_slp = 0;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "===
> vect_make_slp_decision ===");
>
>    FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
> @@ -1798,7 +1798,7 @@ vect_make_slp_decision (loop_vec_info loop_vinfo)
>
>    LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo) = unrolling_factor;
>
> -  if (decided_to_slp && dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (decided_to_slp && dump_enabled_p ())
>      dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
>       "Decided to SLP %d instances. Unrolling factor %d",
>       decided_to_slp, unrolling_factor);
> @@ -1863,7 +1863,7 @@ vect_detect_hybrid_slp (loop_vec_info loop_vinfo)
>    VEC (slp_instance, heap) *slp_instances = LOOP_VINFO_SLP_INSTANCES
> (loop_vinfo);
>    slp_instance instance;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "===
> vect_detect_hybrid_slp ===");
>
>    FOR_EACH_VEC_ELT (slp_instance, slp_instances, i, instance)
> @@ -2060,7 +2060,7 @@ vect_bb_vectorization_profitable_p (bb_vec_info bb
>
>    vec_outside_cost = vec_prologue_cost + vec_epilogue_cost;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE, vect_location, "Cost model analysis: \n");
>        dump_printf (MSG_NOTE, "  Vector inside of basic block cost: %d\n",
> @@ -2097,7 +2097,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>
>    if (!vect_analyze_data_refs (NULL, bb_vinfo, &min_vf))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: unhandled data-ref in basic "
>   "block.\n");
> @@ -2109,7 +2109,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>    ddrs = BB_VINFO_DDRS (bb_vinfo);
>    if (!VEC_length (ddr_p, ddrs))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: not enough data-refs in "
>   "basic block.\n");
> @@ -2123,7 +2123,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>    if (!vect_analyze_data_ref_dependences (NULL, bb_vinfo, &max_vf)
>         || min_vf > max_vf)
>       {
> -       if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +       if (dump_enabled_p ())
>   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>    "not vectorized: unhandled data dependence "
>    "in basic block.\n");
> @@ -2134,7 +2134,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>
>    if (!vect_analyze_data_refs_alignment (NULL, bb_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: bad data alignment in basic "
>   "block.\n");
> @@ -2145,7 +2145,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>
>    if (!vect_analyze_data_ref_accesses (NULL, bb_vinfo))
>      {
> -     if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +     if (dump_enabled_p ())
>         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: unhandled data access in "
>   "basic block.\n");
> @@ -2158,7 +2158,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>       trees.  */
>    if (!vect_analyze_slp (NULL, bb_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: failed to find SLP opportunities "
>   "in basic block.\n");
> @@ -2179,7 +2179,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>
>    if (!vect_verify_datarefs_alignment (NULL, bb_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>                           "not vectorized: unsupported alignment in basic "
>                           "block.\n");
> @@ -2189,7 +2189,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>
>    if (!vect_slp_analyze_operations (bb_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: bad operation in basic block.\n");
>
> @@ -2201,7 +2201,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>    if (flag_vect_cost_model
>        && !vect_bb_vectorization_profitable_p (bb_vinfo))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: vectorization is not "
>   "profitable.\n");
> @@ -2210,7 +2210,7 @@ vect_slp_analyze_bb_1 (basic_block bb)
>        return NULL;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "Basic block will be vectorized using SLP\n");
>
> @@ -2226,7 +2226,7 @@ vect_slp_analyze_bb (basic_block bb)
>    gimple_stmt_iterator gsi;
>    unsigned int vector_sizes;
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "===vect_slp_analyze_bb===\n");
>
>    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
> @@ -2240,7 +2240,7 @@ vect_slp_analyze_bb (basic_block bb)
>
>    if (insns > PARAM_VALUE (PARAM_SLP_MAX_INSNS_IN_BB))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>   "not vectorized: too many instructions in "
>   "basic block.\n");
> @@ -2267,7 +2267,7 @@ vect_slp_analyze_bb (basic_block bb)
>
>        /* Try the next biggest vector size.  */
>        current_vector_size = 1 << floor_log2 (vector_sizes);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          dump_printf_loc (MSG_NOTE, vect_location,
>   "***** Re-trying analysis with "
>   "vector size %d\n", current_vector_size);
> @@ -2292,7 +2292,7 @@ vect_update_slp_costs_according_to_vf (loop_vec_in
>    stmt_info_for_cost *si;
>    void *data = LOOP_VINFO_TARGET_COST_DATA (loop_vinfo);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location,
>       "=== vect_update_slp_costs_according_to_vf ===");
>
> @@ -2800,7 +2800,7 @@ vect_get_mask_element (gimple stmt, int first_mask
>       the next vector as well.  */
>    if (only_one_vec && *current_mask_element >= mask_nunits)
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "permutation requires at least two vectors ");
> @@ -2818,7 +2818,7 @@ vect_get_mask_element (gimple stmt, int first_mask
>            /* We either need the first vector too or have already moved to the
>               next vector. In both cases, this permutation needs three
>               vectors.  */
> -          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +          if (dump_enabled_p ())
>              {
>                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>         "permutation requires at "
> @@ -2884,7 +2884,7 @@ vect_transform_slp_perm_load (gimple stmt, VEC (tr
>
>    if (!can_vec_perm_p (mode, false, NULL))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
>     "no vect permute for ");
> @@ -2964,7 +2964,7 @@ vect_transform_slp_perm_load (gimple stmt, VEC (tr
>
>    if (!can_vec_perm_p (mode, false, mask))
>      {
> -      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
> +      if (dump_enabled_p ())
>   {
>    dump_printf_loc (MSG_MISSED_OPTIMIZATION,
>     vect_location,
> @@ -3068,7 +3068,7 @@ vect_schedule_slp_instance (slp_tree node, slp_ins
>        SLP_TREE_NUMBER_OF_VEC_STMTS (node) = vec_stmts_size;
>      }
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      {
>        dump_printf_loc (MSG_NOTE,vect_location,
>         "------>vectorizing SLP node starting from: ");
> @@ -3177,7 +3177,7 @@ vect_schedule_slp (loop_vec_info loop_vinfo, bb_ve
>        /* Schedule the tree of INSTANCE.  */
>        is_store = vect_schedule_slp_instance (SLP_INSTANCE_TREE (instance),
>                                               instance, vf);
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>   dump_printf_loc (MSG_NOTE, vect_location,
>                           "vectorizing stmts using SLP.");
>      }
> @@ -3222,7 +3222,7 @@ vect_slp_transform_bb (basic_block bb)
>
>    gcc_assert (bb_vinfo);
>
> -  if (dump_kind_p (MSG_NOTE))
> +  if (dump_enabled_p ())
>      dump_printf_loc (MSG_NOTE, vect_location, "SLPing BB\n");
>
>    for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
> @@ -3230,7 +3230,7 @@ vect_slp_transform_bb (basic_block bb)
>        gimple stmt = gsi_stmt (si);
>        stmt_vec_info stmt_info;
>
> -      if (dump_kind_p (MSG_NOTE))
> +      if (dump_enabled_p ())
>          {
>            dump_printf_loc (MSG_NOTE, vect_location,
>                             "------>SLPing statement: ");
> @@ -3248,7 +3248,7 @@ vect_slp_transform_bb (basic_block bb)
>          }
>      }
>
> -  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
> +  if (dump_enabled_p ())
>      dump_printf (MSG_OPTIMIZED_LOCATIONS, "BASIC BLOCK VECTORIZED\n");
>
>    destroy_bb_vec_info (bb_vinfo);

Patch

Index: dumpfile.c
===================================================================
--- dumpfile.c (revision 192695)
+++ dumpfile.c (working copy)
@@ -32,12 +32,18 @@  along with GCC; see the file COPYING3.  If not see

 static int pflags;                   /* current dump_flags */
 static int alt_flags;                /* current opt_info flags */
-static FILE *alt_dump_file = NULL;

 static void dump_loc (int, FILE *, source_location);
 static int dump_phase_enabled_p (int);
 static FILE *dump_open_alternate_stream (struct dump_file_info *);

+/* These are currently used for communicating between passes.
+   However, instead of accessing them directly, the passes can use
+   dump_printf () for dumps.  */
+FILE *dump_file = NULL;
+FILE *alt_dump_file = NULL;
+const char *dump_file_name;
+
 /* Table of tree dump switches. This must be consistent with the
    TREE_DUMP_INDEX enumeration in dumpfile.h.  */
 static struct dump_file_info dump_files[TDI_end] =
@@ -514,14 +520,6 @@  dump_phase_enabled_p (int phase)
     }
 }

-/* Return true if any of the dumps are enabled, false otherwise. */
-
-inline bool
-dump_enabled_p (void)
-{
-  return (dump_file || alt_dump_file);
-}
-
 /* Returns nonzero if tree dump PHASE has been initialized.  */

 int
@@ -836,16 +834,6 @@  opt_info_switch_p (const char *arg)
   return opt_info_enable_all ((TDF_TREE | TDF_RTL | TDF_IPA), flags, filename);
 }

-/* Return true if any dumps are enabled for the given MSG_TYPE, false
-   otherwise.  */
-
-bool
-dump_kind_p (int msg_type)
-{
-  return (dump_file && (msg_type & pflags))
-    || (alt_dump_file && (msg_type & alt_flags));
-}
-
 /* Print basic block on the dump streams.  */

 void
Index: dumpfile.h
===================================================================
--- dumpfile.h (revision 192695)
+++ dumpfile.h (working copy)
@@ -108,7 +108,6 @@  struct dump_file_info
   int num;                      /* dump file number */
 };

-
 /* In dumpfile.c */
 extern char *get_dump_file_name (int);
 extern int dump_initialized_p (int);
@@ -120,8 +119,6 @@  extern void dump_node (const_tree, int, FILE *);
 extern int dump_switch_p (const char *);
 extern int opt_info_switch_p (const char *);
 extern const char *dump_flag_name (int);
-extern bool dump_kind_p (int);
-extern inline bool dump_enabled_p (void);
 extern void dump_printf (int, const char *, ...) ATTRIBUTE_PRINTF_2;
 extern void dump_printf_loc (int, source_location,
                              const char *, ...) ATTRIBUTE_PRINTF_3;
@@ -142,10 +139,19 @@  extern void dump_bb (FILE *, basic_block, int, int

 /* Global variables used to communicate with passes.  */
 extern FILE *dump_file;
+extern FILE *alt_dump_file;
 extern int dump_flags;
 extern const char *dump_file_name;

 /* Return the dump_file_info for the given phase.  */
 extern struct dump_file_info *get_dump_file_info (int);

+/* Return true if any of the dumps are enabled, false otherwise. */
+
+static inline bool
+dump_enabled_p (void)
+{
+  return (dump_file || alt_dump_file);
+}
+
 #endif /* GCC_DUMPFILE_H */
Index: toplev.c
===================================================================
--- toplev.c (revision 192695)
+++ toplev.c (working copy)
@@ -169,8 +169,6 @@  const char *user_label_prefix;
 FILE *asm_out_file;
 FILE *aux_info_file;
 FILE *stack_usage_file = NULL;
-FILE *dump_file = NULL;
-const char *dump_file_name;

 /* The current working directory of a translation.  It's generally the
    directory from which compilation was initiated, but a preprocessed
Index: tree-vect-loop-manip.c
===================================================================
--- tree-vect-loop-manip.c (revision 192695)
+++ tree-vect-loop-manip.c (working copy)
@@ -792,7 +792,7 @@  slpeel_make_loop_iterate_ntimes (struct loop *loop
   free_stmt_vec_info (orig_cond);

   loop_loc = find_loop_location (loop);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       if (LOCATION_LOCUS (loop_loc) != UNKNOWN_LOC)
  dump_printf (MSG_NOTE, "\nloop at %s:%d: ", LOC_FILE (loop_loc),
@@ -1683,7 +1683,7 @@  vect_can_advance_ivs_p (loop_vec_info loop_vinfo)

   /* Analyze phi functions of the loop header.  */

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "vect_can_advance_ivs_p:");
   for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
@@ -1691,7 +1691,7 @@  vect_can_advance_ivs_p (loop_vec_info loop_vinfo)
       tree evolution_part;

       phi = gsi_stmt (gsi);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
           dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
           dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
@@ -1702,7 +1702,7 @@  vect_can_advance_ivs_p (loop_vec_info loop_vinfo)

       if (virtual_operand_p (PHI_RESULT (phi)))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "virtual phi. skip.");
   continue;
@@ -1712,7 +1712,7 @@  vect_can_advance_ivs_p (loop_vec_info loop_vinfo)

       if (STMT_VINFO_DEF_TYPE (vinfo_for_stmt (phi)) == vect_reduction_def)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "reduc phi. skip.");
           continue;
@@ -1725,13 +1725,13 @@  vect_can_advance_ivs_p (loop_vec_info loop_vinfo)

       if (!access_fn)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "No Access function.");
   return false;
  }

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
   dump_printf_loc (MSG_NOTE, vect_location,
                            "Access function of PHI: ");
@@ -1742,7 +1742,7 @@  vect_can_advance_ivs_p (loop_vec_info loop_vinfo)

       if (evolution_part == NULL_TREE)
         {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf (MSG_MISSED_OPTIMIZATION, "No evolution.");
   return false;
         }
@@ -1827,7 +1827,7 @@  vect_update_ivs_after_vectorizer (loop_vec_info lo

       phi = gsi_stmt (gsi);
       phi1 = gsi_stmt (gsi1);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_update_ivs_after_vectorizer: phi: ");
@@ -1837,7 +1837,7 @@  vect_update_ivs_after_vectorizer (loop_vec_info lo
       /* Skip virtual phi's.  */
       if (virtual_operand_p (PHI_RESULT (phi)))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "virtual phi. skip.");
   continue;
@@ -1847,7 +1847,7 @@  vect_update_ivs_after_vectorizer (loop_vec_info lo
       stmt_info = vinfo_for_stmt (phi);
       if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_reduction_def)
         {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "reduc phi. skip.");
           continue;
@@ -1910,7 +1910,7 @@  vect_do_peeling_for_loop_bound (loop_vec_info loop
   tree cond_expr = NULL_TREE;
   gimple_seq cond_expr_stmt_list = NULL;

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "=== vect_do_peeling_for_loop_bound ===");

@@ -2022,7 +2022,7 @@  vect_gen_niters_for_prolog_loop (loop_vec_info loo
     {
       int npeel = LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo);

-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                          "known peeling = %d.", npeel);

@@ -2076,7 +2076,7 @@  vect_gen_niters_for_prolog_loop (loop_vec_info loo
   if (TREE_CODE (loop_niters) != INTEGER_CST)
     iters = fold_build2 (MIN_EXPR, niters_type, iters, loop_niters);

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                        "niters for prolog loop: ");
@@ -2134,7 +2134,7 @@  vect_update_inits_of_drs (loop_vec_info loop_vinfo
   VEC (data_reference_p, heap) *datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
   struct data_reference *dr;

- if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+ if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "=== vect_update_inits_of_dr ===");

@@ -2163,7 +2163,7 @@  vect_do_peeling_for_alignment (loop_vec_info loop_
   int max_iter;
   int bound = 0;

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "=== vect_do_peeling_for_alignment ===");

@@ -2475,7 +2475,7 @@  vect_create_cond_for_alias_checks (loop_vec_info l
       segment_length_a = vect_vfa_segment_size (dr_a, length_factor);
       segment_length_b = vect_vfa_segment_size (dr_b, length_factor);

-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                            "create runtime check for data references ");
@@ -2506,7 +2506,7 @@  vect_create_cond_for_alias_checks (loop_vec_info l
  *cond_expr = part_cond_expr;
     }

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
      "created %u versioning for alias checks.\n",
      VEC_length (ddr_p, may_alias_ddrs));
Index: tree-vectorizer.c
===================================================================
--- tree-vectorizer.c (revision 192695)
+++ tree-vectorizer.c (working copy)
@@ -107,7 +107,7 @@  vectorize_loops (void)
  loop_vec_info loop_vinfo;
  vect_location = find_loop_location (loop);
         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC
-    && dump_kind_p (MSG_ALL))
+    && dump_enabled_p ())
   dump_printf (MSG_ALL, "\nAnalyzing loop at %s:%d\n",
                        LOC_FILE (vect_location), LOC_LINE (vect_location));

@@ -118,7 +118,7 @@  vectorize_loops (void)
   continue;

         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOC
-    && dump_kind_p (MSG_ALL))
+    && dump_enabled_p ())
           dump_printf (MSG_ALL, "\n\nVectorizing loop at %s:%d\n",
                        LOC_FILE (vect_location), LOC_LINE (vect_location));
  vect_transform_loop (loop_vinfo);
@@ -128,8 +128,8 @@  vectorize_loops (void)
   vect_location = UNKNOWN_LOC;

   statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);
-  if (dump_kind_p (MSG_ALL)
-      || (num_vectorized_loops > 0 && dump_kind_p (MSG_ALL)))
+  if (dump_enabled_p ()
+      || (num_vectorized_loops > 0 && dump_enabled_p ()))
     dump_printf_loc (MSG_ALL, vect_location,
                      "vectorized %u loops in function.\n",
                      num_vectorized_loops);
@@ -170,7 +170,7 @@  execute_vect_slp (void)
       if (vect_slp_analyze_bb (bb))
         {
           vect_slp_transform_bb (bb);
-          if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
      "basic block vectorized using SLP\n");
         }
Index: tree-vect-loop.c
===================================================================
--- tree-vect-loop.c (revision 192695)
+++ tree-vect-loop.c (working copy)
@@ -187,7 +187,7 @@  vect_determine_vectorization_factor (loop_vec_info
   gimple_stmt_iterator pattern_def_si = gsi_none ();
   bool analyze_pattern_stmt = false;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_determine_vectorization_factor ===");

@@ -199,7 +199,7 @@  vect_determine_vectorization_factor (loop_vec_info
  {
   phi = gsi_stmt (si);
   stmt_info = vinfo_for_stmt (phi);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "==> examining phi: ");
       dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
@@ -212,7 +212,7 @@  vect_determine_vectorization_factor (loop_vec_info
       gcc_assert (!STMT_VINFO_VECTYPE (stmt_info));
               scalar_type = TREE_TYPE (PHI_RESULT (phi));

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
                                    "get vectype for scalar type:  ");
@@ -222,7 +222,7 @@  vect_determine_vectorization_factor (loop_vec_info
       vectype = get_vectype_for_scalar_type (scalar_type);
       if (!vectype)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                        "not vectorized: unsupported "
@@ -234,14 +234,14 @@  vect_determine_vectorization_factor (loop_vec_info
  }
       STMT_VINFO_VECTYPE (stmt_info) = vectype;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
   dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
  }

       nunits = TYPE_VECTOR_SUBPARTS (vectype);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location, "nunits = %d", nunits);

       if (!vectorization_factor
@@ -261,7 +261,7 @@  vect_determine_vectorization_factor (loop_vec_info

           stmt_info = vinfo_for_stmt (stmt);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "==> examining statement: ");
@@ -281,7 +281,7 @@  vect_determine_vectorization_factor (loop_vec_info
                 {
                   stmt = pattern_stmt;
                   stmt_info = vinfo_for_stmt (pattern_stmt);
-                  if (dump_kind_p (MSG_NOTE))
+                  if (dump_enabled_p ())
                     {
                       dump_printf_loc (MSG_NOTE, vect_location,
                                        "==> examining pattern statement: ");
@@ -290,7 +290,7 @@  vect_determine_vectorization_factor (loop_vec_info
                 }
               else
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location, "skip.");
                   gsi_next (&si);
           continue;
@@ -330,7 +330,7 @@  vect_determine_vectorization_factor (loop_vec_info

   if (!gsi_end_p (pattern_def_si))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
                                            "==> examining pattern def stmt: ");
@@ -353,7 +353,7 @@  vect_determine_vectorization_factor (loop_vec_info

   if (gimple_get_lhs (stmt) == NULL_TREE)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: irregular stmt.");
@@ -365,7 +365,7 @@  vect_determine_vectorization_factor (loop_vec_info

   if (VECTOR_MODE_P (TYPE_MODE (gimple_expr_type (stmt))))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: vector stmt in loop:");
@@ -389,7 +389,7 @@  vect_determine_vectorization_factor (loop_vec_info
     {
       gcc_assert (!STMT_VINFO_DATA_REF (stmt_info));
       scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
                                    "get vectype for scalar type:  ");
@@ -398,7 +398,7 @@  vect_determine_vectorization_factor (loop_vec_info
       vectype = get_vectype_for_scalar_type (scalar_type);
       if (!vectype)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                        "not vectorized: unsupported "
@@ -417,7 +417,7 @@  vect_determine_vectorization_factor (loop_vec_info
      support one vector size per loop).  */
   scalar_type = vect_get_smallest_scalar_type (stmt, &dummy,
        &dummy);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "get vectype for scalar type:  ");
@@ -426,7 +426,7 @@  vect_determine_vectorization_factor (loop_vec_info
   vf_vectype = get_vectype_for_scalar_type (scalar_type);
   if (!vf_vectype)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: unsupported data-type ");
@@ -439,7 +439,7 @@  vect_determine_vectorization_factor (loop_vec_info
   if ((GET_MODE_SIZE (TYPE_MODE (vectype))
        != GET_MODE_SIZE (TYPE_MODE (vf_vectype))))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: different sized vector "
@@ -453,14 +453,14 @@  vect_determine_vectorization_factor (loop_vec_info
       return false;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
       dump_generic_expr (MSG_NOTE, TDF_SLIM, vf_vectype);
     }

   nunits = TYPE_VECTOR_SUBPARTS (vf_vectype);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "nunits = %d", nunits);
   if (!vectorization_factor
       || (nunits > vectorization_factor))
@@ -475,12 +475,12 @@  vect_determine_vectorization_factor (loop_vec_info
     }

   /* TODO: Analyze cost. Decide if worth while to vectorize.  */
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "vectorization factor = %d",
                      vectorization_factor);
   if (vectorization_factor <= 1)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not vectorized: unsupported data-type");
       return false;
@@ -517,7 +517,7 @@  vect_is_simple_iv_evolution (unsigned loop_nb, tre
   step_expr = evolution_part;
   init_expr = unshare_expr (initial_condition_in_loop_num (access_fn,
loop_nb));

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "step: ");
       dump_generic_expr (MSG_NOTE, TDF_SLIM, step_expr);
@@ -530,7 +530,7 @@  vect_is_simple_iv_evolution (unsigned loop_nb, tre

   if (TREE_CODE (step_expr) != INTEGER_CST)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "step unknown.");
       return false;
@@ -555,7 +555,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
   gimple_stmt_iterator gsi;
   bool double_reduc;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_analyze_scalar_cycles ===");

@@ -569,7 +569,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
       tree def = PHI_RESULT (phi);
       stmt_vec_info stmt_vinfo = vinfo_for_stmt (phi);

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
   dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
@@ -587,7 +587,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
       if (access_fn)
  {
   STRIP_NOPS (access_fn);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "Access function of PHI: ");
@@ -606,7 +606,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v

       gcc_assert (STMT_VINFO_LOOP_PHI_EVOLUTION_PART (stmt_vinfo) !=
NULL_TREE);

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location, "Detected induction.");
       STMT_VINFO_DEF_TYPE (stmt_vinfo) = vect_induction_def;
     }
@@ -621,7 +621,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
       gimple reduc_stmt;
       bool nested_cycle;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location, "Analyze phi: ");
           dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
@@ -637,7 +637,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
         {
           if (double_reduc)
             {
-              if (dump_kind_p (MSG_NOTE))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_NOTE, vect_location,
  "Detected double reduction.");

@@ -649,7 +649,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
             {
               if (nested_cycle)
                 {
-                  if (dump_kind_p (MSG_NOTE))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_NOTE, vect_location,
      "Detected vectorizable nested cycle.");

@@ -659,7 +659,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
                 }
               else
                 {
-                  if (dump_kind_p (MSG_NOTE))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_NOTE, vect_location,
      "Detected reduction.");

@@ -675,7 +675,7 @@  vect_analyze_scalar_cycles_1 (loop_vec_info loop_v
             }
         }
       else
-        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Unknown def-use cycle pattern.");
     }
@@ -737,7 +737,7 @@  vect_get_loop_niters (struct loop *loop, tree *num
 {
   tree niters;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "=== get_loop_niters ===");
   niters = number_of_exit_cond_executions (loop);
@@ -747,7 +747,7 @@  vect_get_loop_niters (struct loop *loop, tree *num
     {
       *number_of_iterations = niters;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location, "==> get_loop_niters:");
           dump_generic_expr (MSG_NOTE, TDF_SLIM, *number_of_iterations);
@@ -995,7 +995,7 @@  vect_analyze_loop_1 (struct loop *loop)
 {
   loop_vec_info loop_vinfo;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "===== analyze_loop_nest_1 =====");

@@ -1004,7 +1004,7 @@  vect_analyze_loop_1 (struct loop *loop)
   loop_vinfo = vect_analyze_loop_form (loop);
   if (!loop_vinfo)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad inner-loop form.");
       return NULL;
@@ -1030,7 +1030,7 @@  vect_analyze_loop_form (struct loop *loop)
   tree number_of_iterations = NULL;
   loop_vec_info inner_loop_vinfo = NULL;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "=== vect_analyze_loop_form ===");

@@ -1054,7 +1054,7 @@  vect_analyze_loop_form (struct loop *loop)

       if (loop->num_nodes != 2)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: control flow in loop.");
           return NULL;
@@ -1062,7 +1062,7 @@  vect_analyze_loop_form (struct loop *loop)

       if (empty_block_p (loop->header))
     {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: empty loop.");
       return NULL;
@@ -1092,7 +1092,7 @@  vect_analyze_loop_form (struct loop *loop)

       if ((loop->inner)->inner || (loop->inner)->next)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: multiple nested loops.");
   return NULL;
@@ -1102,7 +1102,7 @@  vect_analyze_loop_form (struct loop *loop)
       inner_loop_vinfo = vect_analyze_loop_1 (loop->inner);
       if (!inner_loop_vinfo)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: Bad inner loop.");
   return NULL;
@@ -1111,7 +1111,7 @@  vect_analyze_loop_form (struct loop *loop)
       if (!expr_invariant_in_loop_p (loop,
  LOOP_VINFO_NITERS (inner_loop_vinfo)))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: inner-loop count not invariant.");
   destroy_loop_vec_info (inner_loop_vinfo, true);
@@ -1120,7 +1120,7 @@  vect_analyze_loop_form (struct loop *loop)

       if (loop->num_nodes != 5)
         {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: control flow in loop.");
   destroy_loop_vec_info (inner_loop_vinfo, true);
@@ -1136,14 +1136,14 @@  vect_analyze_loop_form (struct loop *loop)
   || !single_exit (innerloop)
   || single_exit (innerloop)->dest !=  EDGE_PRED (loop->latch, 0)->src)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: unsupported outerloop form.");
   destroy_loop_vec_info (inner_loop_vinfo, true);
   return NULL;
  }

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "Considering outer-loop vectorization.");
     }
@@ -1151,7 +1151,7 @@  vect_analyze_loop_form (struct loop *loop)
   if (!single_exit (loop)
       || EDGE_COUNT (loop->header->preds) != 2)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           if (!single_exit (loop))
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
@@ -1172,7 +1172,7 @@  vect_analyze_loop_form (struct loop *loop)
   if (!empty_block_p (loop->latch)
         || !gimple_seq_empty_p (phi_nodes (loop->latch)))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: unexpected loop form.");
       if (inner_loop_vinfo)
@@ -1187,12 +1187,12 @@  vect_analyze_loop_form (struct loop *loop)
       if (!(e->flags & EDGE_ABNORMAL))
  {
   split_loop_exit_edge (e);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf (MSG_NOTE, "split exit edge.");
  }
       else
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: abnormal loop exit edge.");
   if (inner_loop_vinfo)
@@ -1204,7 +1204,7 @@  vect_analyze_loop_form (struct loop *loop)
   loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
   if (!loop_cond)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: complicated exit condition.");
       if (inner_loop_vinfo)
@@ -1214,7 +1214,7 @@  vect_analyze_loop_form (struct loop *loop)

   if (!number_of_iterations)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: number of iterations cannot be "
  "computed.");
@@ -1225,7 +1225,7 @@  vect_analyze_loop_form (struct loop *loop)

   if (chrec_contains_undetermined (number_of_iterations))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "Infinite number of iterations.");
       if (inner_loop_vinfo)
@@ -1235,7 +1235,7 @@  vect_analyze_loop_form (struct loop *loop)

   if (!NITERS_KNOWN_P (number_of_iterations))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
    "Symbolic number of iterations is ");
@@ -1244,7 +1244,7 @@  vect_analyze_loop_form (struct loop *loop)
     }
   else if (TREE_INT_CST_LOW (number_of_iterations) == 0)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: number of iterations = 0.");
       if (inner_loop_vinfo)
@@ -1292,7 +1292,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v
   HOST_WIDE_INT estimated_niter;
   int min_profitable_estimate;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "=== vect_analyze_loop_operations ===");

@@ -1328,7 +1328,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v
  LOOP_VINFO_SLP_UNROLLING_FACTOR (loop_vinfo));

       LOOP_VINFO_VECT_FACTOR (loop_vinfo) = vectorization_factor;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
  "Updating vectorization factor to %d ",
  vectorization_factor);
@@ -1344,7 +1344,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v
           ok = true;

           stmt_info = vinfo_for_stmt (phi);
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_NOTE, vect_location, "examining phi: ");
               dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
@@ -1363,7 +1363,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v
                   && STMT_VINFO_DEF_TYPE (stmt_info)
                      != vect_double_reduction_def)
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "Unsupported loop-closed phi in "
      "outer-loop.");
@@ -1405,7 +1405,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v
           if (STMT_VINFO_LIVE_P (stmt_info))
             {
               /* FORNOW: not yet supported.  */
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: value used after loop.");
               return false;
@@ -1415,7 +1415,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v
               && STMT_VINFO_DEF_TYPE (stmt_info) != vect_induction_def)
             {
               /* A scalar-dependence cycle that we don't support.  */
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: scalar dependence cycle.");
               return false;
@@ -1430,7 +1430,7 @@  vect_analyze_loop_operations (loop_vec_info loop_v

           if (!ok)
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "not vectorized: relevant phi not "
@@ -1456,18 +1456,17 @@  vect_analyze_loop_operations (loop_vec_info loop_v
      touching this loop.  */
   if (!need_to_vectorize)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "All the computation can be taken out of the loop.");
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: redundant loop. no profit to "
  "vectorize.");
       return false;
     }

-  if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
-      && dump_kind_p (MSG_NOTE))
+  if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo) && dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "vectorization_factor = %d, niters = "
      HOST_WIDE_INT_PRINT_DEC, vectorization_factor,
@@ -1478,10 +1477,10 @@  vect_analyze_loop_operations (loop_vec_info loop_v
       || ((max_niter = max_stmt_executions_int (loop)) != -1
   && (unsigned HOST_WIDE_INT) max_niter < vectorization_factor))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: iteration count too small.");
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: iteration count smaller than "
  "vectorization factor.");
@@ -1500,10 +1499,10 @@  vect_analyze_loop_operations (loop_vec_info loop_v

   if (min_profitable_iters < 0)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: vectorization not profitable.");
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: vector version will never be "
  "profitable.");
@@ -1526,10 +1525,10 @@  vect_analyze_loop_operations (loop_vec_info loop_v
   if (LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)
       && LOOP_VINFO_INT_NITERS (loop_vinfo) <= th)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: vectorization not profitable.");
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "not vectorized: iteration count smaller than user "
  "specified loop bound parameter or minimum profitable "
@@ -1541,11 +1540,11 @@  vect_analyze_loop_operations (loop_vec_info loop_v
       && ((unsigned HOST_WIDE_INT) estimated_niter
           <= MAX (th, (unsigned)min_profitable_estimate)))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "not vectorized: estimated iteration count too "
                          "small.");
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "not vectorized: estimated iteration count smaller "
                          "than specified loop bound parameter or minimum "
@@ -1558,18 +1557,18 @@  vect_analyze_loop_operations (loop_vec_info loop_v
       || LOOP_VINFO_INT_NITERS (loop_vinfo) % vectorization_factor != 0
       || LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location, "epilog loop required.");
       if (!vect_can_advance_ivs_p (loop_vinfo))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: can't create epilog loop 1.");
           return false;
         }
       if (!slpeel_can_duplicate_loop_p (loop, single_exit (loop)))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not vectorized: can't create epilog loop 2.");
           return false;
@@ -1602,7 +1601,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad data references.");
       return false;
@@ -1620,7 +1619,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_mark_stmts_to_be_vectorized (loop_vinfo);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "unexpected pattern.");
       return false;
@@ -1635,7 +1634,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   if (!ok
       || max_vf < min_vf)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "bad data dependence.");
       return false;
@@ -1644,14 +1643,14 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_determine_vectorization_factor (loop_vinfo);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "can't determine vectorization factor.");
       return false;
     }
   if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad data dependence.");
       return false;
@@ -1663,7 +1662,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad data alignment.");
       return false;
@@ -1675,7 +1674,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_analyze_data_ref_accesses (loop_vinfo, NULL);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad data access.");
       return false;
@@ -1687,7 +1686,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_prune_runtime_alias_test_list (loop_vinfo);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "too long list of versioning for alias "
  "run-time tests.");
@@ -1700,7 +1699,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_enhance_data_refs_alignment (loop_vinfo);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad data alignment.");
       return false;
@@ -1725,7 +1724,7 @@  vect_analyze_loop_2 (loop_vec_info loop_vinfo)
   ok = vect_analyze_loop_operations (loop_vinfo, slp);
   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "bad operation or unsupported loop bound.");
       return false;
@@ -1749,7 +1748,7 @@  vect_analyze_loop (struct loop *loop)
   current_vector_size = 0;
   vector_sizes = targetm.vectorize.autovectorize_vector_sizes ();

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "===== analyze_loop_nest =====");

@@ -1757,7 +1756,7 @@  vect_analyze_loop (struct loop *loop)
       && loop_vec_info_for_loop (loop_outer (loop))
       && LOOP_VINFO_VECTORIZABLE_P (loop_vec_info_for_loop
(loop_outer (loop))))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
  "outer-loop already vectorized.");
       return NULL;
@@ -1769,7 +1768,7 @@  vect_analyze_loop (struct loop *loop)
       loop_vinfo = vect_analyze_loop_form (loop);
       if (!loop_vinfo)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "bad loop form.");
   return NULL;
@@ -1791,7 +1790,7 @@  vect_analyze_loop (struct loop *loop)

       /* Try the next biggest vector size.  */
       current_vector_size = 1 << floor_log2 (vector_sizes);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
  "***** Re-trying analysis with "
  "vector size %d\n", current_vector_size);
@@ -2023,7 +2022,7 @@  vect_is_slp_reduction (loop_vec_info loop_info, gi
                                   == vect_internal_def
                       && !is_loop_header_bb_p (gimple_bb (def_stmt)))))
       {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location, "swapping oprnds: ");
   dump_gimple_stmt (MSG_NOTE, TDF_SLIM, next_stmt, 0);
@@ -2125,7 +2124,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf

       if (!flow_bb_inside_loop_p (loop, gimple_bb (use_stmt)))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "intermediate value used outside loop.");

@@ -2137,7 +2136,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
         nloop_uses++;
       if (nloop_uses > 1)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "reduction used in loop.");
           return NULL;
@@ -2146,7 +2145,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf

   if (TREE_CODE (loop_arg) != SSA_NAME)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "reduction: not ssa_name: ");
@@ -2158,7 +2157,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
   def_stmt = SSA_NAME_DEF_STMT (loop_arg);
   if (!def_stmt)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "reduction: no def_stmt.");
       return NULL;
@@ -2166,7 +2165,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf

   if (!is_gimple_assign (def_stmt) && gimple_code (def_stmt) != GIMPLE_PHI)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_gimple_stmt (MSG_NOTE, TDF_SLIM, def_stmt, 0);
       return NULL;
     }
@@ -2194,7 +2193,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
  nloop_uses++;
       if (nloop_uses > 1)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "reduction used in loop.");
   return NULL;
@@ -2210,7 +2209,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
       if (gimple_phi_num_args (def_stmt) != 1
           || TREE_CODE (op1) != SSA_NAME)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "unsupported phi node definition.");

@@ -2223,7 +2222,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
           && flow_bb_inside_loop_p (loop->inner, gimple_bb (def1))
           && is_gimple_assign (def1))
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             report_vect_op (MSG_NOTE, def_stmt,
     "detected double reduction: ");

@@ -2250,7 +2249,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
   if (check_reduction
       && (!commutative_tree_code (code) || !associative_tree_code (code)))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
  "reduction: not commutative/associative: ");
       return NULL;
@@ -2260,7 +2259,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
     {
       if (code != COND_EXPR)
         {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
     "reduction: not binary operation: ");

@@ -2279,7 +2278,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf

       if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
     "reduction: uses not ssa_names: ");

@@ -2293,7 +2292,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf

       if (TREE_CODE (op1) != SSA_NAME && TREE_CODE (op2) != SSA_NAME)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
     "reduction: uses not ssa_names: ");

@@ -2311,7 +2310,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
       || (op4 && TREE_CODE (op4) == SSA_NAME
           && !types_compatible_p (type, TREE_TYPE (op4))))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
    "reduction: multiple types: operation type: ");
@@ -2353,7 +2352,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
       && check_reduction)
     {
       /* Changing the order of operations changes the semantics.  */
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
  "reduction: unsafe fp math optimization: ");
       return NULL;
@@ -2362,7 +2361,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
    && check_reduction)
     {
       /* Changing the order of operations changes the semantics.  */
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
  "reduction: unsafe int math optimization: ");
       return NULL;
@@ -2370,7 +2369,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
   else if (SAT_FIXED_POINT_TYPE_P (type) && check_reduction)
     {
       /* Changing the order of operations changes the semantics.  */
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
  "reduction: unsafe fixed-point math optimization: ");
       return NULL;
@@ -2407,7 +2406,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
   if (code != COND_EXPR
       && ((!def1 || gimple_nop_p (def1)) && (!def2 || gimple_nop_p (def2))))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  report_vect_op (MSG_NOTE, def_stmt, "reduction: no defs for operands: ");
       return NULL;
     }
@@ -2429,7 +2428,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
                           == vect_internal_def
               && !is_loop_header_bb_p (gimple_bb (def1)))))))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
       return def_stmt;
     }
@@ -2452,7 +2451,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
           /* Swap operands (just for simplicity - so that the rest of the code
      can assume that the reduction variable is always the last (second)
      argument).  */
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
     report_vect_op (MSG_NOTE, def_stmt,
               "detected reduction: need to swap operands: ");

@@ -2464,7 +2463,7 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
         }
       else
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             report_vect_op (MSG_NOTE, def_stmt, "detected reduction: ");
         }

@@ -2474,14 +2473,14 @@  vect_is_simple_reduction_1 (loop_vec_info loop_inf
   /* Try to find SLP reduction chain.  */
   if (check_reduction && vect_is_slp_reduction (loop_info, phi, def_stmt))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         report_vect_op (MSG_NOTE, def_stmt,
  "reduction: detected reduction chain: ");

       return def_stmt;
     }

-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     report_vect_op (MSG_MISSED_OPTIMIZATION, def_stmt,
     "reduction: unknown pattern: ");

@@ -2589,7 +2588,7 @@  vect_get_known_peeling_cost (loop_vec_info loop_vi
   if (!LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
     {
       *peel_iters_epilogue = vf/2;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "cost model: epilogue peel iters set to vf/2 "
  "because loop iterations are unknown .");
@@ -2882,7 +2881,7 @@  vect_estimate_min_profitable_iters (loop_vec_info
   /* vector version will never be profitable.  */
   else
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "cost model: the vector iteration cost = %d "
  "divided by the scalar iteration cost = %d "
@@ -2893,7 +2892,7 @@  vect_estimate_min_profitable_iters (loop_vec_info
       return;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "Cost model analysis: \n");
       dump_printf (MSG_NOTE, "  Vector inside of loop cost: %d\n",
@@ -2925,7 +2924,7 @@  vect_estimate_min_profitable_iters (loop_vec_info
        then skip the vectorized loop.  */
   min_profitable_iters--;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "  Runtime profitability threshold = %d\n",
min_profitable_iters);

@@ -2950,7 +2949,7 @@  vect_estimate_min_profitable_iters (loop_vec_info
     }
   min_profitable_estimate --;
   min_profitable_estimate = MAX (min_profitable_estimate,
min_profitable_iters);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "  Static estimate profitability threshold = %d\n",
                       min_profitable_iters);
@@ -3010,7 +3009,7 @@  vect_model_reduction_cost (stmt_vec_info stmt_info
   vectype = get_vectype_for_scalar_type (TREE_TYPE (reduction_op));
   if (!vectype)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "unsupported data-type ");
@@ -3081,7 +3080,7 @@  vect_model_reduction_cost (stmt_vec_info stmt_info
  }
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf (MSG_NOTE,
                  "vect_model_reduction_cost: inside_cost = %d, "
                  "prologue_cost = %d, epilogue_cost = %d .", inside_cost,
@@ -3110,7 +3109,7 @@  vect_model_induction_cost (stmt_vec_info stmt_info
   prologue_cost = add_stmt_cost (target_cost_data, 2, scalar_to_vec,
  stmt_info, 0, vect_prologue);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_model_induction_cost: inside_cost = %d, "
                      "prologue_cost = %d .", inside_cost, prologue_cost);
@@ -3239,7 +3238,7 @@  get_initial_def_for_induction (gimple iv_phi)
   new_bb = gsi_insert_on_edge_immediate (pe, init_stmt);
   gcc_assert (!new_bb);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
        "created new init_stmt: ");
@@ -3382,7 +3381,7 @@  get_initial_def_for_induction (gimple iv_phi)
       && !STMT_VINFO_LIVE_P (stmt_vinfo));

   STMT_VINFO_VEC_STMT (stmt_vinfo) = new_stmt;
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
        "vector of inductions after inner-loop:");
@@ -3392,7 +3391,7 @@  get_initial_def_for_induction (gimple iv_phi)
     }


-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
        "transform induction: created def-use cycle: ");
@@ -3800,7 +3799,7 @@  vect_create_epilog_for_reduction (VEC (tree, heap)

           add_phi_arg (phi, def, loop_latch_edge (loop), UNKNOWN_LOCATION);

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_NOTE, vect_location,
        "transform reduction: created def-use cycle: ");
@@ -4001,7 +4000,7 @@  vect_create_epilog_for_reduction (VEC (tree, heap)
       /*** Case 1:  Create:
            v_out2 = reduc_expr <v_out1>  */

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "Reduce using direct vector reduction.");

@@ -4052,7 +4051,7 @@  vect_create_epilog_for_reduction (VEC (tree, heap)
                   Create:  va = vop <va, va'>
                 }  */

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
      "Reduce using vector shifts");

@@ -4093,7 +4092,7 @@  vect_create_epilog_for_reduction (VEC (tree, heap)
                  Create:  s = op <s, s'>  // For non SLP cases
                }  */

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
      "Reduce using scalar code. ");

@@ -4184,7 +4183,7 @@  vect_create_epilog_for_reduction (VEC (tree, heap)
     {
       tree rhs;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
  "extract scalar result");

@@ -4423,7 +4422,7 @@  vect_finalize_reduction:
                                UNKNOWN_LOCATION);
                   add_phi_arg (vect_phi, PHI_RESULT (inner_phi),
                                loop_latch_edge (outer_loop), UNKNOWN_LOCATION);
-                  if (dump_kind_p (MSG_NOTE))
+                  if (dump_enabled_p ())
                     {
                       dump_printf_loc (MSG_NOTE, vect_location,
        "created double reduction phi node: ");
@@ -4773,7 +4772,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
     {
       if (!vectorizable_condition (stmt, gsi, NULL, ops[reduc_index], 0, NULL))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "unsupported condition in reduction");

@@ -4788,7 +4787,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
       optab = optab_for_tree_code (code, vectype_in, optab_default);
       if (!optab)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "no optab.");

@@ -4797,7 +4796,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i

       if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf (MSG_NOTE, "op not supported by target.");

           if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
@@ -4805,7 +4804,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
           < vect_min_worthwhile_factor (code))
             return false;

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
       dump_printf (MSG_NOTE, "proceeding using word mode.");
         }

@@ -4814,7 +4813,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
           && LOOP_VINFO_VECT_FACTOR (loop_vinfo)
        < vect_min_worthwhile_factor (code))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "not worthwhile without SIMD support.");

@@ -4895,7 +4894,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
                                          optab_default);
       if (!reduc_optab)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "no optab for reduction.");

@@ -4905,7 +4904,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
       if (reduc_optab
           && optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "reduc op not supported by target.");

@@ -4916,7 +4915,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
     {
       if (!nested_cycle || double_reduc)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "no reduc code for scalar code.");

@@ -4926,7 +4925,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i

   if (double_reduc && ncopies > 1)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "multiple types in double reduction");

@@ -4945,7 +4944,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i
         ops[1] = fold_convert (TREE_TYPE (ops[0]), ops[1]);
       else
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "invalid types in dot-prod");

@@ -4963,7 +4962,7 @@  vectorizable_reduction (gimple stmt, gimple_stmt_i

   /** Transform.  **/

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "transform reduction.");

   /* FORNOW: Multiple types are not supported for condition.  */
@@ -5249,7 +5248,7 @@  vectorizable_induction (gimple phi, gimple_stmt_it

       if (ncopies > 1)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "multiple types in nested loop.");
   return false;
@@ -5273,7 +5272,7 @@  vectorizable_induction (gimple phi, gimple_stmt_it
   if (!(STMT_VINFO_RELEVANT_P (exit_phi_vinfo)
  && !STMT_VINFO_LIVE_P (exit_phi_vinfo)))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "inner-loop induction only used outside "
  "of the outer vectorized loop.");
@@ -5297,7 +5296,7 @@  vectorizable_induction (gimple phi, gimple_stmt_it
   if (!vec_stmt) /* transformation not required.  */
     {
       STMT_VINFO_TYPE (stmt_info) = induc_vec_info_type;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "=== vectorizable_induction ===");
       vect_model_induction_cost (stmt_info, ncopies);
@@ -5306,7 +5305,7 @@  vectorizable_induction (gimple phi, gimple_stmt_it

   /** Transform.  **/

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "transform induction phi.");

   vec_def = get_initial_def_for_induction (phi);
@@ -5371,7 +5370,7 @@  vectorizable_live_operation (gimple stmt,
           && !vect_is_simple_use (op, stmt, loop_vinfo, NULL, &def_stmt, &def,
   &dt))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "use not simple.");
           return false;
@@ -5410,7 +5409,7 @@  vect_loop_kill_debug_uses (struct loop *loop, gimp
     {
       if (gimple_debug_bind_p (ustmt))
  {
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                                      "killing debug use");

@@ -5450,7 +5449,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
   bool check_profitability = false;
   int th;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "=== vec_transform_loop ===");

   /* Use the more conservative vectorization threshold.  If the number
@@ -5464,7 +5463,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
   if (th >= LOOP_VINFO_VECT_FACTOR (loop_vinfo) - 1
       && !LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
  "Profitability threshold is %d loop iterations.", th);
       check_profitability = true;
@@ -5525,7 +5524,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
         {
   phi = gsi_stmt (si);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "------>vectorizing phi: ");
@@ -5544,12 +5543,12 @@  vect_transform_loop (loop_vec_info loop_vinfo)

   if ((TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info))
         != (unsigned HOST_WIDE_INT) vectorization_factor)
-      && dump_kind_p (MSG_NOTE))
+      && dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "multiple-types.");

   if (STMT_VINFO_DEF_TYPE (stmt_info) == vect_induction_def)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location, "transform phi.");
       vect_transform_stmt (phi, NULL, NULL, NULL, NULL);
     }
@@ -5565,7 +5564,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
           else
             stmt = gsi_stmt (si);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
        "------>vectorizing statement: ");
@@ -5637,7 +5636,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)

   if (!gsi_end_p (pattern_def_si))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
    "==> vectorizing pattern def "
@@ -5664,7 +5663,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
                                                STMT_VINFO_VECTYPE (stmt_info));
   if (!STMT_SLP_TYPE (stmt_info)
       && nunits != (unsigned int) vectorization_factor
-              && dump_kind_p (MSG_NOTE))
+              && dump_enabled_p ())
     /* For SLP VF is set according to unrolling factor, and not to
        vector size, hence for SLP this print is not valid.  */
             dump_printf_loc (MSG_NOTE, vect_location,
@@ -5678,7 +5677,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
  {
   slp_scheduled = true;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
      "=== scheduling SLP instances ===");

@@ -5698,7 +5697,7 @@  vect_transform_loop (loop_vec_info loop_vinfo)
     }

   /* -------- vectorize statement ------------ */
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "transform statement.");

   grouped_store = false;
@@ -5741,9 +5740,9 @@  vect_transform_loop (loop_vec_info loop_vinfo)
      until all the loops have been transformed?  */
   update_ssa (TODO_update_ssa);

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location, "LOOP
VECTORIZED.");
-  if (loop->inner && dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (loop->inner && dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
      "OUTER LOOP VECTORIZED.");
 }
Index: tree-vect-data-refs.c
===================================================================
--- tree-vect-data-refs.c (revision 192695)
+++ tree-vect-data-refs.c (working copy)
@@ -60,7 +60,7 @@  vect_lanes_optab_supported_p (const char *name, co

   if (array_mode == BLKmode)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "no array mode for %s[" HOST_WIDE_INT_PRINT_DEC "]",
                          GET_MODE_NAME (mode), count);
@@ -69,14 +69,14 @@  vect_lanes_optab_supported_p (const char *name, co

   if (convert_optab_handler (optab, array_mode, mode) == CODE_FOR_nothing)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "cannot use %s<%s><%s>", name,
                          GET_MODE_NAME (array_mode), GET_MODE_NAME (mode));
       return false;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "can use %s<%s><%s>", name, GET_MODE_NAME (array_mode),
                      GET_MODE_NAME (mode));
@@ -439,7 +439,7 @@  vect_check_interleaving (struct data_reference *dr
       if (diff_mod_size == 0)
  {
   vect_update_interleaving_chain (drb, dra);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "Detected interleaving ");
@@ -462,7 +462,7 @@  vect_check_interleaving (struct data_reference *dr
       if (diff_mod_size == 0)
  {
   vect_update_interleaving_chain (dra, drb);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "Detected interleaving ");
@@ -524,7 +524,7 @@  vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
   if ((unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS) == 0)
     return false;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                        "mark for run-time aliasing test between ");
@@ -535,7 +535,7 @@  vect_mark_for_runtime_alias_test (ddr_p ddr, loop_

   if (optimize_loop_nest_for_size_p (loop))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "versioning not supported when optimizing for size.");
       return false;
@@ -544,7 +544,7 @@  vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
   /* FORNOW: We don't support versioning with outer-loop vectorization.  */
   if (loop->inner)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "versioning not yet supported for outer-loops.");
       return false;
@@ -555,7 +555,7 @@  vect_mark_for_runtime_alias_test (ddr_p ddr, loop_
   if (TREE_CODE (DR_STEP (DDR_A (ddr))) != INTEGER_CST
       || TREE_CODE (DR_STEP (DDR_B (ddr))) != INTEGER_CST)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "versioning not yet supported for non-constant "
                          "step");
@@ -611,7 +611,7 @@  vect_analyze_data_ref_dependence (struct data_depe

       if (loop_vinfo)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "versioning for alias required: "
@@ -637,7 +637,7 @@  vect_analyze_data_ref_dependence (struct data_depe
       if (DR_IS_READ (dra) && DR_IS_READ (drb))
         return false;

-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "can't determine dependence between ");
@@ -666,7 +666,7 @@  vect_analyze_data_ref_dependence (struct data_depe
       if (dra != drb && vect_check_interleaving (dra, drb))
         return false;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
                            "determined dependence between ");
@@ -686,7 +686,7 @@  vect_analyze_data_ref_dependence (struct data_depe
   /* Loop-based vectorization and known data dependence.  */
   if (DDR_NUM_DIST_VECTS (ddr) == 0)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "versioning for alias required: "
@@ -704,13 +704,13 @@  vect_analyze_data_ref_dependence (struct data_depe
     {
       int dist = dist_v[loop_depth];

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "dependence distance  = %d.", dist);

       if (dist == 0)
  {
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "dependence distance == 0 between ");
@@ -737,7 +737,7 @@  vect_analyze_data_ref_dependence (struct data_depe
   /* If DDR_REVERSED_P the order of the data-refs in DDR was
      reversed (to make distance vector positive), and the actual
      distance is negative.  */
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "dependence distance negative.");
   continue;
@@ -749,7 +749,7 @@  vect_analyze_data_ref_dependence (struct data_depe
   /* The dependence distance requires reduction of the maximal
      vectorization factor.  */
   *max_vf = abs (dist);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                              "adjusting maximal vectorization factor to %i",
                              *max_vf);
@@ -759,13 +759,13 @@  vect_analyze_data_ref_dependence (struct data_depe
  {
   /* Dependence distance does not create dependence, as far as
      vectorization is concerned, in this case.  */
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                              "dependence distance >= VF.");
   continue;
  }

-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                        "not vectorized, possible dependence "
@@ -795,7 +795,7 @@  vect_analyze_data_ref_dependences (loop_vec_info l
   VEC (ddr_p, heap) *ddrs = NULL;
   struct data_dependence_relation *ddr;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_analyze_dependences ===");
   if (loop_vinfo)
@@ -837,7 +837,7 @@  vect_compute_data_ref_alignment (struct data_refer
   tree misalign;
   tree aligned_to, alignment;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_compute_data_ref_alignment:");

@@ -870,7 +870,7 @@  vect_compute_data_ref_alignment (struct data_refer

       if (dr_step % GET_MODE_SIZE (TYPE_MODE (vectype)) == 0)
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
                              "inner step divides the vector-size.");
   misalign = STMT_VINFO_DR_INIT (stmt_info);
@@ -879,7 +879,7 @@  vect_compute_data_ref_alignment (struct data_refer
         }
       else
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "inner step doesn't divide the vector-size.");
   misalign = NULL_TREE;
@@ -898,7 +898,7 @@  vect_compute_data_ref_alignment (struct data_refer

       if (dr_step % GET_MODE_SIZE (TYPE_MODE (vectype)) != 0)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "SLP: step doesn't divide the vector-size.");
   misalign = NULL_TREE;
@@ -911,7 +911,7 @@  vect_compute_data_ref_alignment (struct data_refer
   if ((aligned_to && tree_int_cst_compare (aligned_to, alignment) < 0)
       || !misalign)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "Unknown alignment for access: ");
@@ -941,7 +941,7 @@  vect_compute_data_ref_alignment (struct data_refer
       if (!vect_can_force_dr_alignment_p (base, TYPE_ALIGN (vectype))
   || (TREE_STATIC (base) && flag_section_anchors))
  {
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "can't force alignment of ref: ");
@@ -953,7 +953,7 @@  vect_compute_data_ref_alignment (struct data_refer
       /* Force the alignment of the decl.
  NOTE: This is the only change to the code we make during
  the analysis phase, before deciding to vectorize the loop.  */
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location, "force alignment of ");
           dump_generic_expr (MSG_NOTE, TDF_SLIM, ref);
@@ -987,7 +987,7 @@  vect_compute_data_ref_alignment (struct data_refer
   if (!host_integerp (misalign, 1))
     {
       /* Negative or overflowed misalignment value.  */
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "unexpected misalign value");
       return false;
@@ -995,7 +995,7 @@  vect_compute_data_ref_alignment (struct data_refer

   SET_DR_MISALIGNMENT (dr, TREE_INT_CST_LOW (misalign));

-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                        "misalign = %d bytes of ref ", DR_MISALIGNMENT (dr));
@@ -1095,7 +1095,7 @@  vect_update_misalignment_for_peel (struct data_ref
       return;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "Setting misalignment to -1.");
   SET_DR_MISALIGNMENT (dr, -1);
 }
@@ -1142,7 +1142,7 @@  vect_verify_datarefs_alignment (loop_vec_info loop
       supportable_dr_alignment = vect_supportable_dr_alignment (dr, false);
       if (!supportable_dr_alignment)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               if (DR_IS_READ (dr))
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
@@ -1157,8 +1157,7 @@  vect_verify_datarefs_alignment (loop_vec_info loop
             }
           return false;
         }
-      if (supportable_dr_alignment != dr_aligned
-          && dump_kind_p (MSG_NOTE))
+      if (supportable_dr_alignment != dr_aligned && dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "Vectorizing an unaligned access.");
     }
@@ -1215,7 +1214,7 @@  vector_alignment_reachable_p (struct data_referenc
     {
       HOST_WIDE_INT elmsize =
  int_cst_value (TYPE_SIZE_UNIT (TREE_TYPE (vectype)));
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
                            "data size =" HOST_WIDE_INT_PRINT_DEC, elmsize);
@@ -1224,7 +1223,7 @@  vector_alignment_reachable_p (struct data_referenc
  }
       if (DR_MISALIGNMENT (dr) % elmsize)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "data size does not divide the misalignment.\n");
   return false;
@@ -1235,7 +1234,7 @@  vector_alignment_reachable_p (struct data_referenc
     {
       tree type = TREE_TYPE (DR_REF (dr));
       bool is_packed = not_size_aligned (DR_REF (dr));
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "Unknown misalignment, is_packed = %d",is_packed);
       if (targetm.vectorize.vector_alignment_reachable (type, is_packed))
@@ -1269,7 +1268,7 @@  vect_get_data_access_cost (struct data_reference *
   else
     vect_get_store_cost (dr, ncopies, inside_cost, body_cost_vec);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_get_data_access_cost: inside_cost = %d, "
                      "outside_cost = %d.", *inside_cost, *outside_cost);
@@ -1567,7 +1566,7 @@  vect_enhance_data_refs_alignment (loop_vec_info lo
   unsigned int nelements, mis, same_align_drs_max = 0;
   stmt_vector_for_cost body_cost_vec = NULL;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_enhance_data_refs_alignment ===");

@@ -1622,7 +1621,7 @@  vect_enhance_data_refs_alignment (loop_vec_info lo
  and so we can't generate the new base for the pointer.  */
       if (STMT_VINFO_STRIDE_LOAD_P (stmt_info))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "strided load prevents peeling");
   do_peeling = false;
@@ -1738,7 +1737,7 @@  vect_enhance_data_refs_alignment (loop_vec_info lo
         {
           if (!aligned_access_p (dr))
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "vector alignment may not be reachable");
               break;
@@ -1879,7 +1878,7 @@  vect_enhance_data_refs_alignment (loop_vec_info lo
   if (STMT_VINFO_GROUPED_ACCESS (stmt_info))
     npeel /= GROUP_SIZE (stmt_info);

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
                              "Try peeling by %d", npeel);
         }
@@ -1951,7 +1950,7 @@  vect_enhance_data_refs_alignment (loop_vec_info lo
           else
             LOOP_PEELING_FOR_ALIGNMENT (loop_vinfo) = DR_MISALIGNMENT (dr0);
   SET_DR_MISALIGNMENT (dr0, 0);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_NOTE, vect_location,
                                "Alignment of access forced using peeling.");
@@ -2077,12 +2076,12 @@  vect_enhance_data_refs_alignment (loop_vec_info lo
           stmt_vec_info stmt_info = vinfo_for_stmt (stmt);
           dr = STMT_VINFO_DATA_REF (stmt_info);
   SET_DR_MISALIGNMENT (dr, 0);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
                              "Alignment of access forced using versioning.");
         }

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "Versioning for alignment will be applied.");

@@ -2148,7 +2147,7 @@  vect_find_same_alignment_drs (struct data_dependen
     {
       int dist = dist_v[loop_depth];

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "dependence distance  = %d.", dist);

@@ -2159,7 +2158,7 @@  vect_find_same_alignment_drs (struct data_dependen
   /* Two references with distance zero have the same alignment.  */
   VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_a), drb);
   VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_b), dra);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
               dump_printf_loc (MSG_NOTE, vect_location,
                                "accesses have the same alignment.");
@@ -2183,7 +2182,7 @@  bool
 vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo,
                                   bb_vec_info bb_vinfo)
 {
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_analyze_data_refs_alignment ===");

@@ -2201,7 +2200,7 @@  vect_analyze_data_refs_alignment (loop_vec_info lo

   if (!vect_compute_data_refs_alignment (loop_vinfo, bb_vinfo))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not vectorized: can't calculate alignment "
                          "for data ref.");
@@ -2254,7 +2253,7 @@  vect_analyze_group_access (struct data_reference *
  {
   GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) = stmt;
   GROUP_SIZE (vinfo_for_stmt (stmt)) = groupsize;
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "Detected single element interleaving ");
@@ -2265,13 +2264,13 @@  vect_analyze_group_access (struct data_reference *

   if (loop_vinfo)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                                  "Data access with gaps requires scalar "
                                  "epilogue loop");
               if (loop->inner)
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                      "Peeling for outer loop is not"
                                      " supported");
@@ -2284,7 +2283,7 @@  vect_analyze_group_access (struct data_reference *
   return true;
  }

-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "not consecutive access ");
@@ -2324,7 +2323,7 @@  vect_analyze_group_access (struct data_reference *
             {
               if (DR_IS_WRITE (data_ref))
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                      "Two store stmts share the same dr.");
                   return false;
@@ -2335,7 +2334,7 @@  vect_analyze_group_access (struct data_reference *
               if (GROUP_READ_WRITE_DEPENDENCE (vinfo_for_stmt (next))
                   || GROUP_READ_WRITE_DEPENDENCE (vinfo_for_stmt (prev)))
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                      "READ_WRITE dependence in interleaving.");
                   return false;
@@ -2355,7 +2354,7 @@  vect_analyze_group_access (struct data_reference *
           next_step = DR_STEP (STMT_VINFO_DATA_REF (vinfo_for_stmt (next)));
           if (tree_int_cst_compare (step, next_step))
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "not consecutive access in interleaving");
               return false;
@@ -2372,7 +2371,7 @@  vect_analyze_group_access (struct data_reference *
       slp_impossible = true;
       if (DR_IS_WRITE (data_ref))
  {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                      "interleaved store with gaps");
   return false;
@@ -2401,7 +2400,7 @@  vect_analyze_group_access (struct data_reference *
          greater than STEP.  */
       if (dr_step && dr_step < count_in_bytes + gaps * type_size)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "interleaving size is greater than step for ");
@@ -2424,7 +2423,7 @@  vect_analyze_group_access (struct data_reference *
             }
           else
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "interleaved store with gaps");
               return false;
@@ -2434,7 +2433,7 @@  vect_analyze_group_access (struct data_reference *
       /* Check that STEP is a multiple of type size.  */
       if (dr_step && (dr_step % type_size) != 0)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "step is not a multiple of type size: step ");
@@ -2450,7 +2449,7 @@  vect_analyze_group_access (struct data_reference *
         groupsize = count;

       GROUP_SIZE (vinfo_for_stmt (stmt)) = groupsize;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "Detected interleaving of size %d", (int)groupsize);

@@ -2469,13 +2468,13 @@  vect_analyze_group_access (struct data_reference *
       /* There is a gap in the end of the group.  */
       if (groupsize - last_accessed_element > 0 && loop_vinfo)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "Data access with gaps requires scalar "
                              "epilogue loop");
           if (loop->inner)
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "Peeling for outer loop is not supported");
               return false;
@@ -2508,7 +2507,7 @@  vect_analyze_data_ref_access (struct data_referenc

   if (loop_vinfo && !step)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "bad data-ref access in loop");
       return false;
@@ -2531,7 +2530,7 @@  vect_analyze_data_ref_access (struct data_referenc
       step = STMT_VINFO_DR_STEP (stmt_info);
       if (integer_zerop (step))
  {
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                              "zero step in outer loop.");
   if (DR_IS_READ (dr))
@@ -2557,7 +2556,7 @@  vect_analyze_data_ref_access (struct data_referenc

   if (loop && nested_in_vect_loop_p (loop, stmt))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "grouped access in outer loop.");
       return false;
@@ -2588,7 +2587,7 @@  vect_analyze_data_ref_accesses (loop_vec_info loop
   VEC (data_reference_p, heap) *datarefs;
   struct data_reference *dr;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_analyze_data_ref_accesses ===");

@@ -2601,7 +2600,7 @@  vect_analyze_data_ref_accesses (loop_vec_info loop
     if (STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (DR_STMT (dr)))
         && !vect_analyze_data_ref_access (dr))
       {
- if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+ if (dump_enabled_p ())
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "not vectorized: complicated access pattern.");

@@ -2631,7 +2630,7 @@  vect_prune_runtime_alias_test_list (loop_vec_info
     LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo);
   unsigned i, j;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_prune_runtime_alias_test_list ===");

@@ -2649,7 +2648,7 @@  vect_prune_runtime_alias_test_list (loop_vec_info

   if (vect_vfa_range_equal (ddr_i, ddr_j))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
                                    "found equal ranges ");
@@ -2677,7 +2676,7 @@  vect_prune_runtime_alias_test_list (loop_vec_info
   if (VEC_length (ddr_p, ddrs) >
        (unsigned) PARAM_VALUE (PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION,  vect_location,
                            "disable versioning for alias - max number of "
@@ -2964,7 +2963,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
   tree scalar_type;
   bool res, stop_bb_analysis = false;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_analyze_data_refs ===\n");

@@ -2979,7 +2978,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (!res)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "not vectorized: loop contains function calls"
                              " or data references that cannot be analyzed");
@@ -3011,7 +3010,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
       if (!compute_all_dependences (BB_VINFO_DATAREFS (bb_vinfo),
     &BB_VINFO_DDRS (bb_vinfo), NULL, true))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "not vectorized: basic block contains function"
                              " calls or data references that cannot be"
@@ -3035,7 +3034,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (!dr || !DR_REF (dr))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "not vectorized: unhandled data-ref ");
           return false;
@@ -3081,7 +3080,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

   if (!gather)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: data ref analysis "
@@ -3102,7 +3101,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (TREE_CODE (DR_BASE_ADDRESS (dr)) == INTEGER_CST)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "not vectorized: base addr of dr is a "
                              "constant");
@@ -3121,7 +3120,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (TREE_THIS_VOLATILE (DR_REF (dr)))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "not vectorized: volatile type ");
@@ -3140,7 +3139,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (stmt_can_throw_internal (stmt))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "not vectorized: statement can throw an "
@@ -3163,7 +3162,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
       if (TREE_CODE (DR_REF (dr)) == COMPONENT_REF
   && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (dr), 1)))
  {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "not vectorized: statement is bitfield "
@@ -3189,7 +3188,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (is_gimple_call (stmt))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION,  vect_location,
                                "not vectorized: dr in a call ");
@@ -3232,7 +3231,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
           tree inner_base = build_fold_indirect_ref
                                 (fold_build_pointer_plus (base, init));

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "analyze in outer-loop: ");
@@ -3245,7 +3244,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

   if (pbitpos % BITS_PER_UNIT != 0)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "failed: bit offset alignment.\n");
       return false;
@@ -3255,7 +3254,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
   if (!simple_iv (loop, loop_containing_stmt (stmt), outer_base,
                           &base_iv, false))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "failed: evolution of base is not affine.\n");
       return false;
@@ -3278,7 +3277,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
   else if (!simple_iv (loop, loop_containing_stmt (stmt), poffset,
                                &offset_iv, false))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "evolution of offset is not affine.\n");
       return false;
@@ -3303,7 +3302,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
   STMT_VINFO_DR_ALIGNED_TO (stmt_info) =
  size_int (highest_pow2_factor (offset_iv.base));

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                                "\touter base_address: ");
@@ -3327,7 +3326,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

       if (STMT_VINFO_DATA_REF (stmt_info))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "not vectorized: more than one data ref "
@@ -3355,7 +3354,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
                 get_vectype_for_scalar_type (scalar_type);
       if (!STMT_VINFO_VECTYPE (stmt_info))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                "not vectorized: no vectype for stmt: ");
@@ -3406,7 +3405,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
     {
       STMT_VINFO_DATA_REF (stmt_info) = NULL;
       free_data_ref (dr);
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: not suitable for gather "
@@ -3459,7 +3458,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,

   if (bad)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: data dependence conflict"
@@ -3480,7 +3479,7 @@  vect_analyze_data_refs (loop_vec_info loop_vinfo,
       = vect_check_strided_load (stmt, loop_vinfo, NULL, NULL);
   if (!strided_load)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "not vectorized: not suitable for strided "
@@ -3668,7 +3667,7 @@  vect_create_addr_base_for_vector_ref (gimple stmt,
  mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (vec_stmt));
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "created ");
       dump_generic_expr (MSG_NOTE, TDF_SLIM, vec_stmt);
@@ -3790,7 +3789,7 @@  vect_create_data_ref_ptr (gimple stmt, tree aggr_t
      in LOOP.  */
   base_name = build_fold_indirect_ref (unshare_expr (DR_BASE_ADDRESS (dr)));

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       tree data_ref_base = base_name;
       dump_printf_loc (MSG_NOTE, vect_location,
@@ -4120,7 +4119,7 @@  vect_grouped_store_supported (tree vectype, unsign
   /* vect_permute_store_chain requires the group size to be a power of two.  */
   if (exact_log2 (count) == -1)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "the size of the group of accesses"
                          " is not a power of 2");
@@ -4146,7 +4145,7 @@  vect_grouped_store_supported (tree vectype, unsign
  }
     }

-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf (MSG_MISSED_OPTIMIZATION,
                  "interleave op not supported by target.");
   return false;
@@ -4564,7 +4563,7 @@  vect_grouped_load_supported (tree vectype, unsigne
   /* vect_permute_load_chain requires the group size to be a power of two.  */
   if (exact_log2 (count) == -1)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "the size of the group of accesses"
                          " is not a power of 2");
@@ -4588,7 +4587,7 @@  vect_grouped_load_supported (tree vectype, unsigne
  }
     }

-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                      "extract even/odd not supported by target");
   return false;
Index: tree-vect-patterns.c
===================================================================
--- tree-vect-patterns.c (revision 192695)
+++ tree-vect-patterns.c (working copy)
@@ -416,7 +416,7 @@  vect_recog_dot_prod_pattern (VEC (gimple, heap) **
   pattern_stmt = gimple_build_assign_with_ops (DOT_PROD_EXPR, var,
        oprnd00, oprnd01, oprnd1);

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                        "vect_recog_dot_prod_pattern: detected: ");
@@ -676,7 +676,7 @@  vect_recog_widen_mult_pattern (VEC (gimple, heap)
     return NULL;

   /* Pattern detected.  */
-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "vect_recog_widen_mult_pattern: detected: ");

@@ -699,7 +699,7 @@  vect_recog_widen_mult_pattern (VEC (gimple, heap)
   pattern_stmt = gimple_build_assign_with_ops (WIDEN_MULT_EXPR, var, oprnd0,
        oprnd1);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);

   VEC_safe_push (gimple, heap, *stmts, last_stmt);
@@ -912,7 +912,7 @@  vect_recog_widen_sum_pattern (VEC (gimple, heap) *
   pattern_stmt = gimple_build_assign_with_ops (WIDEN_SUM_EXPR, var,
        oprnd0, oprnd1);

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                        "vect_recog_widen_sum_pattern: detected: ");
@@ -1217,7 +1217,7 @@  vect_recog_over_widening_pattern (VEC (gimple, hea
       STMT_VINFO_RELATED_STMT (vinfo_for_stmt (stmt)) = pattern_stmt;
       new_pattern_def_seq (vinfo_for_stmt (stmt), new_def_stmt);

-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                            "created pattern stmt: ");
@@ -1285,7 +1285,7 @@  vect_recog_over_widening_pattern (VEC (gimple, hea
     return NULL;

   /* Pattern detected.  */
-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                        "vect_recog_over_widening_pattern: detected: ");
@@ -1421,7 +1421,7 @@  vect_recog_widen_shift_pattern (VEC (gimple, heap)
     return NULL;

   /* Pattern detected.  */
-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "vect_recog_widen_shift_pattern: detected: ");

@@ -1445,7 +1445,7 @@  vect_recog_widen_shift_pattern (VEC (gimple, heap)
   pattern_stmt =
     gimple_build_assign_with_ops (WIDEN_LSHIFT_EXPR, var, oprnd0, oprnd1);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);

   VEC_safe_push (gimple, heap, *stmts, last_stmt);
@@ -1567,7 +1567,7 @@  vect_recog_vector_vector_shift_pattern (VEC (gimpl
     }

   /* Pattern detected.  */
-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "vect_recog_vector_vector_shift_pattern: detected: ");

@@ -1575,7 +1575,7 @@  vect_recog_vector_vector_shift_pattern (VEC (gimpl
   var = vect_recog_temp_ssa_var (TREE_TYPE (oprnd0), NULL);
   pattern_stmt = gimple_build_assign_with_ops (rhs_code, var, oprnd0, def);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt, 0);

   VEC_safe_push (gimple, heap, *stmts, last_stmt);
@@ -1685,7 +1685,7 @@  vect_recog_divmod_pattern (VEC (gimple, heap) **st
  return NULL;

       /* Pattern detected.  */
-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                          "vect_recog_divmod_pattern: detected: ");

@@ -1789,7 +1789,7 @@  vect_recog_divmod_pattern (VEC (gimple, heap) **st
     signmask);
  }

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_gimple_stmt_loc (MSG_NOTE, vect_location, TDF_SLIM, pattern_stmt,
                               0);

@@ -2031,7 +2031,7 @@  vect_recog_divmod_pattern (VEC (gimple, heap) **st
     }

   /* Pattern detected.  */
-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                        "vect_recog_divmod_pattern: detected: ");
@@ -2199,7 +2199,7 @@  vect_recog_mixed_size_cond_pattern (VEC (gimple, h
   *type_in = vecitype;
   *type_out = vectype;

-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                      "vect_recog_mixed_size_cond_pattern: detected: ");

@@ -2592,7 +2592,7 @@  vect_recog_bool_pattern (VEC (gimple, heap) **stmt
       *type_out = vectype;
       *type_in = vectype;
       VEC_safe_push (gimple, heap, *stmts, last_stmt);
-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                          "vect_recog_bool_pattern: detected: ");

@@ -2638,7 +2638,7 @@  vect_recog_bool_pattern (VEC (gimple, heap) **stmt
       *type_out = vectype;
       *type_in = vectype;
       VEC_safe_push (gimple, heap, *stmts, last_stmt);
-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                          "vect_recog_bool_pattern: detected: ");
       return pattern_stmt;
@@ -2788,7 +2788,7 @@  vect_pattern_recog_1 (vect_recog_func_ptr vect_rec
     }

   /* Found a vectorizable pattern.  */
-  if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                        "pattern recognized: ");
@@ -2814,7 +2814,7 @@  vect_pattern_recog_1 (vect_recog_func_ptr vect_rec
     {
       stmt_info = vinfo_for_stmt (stmt);
       pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info);
-      if (dump_kind_p (MSG_OPTIMIZED_LOCATIONS))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
                            "additional pattern stmt: ");
@@ -2915,7 +2915,7 @@  vect_pattern_recog (loop_vec_info loop_vinfo, bb_v
   VEC (gimple, heap) *stmts_to_replace = VEC_alloc (gimple, heap, 1);
   gimple stmt;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_pattern_recog ===");

Index: tree-vect-stmts.c
===================================================================
--- tree-vect-stmts.c (revision 192695)
+++ tree-vect-stmts.c (working copy)
@@ -190,7 +190,7 @@  vect_mark_relevant (VEC(gimple,heap) **worklist, g
   bool save_live_p = STMT_VINFO_LIVE_P (stmt_info);
   gimple pattern_stmt;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "mark relevant %d, live %d.", relevant, live_p);

@@ -246,7 +246,7 @@  vect_mark_relevant (VEC(gimple,heap) **worklist, g

           pattern_stmt = STMT_VINFO_RELATED_STMT (stmt_info);

-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
                              "last stmt in pattern. don't mark"
                              " relevant/live.");
@@ -265,7 +265,7 @@  vect_mark_relevant (VEC(gimple,heap) **worklist, g
   if (STMT_VINFO_RELEVANT (stmt_info) == save_relevant
       && STMT_VINFO_LIVE_P (stmt_info) == save_live_p)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "already marked relevant/live.");
       return;
@@ -310,7 +310,7 @@  vect_stmt_relevant_p (gimple stmt, loop_vec_info l
   if (gimple_code (stmt) != GIMPLE_PHI)
     if (gimple_vdef (stmt))
       {
- if (dump_kind_p (MSG_NOTE))
+ if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
                            "vec_stmt_relevant_p: stmt has vdefs.");
  *relevant = vect_used_in_scope;
@@ -324,7 +324,7 @@  vect_stmt_relevant_p (gimple stmt, loop_vec_info l
   basic_block bb = gimple_bb (USE_STMT (use_p));
   if (!flow_bb_inside_loop_p (loop, bb))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                                  "vec_stmt_relevant_p: used out of loop.");

@@ -437,7 +437,7 @@  process_use (gimple stmt, tree use, loop_vec_info

   if (!vect_is_simple_use (use, stmt, loop_vinfo, NULL, &def_stmt, &def, &dt))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not vectorized: unsupported use in stmt.");
       return false;
@@ -449,7 +449,7 @@  process_use (gimple stmt, tree use, loop_vec_info
   def_bb = gimple_bb (def_stmt);
   if (!flow_bb_inside_loop_p (loop, def_bb))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location, "def_stmt is out of loop.");
       return true;
     }
@@ -467,7 +467,7 @@  process_use (gimple stmt, tree use, loop_vec_info
       && STMT_VINFO_DEF_TYPE (dstmt_vinfo) == vect_reduction_def
       && bb->loop_father == def_bb->loop_father)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "reduc-stmt defining reduc-phi in the same nest.");
       if (STMT_VINFO_IN_PATTERN_P (dstmt_vinfo))
@@ -487,7 +487,7 @@  process_use (gimple stmt, tree use, loop_vec_info
  ...  */
   if (flow_loop_nested_p (def_bb->loop_father, bb->loop_father))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "outer-loop def-stmt defining inner-loop stmt.");

@@ -525,7 +525,7 @@  process_use (gimple stmt, tree use, loop_vec_info
  stmt # use (d) */
   else if (flow_loop_nested_p (bb->loop_father, def_bb->loop_father))
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "inner-loop def-stmt defining outer-loop stmt.");

@@ -589,7 +589,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
   enum vect_relevant relevant, tmp_relevant;
   enum vect_def_type def_type;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "=== vect_mark_stmts_to_be_vectorized ===");

@@ -602,7 +602,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
       for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
  {
   phi = gsi_stmt (si);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "init: phi relevant? ");
       dump_gimple_stmt (MSG_NOTE, TDF_SLIM, phi, 0);
@@ -614,7 +614,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
       for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
  {
   stmt = gsi_stmt (si);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "init: stmt relevant? ");
       dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
@@ -632,7 +632,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
       ssa_op_iter iter;

       stmt = VEC_pop (gimple, worklist);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
           dump_printf_loc (MSG_NOTE, vect_location, "worklist:
examine stmt: ");
           dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
@@ -677,7 +677,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
             /* fall through */

         default:
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                      "unsupported use of reduction.");
             VEC_free (gimple, heap, worklist);
@@ -692,7 +692,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
                 && tmp_relevant != vect_used_in_outer_by_reduction
                 && tmp_relevant != vect_used_in_outer)
               {
-                if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                if (dump_enabled_p ())
                   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "unsupported use of nested cycle.");

@@ -707,7 +707,7 @@  vect_mark_stmts_to_be_vectorized (loop_vec_info lo
             if (tmp_relevant != vect_unused_in_scope
                 && tmp_relevant != vect_used_by_reduction)
               {
-                if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                if (dump_enabled_p ())
                   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                    "unsupported use of double reduction.");

@@ -830,7 +830,7 @@  vect_model_simple_cost (stmt_vec_info stmt_info, i
   inside_cost = record_stmt_cost (body_cost_vec, ncopies, vector_stmt,
   stmt_info, 0, vect_body);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_model_simple_cost: inside_cost = %d, "
                      "prologue_cost = %d .", inside_cost, prologue_cost);
@@ -876,7 +876,7 @@  vect_model_promotion_demotion_cost (stmt_vec_info
       prologue_cost += add_stmt_cost (target_cost_data, 1, vector_stmt,
       stmt_info, 0, vect_prologue);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_model_promotion_demotion_cost: inside_cost = %d, "
                      "prologue_cost = %d .", inside_cost, prologue_cost);
@@ -960,7 +960,7 @@  vect_model_store_cost (stmt_vec_info stmt_info, in
       inside_cost = record_stmt_cost (body_cost_vec, nstmts, vec_perm,
       stmt_info, 0, vect_body);

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "vect_model_store_cost: strided group_size = %d .",
                          group_size);
@@ -969,7 +969,7 @@  vect_model_store_cost (stmt_vec_info stmt_info, in
   /* Costs of the stores.  */
   vect_get_store_cost (first_dr, ncopies, &inside_cost, body_cost_vec);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_model_store_cost: inside_cost = %d, "
                      "prologue_cost = %d .", inside_cost, prologue_cost);
@@ -994,7 +994,7 @@  vect_get_store_cost (struct data_reference *dr, in
   vector_store, stmt_info, 0,
   vect_body);

-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_store_cost: aligned.");
         break;
@@ -1006,7 +1006,7 @@  vect_get_store_cost (struct data_reference *dr, in
  *inside_cost += record_stmt_cost (body_cost_vec, ncopies,
   unaligned_store, stmt_info,
   DR_MISALIGNMENT (dr), vect_body);
-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_store_cost: unaligned supported by "
                            "hardware.");
@@ -1017,7 +1017,7 @@  vect_get_store_cost (struct data_reference *dr, in
       {
         *inside_cost = VECT_MAX_COST;

-        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "vect_model_store_cost: unsupported access.");
         break;
@@ -1076,7 +1076,7 @@  vect_model_load_cost (stmt_vec_info stmt_info, int
       inside_cost += record_stmt_cost (body_cost_vec, nstmts, vec_perm,
        stmt_info, 0, vect_body);

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "vect_model_load_cost: strided group_size = %d .",
                          group_size);
@@ -1100,7 +1100,7 @@  vect_model_load_cost (stmt_vec_info stmt_info, int
  &inside_cost, &prologue_cost,
  prologue_cost_vec, body_cost_vec, true);

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "vect_model_load_cost: inside_cost = %d, "
                      "prologue_cost = %d .", inside_cost, prologue_cost);
@@ -1127,7 +1127,7 @@  vect_get_load_cost (struct data_reference *dr, int
  *inside_cost += record_stmt_cost (body_cost_vec, ncopies, vector_load,
   stmt_info, 0, vect_body);

-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_load_cost: aligned.");

@@ -1140,7 +1140,7 @@  vect_get_load_cost (struct data_reference *dr, int
   unaligned_load, stmt_info,
   DR_MISALIGNMENT (dr), vect_body);

-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_load_cost: unaligned supported by "
                            "hardware.");
@@ -1161,7 +1161,7 @@  vect_get_load_cost (struct data_reference *dr, int
   *inside_cost += record_stmt_cost (body_cost_vec, 1, vector_stmt,
     stmt_info, 0, vect_body);

-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_load_cost: explicit realign");

@@ -1169,7 +1169,7 @@  vect_get_load_cost (struct data_reference *dr, int
       }
     case dr_explicit_realign_optimized:
       {
-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_load_cost: unaligned software "
                            "pipelined.");
@@ -1197,7 +1197,7 @@  vect_get_load_cost (struct data_reference *dr, int
  *inside_cost += record_stmt_cost (body_cost_vec, ncopies, vec_perm,
   stmt_info, 0, vect_body);

-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "vect_model_load_cost: explicit realign optimized");

@@ -1208,7 +1208,7 @@  vect_get_load_cost (struct data_reference *dr, int
       {
         *inside_cost = VECT_MAX_COST;

-        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "vect_model_load_cost: unsupported access.");
         break;
@@ -1258,7 +1258,7 @@  vect_init_vector_1 (gimple stmt, gimple new_stmt,
        }
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                        "created new init_stmt: ");
@@ -1340,7 +1340,7 @@  vect_get_vec_def_for_operand (tree op, gimple stmt
   bool is_simple_use;
   tree vector_type;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                        "vect_get_vec_def_for_operand: ");
@@ -1350,7 +1350,7 @@  vect_get_vec_def_for_operand (tree op, gimple stmt
   is_simple_use = vect_is_simple_use (op, stmt, loop_vinfo, NULL,
       &def_stmt, &def, &dt);
   gcc_assert (is_simple_use);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       int loc_printed = 0;
       if (def)
@@ -1382,7 +1382,7 @@  vect_get_vec_def_for_operand (tree op, gimple stmt
   *scalar_def = op;

         /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location,
                            "Create vector_cst. nunits = %d", nunits);

@@ -1399,7 +1399,7 @@  vect_get_vec_def_for_operand (tree op, gimple stmt
   *scalar_def = def;

         /* Create 'vec_inv = {inv,inv,..,inv}'  */
-        if (dump_kind_p (MSG_NOTE))
+        if (dump_enabled_p ())
           dump_printf_loc (MSG_NOTE, vect_location, "Create vector_inv.");

         return vect_init_vector (stmt, def, vector_type, NULL);
@@ -1661,7 +1661,7 @@  vect_finish_stmt_generation (gimple stmt, gimple v
   set_vinfo_for_stmt (vec_stmt, new_stmt_vec_info (vec_stmt, loop_vinfo,
                                                    bb_vinfo));

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "add new stmt: ");
       dump_gimple_stmt (MSG_NOTE, TDF_SLIM, vec_stmt, 0);
@@ -1764,7 +1764,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat
       if (rhs_type
   && !types_compatible_p (rhs_type, TREE_TYPE (op)))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "argument types differ.");
   return false;
@@ -1775,7 +1775,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat
       if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
  &def_stmt, &def, &dt[i], &opvectype))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "use not simple.");
   return false;
@@ -1786,7 +1786,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat
       else if (opvectype
        && opvectype != vectype_in)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "argument vector types differ.");
   return false;
@@ -1800,7 +1800,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat
     gcc_assert (vectype_in);
   if (!vectype_in)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "no vectype for scalar type ");
@@ -1829,7 +1829,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat
   fndecl = vectorizable_function (stmt, vectype_out, vectype_in);
   if (fndecl == NULL_TREE)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "function is not vectorizable.");

@@ -1852,7 +1852,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat
   if (!vec_stmt) /* transformation not required.  */
     {
       STMT_VINFO_TYPE (stmt_info) = call_vec_info_type;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location, "=== vectorizable_call ===");
       vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
       return true;
@@ -1860,7 +1860,7 @@  vectorizable_call (gimple stmt, gimple_stmt_iterat

   /** Transform.  **/

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "transform call.");

   /* Handle def.  */
@@ -2375,7 +2375,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_
   && (TYPE_PRECISION (rhs_type)
       != GET_MODE_PRECISION (TYPE_MODE (rhs_type)))))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "type conversion to/from bit-precision unsupported.");
       return false;
@@ -2385,7 +2385,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_
   if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
      &def_stmt, &def, &dt[0], &vectype_in))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "use not simple.");
       return false;
@@ -2407,7 +2407,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_

       if (!ok)
  {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "use not simple.");
   return false;
@@ -2422,7 +2422,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_
     gcc_assert (vectype_in);
   if (!vectype_in)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "no vectype for scalar type ");
@@ -2466,7 +2466,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_
  break;
       /* FALLTHRU */
     unsupported:
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "conversion not supported by target.");
       return false;
@@ -2565,7 +2565,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_

   if (!vec_stmt) /* transformation not required.  */
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                          "=== vectorizable_conversion ===");
       if (code == FIX_TRUNC_EXPR || code == FLOAT_EXPR)
@@ -2588,7 +2588,7 @@  vectorizable_conversion (gimple stmt, gimple_stmt_
     }

   /** Transform.  **/
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "transform conversion. ncopies = %d.", ncopies);

@@ -2941,7 +2941,7 @@  vectorizable_assignment (gimple stmt, gimple_stmt_
   if (!vect_is_simple_use_1 (op, stmt, loop_vinfo, bb_vinfo,
      &def_stmt, &def, &dt[0], &vectype_in))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "use not simple.");
       return false;
@@ -2970,7 +2970,7 @@  vectorizable_assignment (gimple stmt, gimple_stmt_
     > TYPE_PRECISION (TREE_TYPE (op)))
    && TYPE_UNSIGNED (TREE_TYPE (op))))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "type conversion to/from bit-precision "
                          "unsupported.");
@@ -2980,7 +2980,7 @@  vectorizable_assignment (gimple stmt, gimple_stmt_
   if (!vec_stmt) /* transformation not required.  */
     {
       STMT_VINFO_TYPE (stmt_info) = assignment_vec_info_type;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "=== vectorizable_assignment ===");
       vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
@@ -2988,7 +2988,7 @@  vectorizable_assignment (gimple stmt, gimple_stmt_
     }

   /** Transform.  **/
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "transform assignment.");

   /* Handle def.  */
@@ -3135,7 +3135,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   if (TYPE_PRECISION (TREE_TYPE (scalar_dest))
       != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (scalar_dest))))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "bit-precision shifts not supported.");
       return false;
@@ -3145,7 +3145,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
                              &def_stmt, &def, &dt[0], &vectype))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "use not simple.");
       return false;
@@ -3158,7 +3158,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
     gcc_assert (vectype);
   if (!vectype)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "no vectype for scalar type ");
       return false;
@@ -3173,7 +3173,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   if (!vect_is_simple_use_1 (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
      &def, &dt[1], &op1_vectype))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "use not simple.");
       return false;
@@ -3218,7 +3218,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
     }
   else
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "operand mode requires invariant argument.");
       return false;
@@ -3228,7 +3228,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   if (!scalar_shift_arg)
     {
       optab = optab_for_tree_code (code, vectype, optab_vector);
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "vector/vector shift/rotate found.");

@@ -3237,7 +3237,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
       if (op1_vectype == NULL_TREE
   || TYPE_MODE (op1_vectype) != TYPE_MODE (vectype))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "unusable type for last operand in"
                              " vector/vector shift/rotate.");
@@ -3252,7 +3252,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
       if (optab
           && optab_handler (optab, TYPE_MODE (vectype)) != CODE_FOR_nothing)
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location,
                              "vector/scalar shift/rotate found.");
         }
@@ -3265,7 +3265,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
             {
       scalar_shift_arg = false;

-              if (dump_kind_p (MSG_NOTE))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_NOTE, vect_location,
                                  "vector/vector shift/rotate found.");

@@ -3282,7 +3282,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
       && TYPE_MODE (TREE_TYPE (vectype))
  != TYPE_MODE (TREE_TYPE (op1)))
     {
-                      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                      if (dump_enabled_p ())
                         dump_printf_loc (MSG_MISSED_OPTIMIZATION,
vect_location,
                                          "unusable type for last operand in"
                                          " vector/vector shift/rotate.");
@@ -3302,7 +3302,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   /* Supportable by target?  */
   if (!optab)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "no optab.");
       return false;
@@ -3311,7 +3311,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   icode = (int) optab_handler (optab, vec_mode);
   if (icode == CODE_FOR_nothing)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "op not supported by target.");
       /* Check only during analysis.  */
@@ -3319,7 +3319,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
           || (vf < vect_min_worthwhile_factor (code)
               && !vec_stmt))
         return false;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location, "proceeding using
word mode.");
     }

@@ -3328,7 +3328,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
       && vf < vect_min_worthwhile_factor (code)
       && !vec_stmt)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not worthwhile without SIMD support.");
       return false;
@@ -3337,7 +3337,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
   if (!vec_stmt) /* transformation not required.  */
     {
       STMT_VINFO_TYPE (stmt_info) = shift_vec_info_type;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location, "===
vectorizable_shift ===");
       vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
       return true;
@@ -3345,7 +3345,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera

   /** Transform.  **/

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "transform binary/unary operation.");

@@ -3382,7 +3382,7 @@  vectorizable_shift (gimple stmt, gimple_stmt_itera
               optab_op2_mode = insn_data[icode].operand[2].mode;
               if (!VECTOR_MODE_P (optab_op2_mode))
                 {
-                  if (dump_kind_p (MSG_NOTE))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_NOTE, vect_location,
                                      "operand 1 using scalar mode.");
                   vec_oprnd1 = op1;
@@ -3510,7 +3510,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
   op_type = TREE_CODE_LENGTH (code);
   if (op_type != unary_op && op_type != binary_op && op_type != ternary_op)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "num. args = %d (not unary/binary/ternary op).",
                          op_type);
@@ -3529,7 +3529,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
       && code != BIT_XOR_EXPR
       && code != BIT_AND_EXPR)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "bit-precision arithmetic not supported.");
       return false;
@@ -3539,7 +3539,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
   if (!vect_is_simple_use_1 (op0, stmt, loop_vinfo, bb_vinfo,
      &def_stmt, &def, &dt[0], &vectype))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "use not simple.");
       return false;
@@ -3552,7 +3552,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
     gcc_assert (vectype);
   if (!vectype)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "no vectype for scalar type ");
@@ -3574,7 +3574,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
       if (!vect_is_simple_use (op1, stmt, loop_vinfo, bb_vinfo, &def_stmt,
        &def, &dt[1]))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "use not simple.");
   return false;
@@ -3586,7 +3586,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
       if (!vect_is_simple_use (op2, stmt, loop_vinfo, bb_vinfo, &def_stmt,
        &def, &dt[2]))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "use not simple.");
   return false;
@@ -3628,7 +3628,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
       optab = optab_for_tree_code (code, vectype, optab_default);
       if (!optab)
  {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "no optab.");
   return false;
@@ -3638,14 +3638,14 @@  vectorizable_operation (gimple stmt, gimple_stmt_i

   if (icode == CODE_FOR_nothing)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "op not supported by target.");
       /* Check only during analysis.  */
       if (GET_MODE_SIZE (vec_mode) != UNITS_PER_WORD
   || (!vec_stmt && vf < vect_min_worthwhile_factor (code)))
         return false;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location, "proceeding using word mode.");
     }

@@ -3654,7 +3654,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
       && !vec_stmt
       && vf < vect_min_worthwhile_factor (code))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not worthwhile without SIMD support.");
       return false;
@@ -3663,7 +3663,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i
   if (!vec_stmt) /* transformation not required.  */
     {
       STMT_VINFO_TYPE (stmt_info) = op_vec_info_type;
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "=== vectorizable_operation ===");
       vect_model_simple_cost (stmt_info, ncopies, dt, NULL, NULL);
@@ -3672,7 +3672,7 @@  vectorizable_operation (gimple stmt, gimple_stmt_i

   /** Transform.  **/

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "transform binary/unary operation.");

@@ -3860,7 +3860,7 @@  vectorizable_store (gimple stmt, gimple_stmt_itera
   /* FORNOW. This restriction should be relaxed.  */
   if (loop && nested_in_vect_loop_p (loop, stmt) && ncopies > 1)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "multiple types in nested loop.");
       return false;
@@ -3894,7 +3894,7 @@  vectorizable_store (gimple stmt, gimple_stmt_itera
   if (!vect_is_simple_use (op, stmt, loop_vinfo, bb_vinfo, &def_stmt,
    &def, &dt))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "use not simple.");
       return false;
@@ -3915,7 +3915,7 @@  vectorizable_store (gimple stmt, gimple_stmt_itera
     ? STMT_VINFO_DR_STEP (stmt_info) : DR_STEP (dr),
     size_zero_node) < 0)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "negative step for store.");
       return false;
@@ -3946,7 +3946,7 @@  vectorizable_store (gimple stmt, gimple_stmt_itera
               if (!vect_is_simple_use (op, next_stmt, loop_vinfo, bb_vinfo,
        &def_stmt, &def, &dt))
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                      "use not simple.");
                   return false;
@@ -4008,7 +4008,7 @@  vectorizable_store (gimple stmt, gimple_stmt_itera
       group_size = vec_num = 1;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "transform store. ncopies = %d", ncopies);

@@ -4396,7 +4396,7 @@  vectorizable_load (gimple stmt, gimple_stmt_iterat
   /* FORNOW. This restriction should be relaxed.  */
   if (nested_in_vect_loop && ncopies > 1)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "multiple types in nested loop.");
       return false;
@@ -4436,7 +4436,7 @@  vectorizable_load (gimple stmt, gimple_stmt_iterat
     (e.g. - data copies).  */
   if (optab_handler (mov_optab, mode) == CODE_FOR_nothing)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "Aligned load, but unsupported type.");
       return false;
@@ -4472,7 +4472,7 @@  vectorizable_load (gimple stmt, gimple_stmt_iterat
  &def_stmt, &def, &gather_dt,
  &gather_off_vectype))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "gather index use not simple.");
   return false;
@@ -4492,7 +4492,7 @@  vectorizable_load (gimple stmt, gimple_stmt_iterat
        size_zero_node) < 0;
       if (negative && ncopies > 1)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "multiple types with negative step.");
   return false;
@@ -4505,14 +4505,14 @@  vectorizable_load (gimple stmt, gimple_stmt_iterat
   if (alignment_support_scheme != dr_aligned
       && alignment_support_scheme != dr_unaligned_supported)
     {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "negative step but alignment required.");
       return false;
     }
   if (!perm_mask_for_reverse (vectype))
     {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                  "negative step and reversing not supported.");
       return false;
@@ -4527,7 +4527,7 @@  vectorizable_load (gimple stmt, gimple_stmt_iterat
       return true;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location,
                      "transform load. ncopies = %d", ncopies);

@@ -5334,7 +5334,7 @@  vectorizable_condition (gimple stmt, gimple_stmt_i
   /* FORNOW: not yet supported.  */
   if (STMT_VINFO_LIVE_P (stmt_info))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "value used after loop.");
       return false;
@@ -5534,7 +5534,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
   gimple pattern_stmt;
   gimple_seq pattern_def_seq;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "==> examining statement: ");
       dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
@@ -5542,7 +5542,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect

   if (gimple_has_volatile_ops (stmt))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not vectorized: stmt has volatile operands");

@@ -5575,7 +5575,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
           /* Analyze PATTERN_STMT instead of the original stmt.  */
           stmt = pattern_stmt;
           stmt_info = vinfo_for_stmt (pattern_stmt);
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_NOTE, vect_location,
                                "==> examining pattern statement: ");
@@ -5584,7 +5584,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
         }
       else
         {
-          if (dump_kind_p (MSG_NOTE))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_NOTE, vect_location, "irrelevant.");

           return true;
@@ -5597,7 +5597,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
                || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_stmt))))
     {
       /* Analyze PATTERN_STMT too.  */
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
                            "==> examining pattern statement: ");
@@ -5621,7 +5621,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
       || STMT_VINFO_LIVE_P (vinfo_for_stmt (pattern_def_stmt)))
     {
       /* Analyze def stmt of STMT if it's a pattern stmt.  */
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location,
                                    "==> examining pattern def statement: ");
@@ -5660,7 +5660,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
       gcc_assert (PURE_SLP_STMT (stmt_info));

       scalar_type = TREE_TYPE (gimple_get_lhs (stmt));
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location,
                            "get vectype for scalar type:  ");
@@ -5670,7 +5670,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
       vectype = get_vectype_for_scalar_type (scalar_type);
       if (!vectype)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
                dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                 "not SLPed: unsupported data-type ");
@@ -5680,7 +5680,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect
           return false;
         }

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_NOTE, vect_location, "vectype:  ");
           dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
@@ -5724,7 +5724,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect

   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "not vectorized: relevant stmt not ");
@@ -5746,7 +5746,7 @@  vect_analyze_stmt (gimple stmt, bool *need_to_vect

   if (!ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                            "not vectorized: live stmt not ");
@@ -5846,7 +5846,7 @@  vect_transform_stmt (gimple stmt, gimple_stmt_iter
     default:
       if (!STMT_VINFO_LIVE_P (stmt_info))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                              "stmt not supported.");
   gcc_unreachable ();
@@ -5871,7 +5871,7 @@  vect_transform_stmt (gimple stmt, gimple_stmt_iter
       tree scalar_dest;
       gimple exit_phi;

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location,
                          "Record the vdef for outer-loop vectorization.");

@@ -6108,7 +6108,7 @@  get_vectype_for_scalar_type_and_size (tree scalar_
     return NULL_TREE;

   vectype = build_vector_type (scalar_type, nunits);
-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                        "get vectype with %d units of type ", nunits);
@@ -6118,7 +6118,7 @@  get_vectype_for_scalar_type_and_size (tree scalar_
   if (!vectype)
     return NULL_TREE;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "vectype: ");
       dump_generic_expr (MSG_NOTE, TDF_SLIM, vectype);
@@ -6127,7 +6127,7 @@  get_vectype_for_scalar_type_and_size (tree scalar_
   if (!VECTOR_MODE_P (TYPE_MODE (vectype))
       && !INTEGRAL_MODE_P (TYPE_MODE (vectype)))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "mode not supported by target.");
       return NULL_TREE;
@@ -6198,7 +6198,7 @@  vect_is_simple_use (tree operand, gimple stmt, loo
   *def_stmt = NULL;
   *def = NULL_TREE;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location,
                        "vect_is_simple_use: operand ");
@@ -6220,14 +6220,14 @@  vect_is_simple_use (tree operand, gimple stmt, loo

   if (TREE_CODE (operand) == PAREN_EXPR)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_NOTE, vect_location, "non-associatable copy.");
       operand = TREE_OPERAND (operand, 0);
     }

   if (TREE_CODE (operand) != SSA_NAME)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "not ssa-name.");
       return false;
@@ -6236,13 +6236,13 @@  vect_is_simple_use (tree operand, gimple stmt, loo
   *def_stmt = SSA_NAME_DEF_STMT (operand);
   if (*def_stmt == NULL)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "no def_stmt.");
       return false;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "def_stmt: ");
       dump_gimple_stmt (MSG_NOTE, TDF_SLIM, *def_stmt, 0);
@@ -6274,13 +6274,13 @@  vect_is_simple_use (tree operand, gimple stmt, loo
   && *dt == vect_double_reduction_def
   && gimple_code (stmt) != GIMPLE_PHI))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "Unsupported pattern.");
       return false;
     }

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "type of def: %d.", *dt);

   switch (gimple_code (*def_stmt))
@@ -6299,7 +6299,7 @@  vect_is_simple_use (tree operand, gimple stmt, loo
  break;
       /* FALLTHRU */
     default:
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                          "unsupported defining stmt: ");
       return false;
Index: tree-vect-slp.c
===================================================================
--- tree-vect-slp.c (revision 192695)
+++ tree-vect-slp.c (working copy)
@@ -238,7 +238,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi
        &def, &dt)
   || (!def_stmt && dt != vect_constant_def))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: can't find def for ");
@@ -263,7 +263,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi
           pattern = true;
           if (!first && !oprnd_info->first_pattern)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: some of the stmts"
@@ -279,7 +279,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi

           if (dt == vect_unknown_def_type)
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "Unsupported pattern.");
               return false;
@@ -296,7 +296,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi
                 break;

               default:
-                if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                if (dump_enabled_p ())
                   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "unsupported defining stmt: ");
                 return false;
@@ -361,7 +361,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi
     {
       if (number_of_oprnds != 2)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "Build SLP failed: different types ");

@@ -388,7 +388,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi
                            && !types_compatible_p (oprnd_info->first_def_type,
                                                    TREE_TYPE (def_op0))))
                     {
-                      if (dump_kind_p (MSG_NOTE))
+                      if (dump_enabled_p ())
                 {
   dump_printf_loc (MSG_NOTE, vect_location,
    "Swapping operands of ");
@@ -400,7 +400,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi
     }
                   else
                     {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "Build SLP failed: different types ");

@@ -435,7 +435,7 @@  vect_get_and_check_slp_defs (loop_vec_info loop_vi

  default:
   /* FORNOW: Not supported.  */
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: illegal type of def ");
@@ -504,7 +504,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
   /* For every stmt in NODE find its def stmt/s.  */
   FOR_EACH_VEC_ELT (gimple, stmts, i, stmt)
     {
-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_NOTE, vect_location, "Build SLP for ");
   dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
@@ -513,7 +513,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
       /* Fail to vectorize statements marked as unvectorizable.  */
       if (!STMT_VINFO_VECTORIZABLE (vinfo_for_stmt (stmt)))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: unvectorizable statement ");
@@ -527,7 +527,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
       lhs = gimple_get_lhs (stmt);
       if (lhs == NULL_TREE)
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: not GIMPLE_ASSIGN nor "
@@ -544,7 +544,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
            && (cond = gimple_assign_rhs1 (stmt))
            && !COMPARISON_CLASS_P (cond))
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: condition is not "
@@ -560,7 +560,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
       vectype = get_vectype_for_scalar_type (scalar_type);
       if (!vectype)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: unsupported data-type ");
@@ -591,7 +591,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
       || !gimple_call_nothrow_p (stmt)
       || gimple_call_chain (stmt))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: unsupported call type ");
@@ -631,7 +631,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_

   if (!optab)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "Build SLP failed: no optab.");
         vect_free_oprnd_info (&oprnds_info);
@@ -640,7 +640,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
   icode = (int) optab_handler (optab, vec_mode);
   if (icode == CODE_FOR_nothing)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "Build SLP failed: "
  "op not supported by target.");
@@ -674,7 +674,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
                        || first_stmt_code == COMPONENT_REF
                        || first_stmt_code == MEM_REF)))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: different operation "
@@ -689,7 +689,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
   if (need_same_oprnds
       && !operand_equal_p (first_op1, gimple_assign_rhs2 (stmt), 0))
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: different shift "
@@ -710,7 +710,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
   || gimple_call_fntype (first_stmt)
      != gimple_call_fntype (stmt))
  {
-  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: different calls in ");
@@ -749,7 +749,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
                   || (GROUP_FIRST_ELEMENT (vinfo_for_stmt (stmt)) != stmt
                       && GROUP_GAP (vinfo_for_stmt (stmt)) != 1))
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     {
                       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: grouped "
@@ -767,7 +767,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
               if (loop_vinfo
                   && GROUP_SIZE (vinfo_for_stmt (stmt)) > ncopies * group_size)
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     {
                       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: the number "
@@ -792,7 +792,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
                       && rhs_code != REALPART_EXPR
                       && rhs_code != IMAGPART_EXPR)
                     {
-                      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                      if (dump_enabled_p ())
                         {
                           dump_printf_loc (MSG_MISSED_OPTIMIZATION,
    vect_location,
@@ -817,7 +817,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
                   if (vect_supportable_dr_alignment (first_dr, false)
                       == dr_unaligned_unsupported)
                     {
-                      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                      if (dump_enabled_p ())
                         {
                           dump_printf_loc (MSG_MISSED_OPTIMIZATION,
    vect_location,
@@ -857,7 +857,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
   if (TREE_CODE_CLASS (rhs_code) == tcc_reference)
     {
       /* Not grouped load.  */
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: not grouped load ");
@@ -875,7 +875,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
       && rhs_code != COND_EXPR
       && rhs_code != CALL_EXPR)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
  {
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: operation");
@@ -895,7 +895,7 @@  vect_build_slp_tree (loop_vec_info loop_vinfo, bb_
  first_cond_code = TREE_CODE (cond_expr);
               else if (first_cond_code != TREE_CODE (cond_expr))
                 {
-                  if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+                  if (dump_enabled_p ())
                     {
                       dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: different"
@@ -1080,7 +1080,7 @@  vect_supported_slp_permutation_p (slp_instance ins
       /* Check that the loads are all in the same interleaving chain.  */
       if (GROUP_FIRST_ELEMENT (vinfo_for_stmt (scalar_stmt)) != first_load)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             {
               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
        "Build SLP failed: unsupported data "
@@ -1169,7 +1169,7 @@  vect_supported_load_permutation_p (slp_instance sl
   if (!slp_instn)
     return false;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     {
       dump_printf_loc (MSG_NOTE, vect_location, "Load permutation ");
       FOR_EACH_VEC_ELT (int, load_permutation, i, next)
@@ -1376,7 +1376,7 @@  vect_supported_load_permutation_p (slp_instance sl
                   if (vect_supportable_dr_alignment (dr, false)
                == dr_unaligned_unsupported)
                     {
-        if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+        if (dump_enabled_p ())
         {
                     dump_printf_loc (MSG_MISSED_OPTIMIZATION,
    vect_location,
@@ -1536,7 +1536,7 @@  vect_analyze_slp_instance (loop_vec_info loop_vinf

   if (!vectype)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         {
           dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: unsupported data-type ");
@@ -1556,7 +1556,7 @@  vect_analyze_slp_instance (loop_vec_info loop_vinf
   unrolling_factor = least_common_multiple (nunits, group_size) / group_size;
   if (unrolling_factor != 1 && !loop_vinfo)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "Build SLP failed: unrolling required in basic"
  " block SLP");
@@ -1618,7 +1618,7 @@  vect_analyze_slp_instance (loop_vec_info loop_vinf

       if (unrolling_factor != 1 && !loop_vinfo)
         {
-          if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+          if (dump_enabled_p ())
             dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
      "Build SLP failed: unrolling required in basic"
      " block SLP");
@@ -1645,7 +1645,7 @@  vect_analyze_slp_instance (loop_vec_info loop_vinf
           if (!vect_supported_load_permutation_p (new_instance, group_size,
                                                   load_permutation))
             {
-              if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+              if (dump_enabled_p ())
                 {
                   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
    "Build SLP failed: unsupported load "
@@ -1685,7 +1685,7 @@  vect_analyze_slp_instance (loop_vec_info loop_vinf
         VEC_safe_push (slp_instance, heap, BB_VINFO_SLP_INSTANCES (bb_vinfo),
                        new_instance);

-      if (dump_kind_p (MSG_NOTE))
+      if (dump_enabled_p ())
  vect_print_slp_tree (MSG_NOTE, node);

       return true;
@@ -1717,7 +1717,7 @@  vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec
   gimple first_element;
   bool ok = false;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "=== vect_analyze_slp ===");

   if (loop_vinfo)
@@ -1736,7 +1736,7 @@  vect_analyze_slp (loop_vec_info loop_vinfo, bb_vec

   if (bb_vinfo && !ok)
     {
-      if (dump_kind_p (MSG_MISSED_OPTIMIZATION))
+      if (dump_enabled_p ())
         dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
  "Failed to SLP the basic block.");

@@ -1780,7 +1780,7 @@  vect_make_slp_decision (loop_vec_info loop_vinfo)
   slp_instance instance;
   int decided_to_slp = 0;

-  if (dump_kind_p (MSG_NOTE))
+  if (dump_enabled_p ())
     dump_printf_loc (MSG_NOTE, vect_location, "===
vect_make_slp_decision ===");