gcc/tree-vectorizer.c

   1 /* Vectorizer
   2    Copyright (C) 2003-2015 Free Software Foundation, Inc.
   3    Contributed by Dorit Naishlos <dorit@il.ibm.com>
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 /* Loop and basic block vectorizer.
  22
  23   This file contains drivers for the three vectorizers:
  24   (1) loop vectorizer (inter-iteration parallelism),
  25   (2) loop-aware SLP (intra-iteration parallelism) (invoked by the loop
  26       vectorizer)
  27   (3) BB vectorizer (out-of-loops), aka SLP
  28
  29   The rest of the vectorizer's code is organized as follows:
  30   - tree-vect-loop.c - loop specific parts such as reductions, etc. These are
  31     used by drivers (1) and (2).
  32   - tree-vect-loop-manip.c - vectorizer's loop control-flow utilities, used by
  33     drivers (1) and (2).
  34   - tree-vect-slp.c - BB vectorization specific analysis and transformation,
  35     used by drivers (2) and (3).
  36   - tree-vect-stmts.c - statements analysis and transformation (used by all).
  37   - tree-vect-data-refs.c - vectorizer specific data-refs analysis and
  38     manipulations (used by all).
  39   - tree-vect-patterns.c - vectorizable code patterns detector (used by all)
  40
  41   Here's a poor attempt at illustrating that:
  42
  43      tree-vectorizer.c:
  44      loop_vect()  loop_aware_slp()  slp_vect()
  45           |        /           \          /
  46           |       /             \        /
  47           tree-vect-loop.c  tree-vect-slp.c
  48                 | \      \  /      /   |
  49                 |  \      \/      /    |
  50                 |   \     /\     /     |
  51                 |    \   /  \   /      |
  52          tree-vect-stmts.c  tree-vect-data-refs.c
  53                        \      /
  54                     tree-vect-patterns.c
  55 */
  56
  57 #include "config.h"
  58 #include "system.h"
  59 #include "coretypes.h"
  60 #include "dumpfile.h"
  61 #include "backend.h"
  62 #include "predict.h"
  63 #include "tree.h"
  64 #include "gimple.h"
  65 #include "hard-reg-set.h"
  66 #include "ssa.h"
  67 #include "alias.h"
  68 #include "fold-const.h"
  69 #include "stor-layout.h"
  70 #include "tree-pretty-print.h"
  71 #include "internal-fn.h"
  72 #include "gimple-iterator.h"
  73 #include "gimple-walk.h"
  74 #include "cgraph.h"
  75 #include "tree-ssa-loop-manip.h"
  76 #include "tree-cfg.h"
  77 #include "cfgloop.h"
  78 #include "tree-vectorizer.h"
  79 #include "tree-pass.h"
  80 #include "tree-ssa-propagate.h"
  81 #include "dbgcnt.h"
  82 #include "gimple-fold.h"
  83 #include "tree-scalar-evolution.h"
  84
  85
  86 /* Loop or bb location.  */
  87 source_location vect_location;
  88
  89 /* Vector mapping GIMPLE stmt to stmt_vec_info. */
  90 vec<vec_void_p> stmt_vec_info_vec;
  91 \f
  92 /* For mapping simduid to vectorization factor.  */
  93
  94 struct simduid_to_vf : free_ptr_hash<simduid_to_vf>
  95 {
  96   unsigned int simduid;
  97   int vf;
  98
  99   /* hash_table support.  */
 100   static inline hashval_t hash (const simduid_to_vf *);
 101   static inline int equal (const simduid_to_vf *, const simduid_to_vf *);
 102 };
 103
 104 inline hashval_t
 105 simduid_to_vf::hash (const simduid_to_vf *p)
 106 {
 107   return p->simduid;
 108 }
 109
 110 inline int
 111 simduid_to_vf::equal (const simduid_to_vf *p1, const simduid_to_vf *p2)
 112 {
 113   return p1->simduid == p2->simduid;
 114 }
 115
 116 /* This hash maps the OMP simd array to the corresponding simduid used
 117    to index into it.  Like thus,
 118
 119         _7 = GOMP_SIMD_LANE (simduid.0)
 120         ...
 121         ...
 122         D.1737[_7] = stuff;
 123
 124
 125    This hash maps from the OMP simd array (D.1737[]) to DECL_UID of
 126    simduid.0.  */
 127
 128 struct simd_array_to_simduid : free_ptr_hash<simd_array_to_simduid>
 129 {
 130   tree decl;
 131   unsigned int simduid;
 132
 133   /* hash_table support.  */
 134   static inline hashval_t hash (const simd_array_to_simduid *);
 135   static inline int equal (const simd_array_to_simduid *,
 136                            const simd_array_to_simduid *);
 137 };
 138
 139 inline hashval_t
 140 simd_array_to_simduid::hash (const simd_array_to_simduid *p)
 141 {
 142   return DECL_UID (p->decl);
 143 }
 144
 145 inline int
 146 simd_array_to_simduid::equal (const simd_array_to_simduid *p1,
 147                               const simd_array_to_simduid *p2)
 148 {
 149   return p1->decl == p2->decl;
 150 }
 151
 152 /* Fold IFN_GOMP_SIMD_LANE, IFN_GOMP_SIMD_VF and IFN_GOMP_SIMD_LAST_LANE
 153    into their corresponding constants.  */
 154
 155 static void
 156 adjust_simduid_builtins (hash_table<simduid_to_vf> *htab)
 157 {
 158   basic_block bb;
 159
 160   FOR_EACH_BB_FN (bb, cfun)
 161     {
 162       gimple_stmt_iterator i;
 163
 164       for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
 165         {
 166           unsigned int vf = 1;
 167           enum internal_fn ifn;
 168           gimple stmt = gsi_stmt (i);
 169           tree t;
 170           if (!is_gimple_call (stmt)
 171               || !gimple_call_internal_p (stmt))
 172             continue;
 173           ifn = gimple_call_internal_fn (stmt);
 174           switch (ifn)
 175             {
 176             case IFN_GOMP_SIMD_LANE:
 177             case IFN_GOMP_SIMD_VF:
 178             case IFN_GOMP_SIMD_LAST_LANE:
 179               break;
 180             default:
 181               continue;
 182             }
 183           tree arg = gimple_call_arg (stmt, 0);
 184           gcc_assert (arg != NULL_TREE);
 185           gcc_assert (TREE_CODE (arg) == SSA_NAME);
 186           simduid_to_vf *p = NULL, data;
 187           data.simduid = DECL_UID (SSA_NAME_VAR (arg));
 188           if (htab)
 189             {
 190               p = htab->find (&data);
 191               if (p)
 192                 vf = p->vf;
 193             }
 194           switch (ifn)
 195             {
 196             case IFN_GOMP_SIMD_VF:
 197               t = build_int_cst (unsigned_type_node, vf);
 198               break;
 199             case IFN_GOMP_SIMD_LANE:
 200               t = build_int_cst (unsigned_type_node, 0);
 201               break;
 202             case IFN_GOMP_SIMD_LAST_LANE:
 203               t = gimple_call_arg (stmt, 1);
 204               break;
 205             default:
 206               gcc_unreachable ();
 207             }
 208           update_call_from_tree (&i, t);
 209         }
 210     }
 211 }
 212
 213 /* Helper structure for note_simd_array_uses.  */
 214
 215 struct note_simd_array_uses_struct
 216 {
 217   hash_table<simd_array_to_simduid> **htab;
 218   unsigned int simduid;
 219 };
 220
 221 /* Callback for note_simd_array_uses, called through walk_gimple_op.  */
 222
 223 static tree
 224 note_simd_array_uses_cb (tree *tp, int *walk_subtrees, void *data)
 225 {
 226   struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
 227   struct note_simd_array_uses_struct *ns
 228     = (struct note_simd_array_uses_struct *) wi->info;
 229
 230   if (TYPE_P (*tp))
 231     *walk_subtrees = 0;
 232   else if (VAR_P (*tp)
 233            && lookup_attribute ("omp simd array", DECL_ATTRIBUTES (*tp))
 234            && DECL_CONTEXT (*tp) == current_function_decl)
 235     {
 236       simd_array_to_simduid data;
 237       if (!*ns->htab)
 238         *ns->htab = new hash_table<simd_array_to_simduid> (15);
 239       data.decl = *tp;
 240       data.simduid = ns->simduid;
 241       simd_array_to_simduid **slot = (*ns->htab)->find_slot (&data, INSERT);
 242       if (*slot == NULL)
 243         {
 244           simd_array_to_simduid *p = XNEW (simd_array_to_simduid);
 245           *p = data;
 246           *slot = p;
 247         }
 248       else if ((*slot)->simduid != ns->simduid)
 249         (*slot)->simduid = -1U;
 250       *walk_subtrees = 0;
 251     }
 252   return NULL_TREE;
 253 }
 254
 255 /* Find "omp simd array" temporaries and map them to corresponding
 256    simduid.  */
 257
 258 static void
 259 note_simd_array_uses (hash_table<simd_array_to_simduid> **htab)
 260 {
 261   basic_block bb;
 262   gimple_stmt_iterator gsi;
 263   struct walk_stmt_info wi;
 264   struct note_simd_array_uses_struct ns;
 265
 266   memset (&wi, 0, sizeof (wi));
 267   wi.info = &ns;
 268   ns.htab = htab;
 269
 270   FOR_EACH_BB_FN (bb, cfun)
 271     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 272       {
 273         gimple stmt = gsi_stmt (gsi);
 274         if (!is_gimple_call (stmt) || !gimple_call_internal_p (stmt))
 275           continue;
 276         switch (gimple_call_internal_fn (stmt))
 277           {
 278           case IFN_GOMP_SIMD_LANE:
 279           case IFN_GOMP_SIMD_VF:
 280           case IFN_GOMP_SIMD_LAST_LANE:
 281             break;
 282           default:
 283             continue;
 284           }
 285         tree lhs = gimple_call_lhs (stmt);
 286         if (lhs == NULL_TREE)
 287           continue;
 288         imm_use_iterator use_iter;
 289         gimple use_stmt;
 290         ns.simduid = DECL_UID (SSA_NAME_VAR (gimple_call_arg (stmt, 0)));
 291         FOR_EACH_IMM_USE_STMT (use_stmt, use_iter, lhs)
 292           if (!is_gimple_debug (use_stmt))
 293             walk_gimple_op (use_stmt, note_simd_array_uses_cb, &wi);
 294       }
 295 }
 296
 297 /* Shrink arrays with "omp simd array" attribute to the corresponding
 298    vectorization factor.  */
 299
 300 static void
 301 shrink_simd_arrays
 302   (hash_table<simd_array_to_simduid> *simd_array_to_simduid_htab,
 303    hash_table<simduid_to_vf> *simduid_to_vf_htab)
 304 {
 305   for (hash_table<simd_array_to_simduid>::iterator iter
 306          = simd_array_to_simduid_htab->begin ();
 307        iter != simd_array_to_simduid_htab->end (); ++iter)
 308     if ((*iter)->simduid != -1U)
 309       {
 310         tree decl = (*iter)->decl;
 311         int vf = 1;
 312         if (simduid_to_vf_htab)
 313           {
 314             simduid_to_vf *p = NULL, data;
 315             data.simduid = (*iter)->simduid;
 316             p = simduid_to_vf_htab->find (&data);
 317             if (p)
 318               vf = p->vf;
 319           }
 320         tree atype
 321           = build_array_type_nelts (TREE_TYPE (TREE_TYPE (decl)), vf);
 322         TREE_TYPE (decl) = atype;
 323         relayout_decl (decl);
 324       }
 325
 326   delete simd_array_to_simduid_htab;
 327 }
 328 \f
 329 /* A helper function to free data refs.  */
 330
 331 void
 332 vect_destroy_datarefs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
 333 {
 334   vec<data_reference_p> datarefs;
 335   struct data_reference *dr;
 336   unsigned int i;
 337
 338  if (loop_vinfo)
 339     datarefs = LOOP_VINFO_DATAREFS (loop_vinfo);
 340   else
 341     datarefs = BB_VINFO_DATAREFS (bb_vinfo);
 342
 343   FOR_EACH_VEC_ELT (datarefs, i, dr)
 344     if (dr->aux)
 345       {
 346         free (dr->aux);
 347         dr->aux = NULL;
 348       }
 349
 350   free_data_refs (datarefs);
 351 }
 352
 353
 354 /* If LOOP has been versioned during ifcvt, return the internal call
 355    guarding it.  */
 356
 357 static gimple
 358 vect_loop_vectorized_call (struct loop *loop)
 359 {
 360   basic_block bb = loop_preheader_edge (loop)->src;
 361   gimple g;
 362   do
 363     {
 364       g = last_stmt (bb);
 365       if (g)
 366         break;
 367       if (!single_pred_p (bb))
 368         break;
 369       bb = single_pred (bb);
 370     }
 371   while (1);
 372   if (g && gimple_code (g) == GIMPLE_COND)
 373     {
 374       gimple_stmt_iterator gsi = gsi_for_stmt (g);
 375       gsi_prev (&gsi);
 376       if (!gsi_end_p (gsi))
 377         {
 378           g = gsi_stmt (gsi);
 379           if (is_gimple_call (g)
 380               && gimple_call_internal_p (g)
 381               && gimple_call_internal_fn (g) == IFN_LOOP_VECTORIZED
 382               && (tree_to_shwi (gimple_call_arg (g, 0)) == loop->num
 383                   || tree_to_shwi (gimple_call_arg (g, 1)) == loop->num))
 384             return g;
 385         }
 386     }
 387   return NULL;
 388 }
 389
 390 /* Fold LOOP_VECTORIZED internal call G to VALUE and
 391    update any immediate uses of it's LHS.  */
 392
 393 static void
 394 fold_loop_vectorized_call (gimple g, tree value)
 395 {
 396   tree lhs = gimple_call_lhs (g);
 397   use_operand_p use_p;
 398   imm_use_iterator iter;
 399   gimple use_stmt;
 400   gimple_stmt_iterator gsi = gsi_for_stmt (g);
 401
 402   update_call_from_tree (&gsi, value);
 403   FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
 404     {
 405       FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
 406         SET_USE (use_p, value);
 407       update_stmt (use_stmt);
 408     }
 409 }
 410 /* Set the uids of all the statements in basic blocks inside loop
 411    represented by LOOP_VINFO. LOOP_VECTORIZED_CALL is the internal
 412    call guarding the loop which has been if converted.  */
 413 static void
 414 set_uid_loop_bbs (loop_vec_info loop_vinfo, gimple loop_vectorized_call)
 415 {
 416   tree arg = gimple_call_arg (loop_vectorized_call, 1);
 417   basic_block *bbs;
 418   unsigned int i;
 419   struct loop *scalar_loop = get_loop (cfun, tree_to_shwi (arg));
 420
 421   LOOP_VINFO_SCALAR_LOOP (loop_vinfo) = scalar_loop;
 422   gcc_checking_assert (vect_loop_vectorized_call
 423                        (LOOP_VINFO_SCALAR_LOOP (loop_vinfo))
 424                        == loop_vectorized_call);
 425   bbs = get_loop_body (scalar_loop);
 426   for (i = 0; i < scalar_loop->num_nodes; i++)
 427     {
 428       basic_block bb = bbs[i];
 429       gimple_stmt_iterator gsi;
 430       for (gsi = gsi_start_phis (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 431         {
 432           gimple phi = gsi_stmt (gsi);
 433           gimple_set_uid (phi, 0);
 434         }
 435       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 436         {
 437           gimple stmt = gsi_stmt (gsi);
 438           gimple_set_uid (stmt, 0);
 439         }
 440     }
 441   free (bbs);
 442 }
 443
 444 /* Function vectorize_loops.
 445
 446    Entry point to loop vectorization phase.  */
 447
 448 unsigned
 449 vectorize_loops (void)
 450 {
 451   unsigned int i;
 452   unsigned int num_vectorized_loops = 0;
 453   unsigned int vect_loops_num;
 454   struct loop *loop;
 455   hash_table<simduid_to_vf> *simduid_to_vf_htab = NULL;
 456   hash_table<simd_array_to_simduid> *simd_array_to_simduid_htab = NULL;
 457   bool any_ifcvt_loops = false;
 458   unsigned ret = 0;
 459
 460   vect_loops_num = number_of_loops (cfun);
 461
 462   /* Bail out if there are no loops.  */
 463   if (vect_loops_num <= 1)
 464     return 0;
 465
 466   if (cfun->has_simduid_loops)
 467     note_simd_array_uses (&simd_array_to_simduid_htab);
 468
 469   init_stmt_vec_info_vec ();
 470
 471   /*  ----------- Analyze loops. -----------  */
 472
 473   /* If some loop was duplicated, it gets bigger number
 474      than all previously defined loops.  This fact allows us to run
 475      only over initial loops skipping newly generated ones.  */
 476   FOR_EACH_LOOP (loop, 0)
 477     if (loop->dont_vectorize)
 478       any_ifcvt_loops = true;
 479     else if ((flag_tree_loop_vectorize
 480               && optimize_loop_nest_for_speed_p (loop))
 481              || loop->force_vectorize)
 482       {
 483         loop_vec_info loop_vinfo;
 484         vect_location = find_loop_location (loop);
 485         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
 486             && dump_enabled_p ())
 487           dump_printf (MSG_NOTE, "\nAnalyzing loop at %s:%d\n",
 488                        LOCATION_FILE (vect_location),
 489                        LOCATION_LINE (vect_location));
 490
 491         loop_vinfo = vect_analyze_loop (loop);
 492         loop->aux = loop_vinfo;
 493
 494         if (!loop_vinfo || !LOOP_VINFO_VECTORIZABLE_P (loop_vinfo))
 495           continue;
 496
 497         if (!dbg_cnt (vect_loop))
 498           break;
 499
 500         gimple loop_vectorized_call = vect_loop_vectorized_call (loop);
 501         if (loop_vectorized_call)
 502           set_uid_loop_bbs (loop_vinfo, loop_vectorized_call);
 503         if (LOCATION_LOCUS (vect_location) != UNKNOWN_LOCATION
 504             && dump_enabled_p ())
 505           dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
 506                            "loop vectorized\n");
 507         vect_transform_loop (loop_vinfo);
 508         num_vectorized_loops++;
 509         /* Now that the loop has been vectorized, allow it to be unrolled
 510            etc.  */
 511         loop->force_vectorize = false;
 512
 513         if (loop->simduid)
 514           {
 515             simduid_to_vf *simduid_to_vf_data = XNEW (simduid_to_vf);
 516             if (!simduid_to_vf_htab)
 517               simduid_to_vf_htab = new hash_table<simduid_to_vf> (15);
 518             simduid_to_vf_data->simduid = DECL_UID (loop->simduid);
 519             simduid_to_vf_data->vf = loop_vinfo->vectorization_factor;
 520             *simduid_to_vf_htab->find_slot (simduid_to_vf_data, INSERT)
 521               = simduid_to_vf_data;
 522           }
 523
 524         if (loop_vectorized_call)
 525           {
 526             fold_loop_vectorized_call (loop_vectorized_call, boolean_true_node);
 527             ret |= TODO_cleanup_cfg;
 528           }
 529       }
 530
 531   vect_location = UNKNOWN_LOCATION;
 532
 533   statistics_counter_event (cfun, "Vectorized loops", num_vectorized_loops);
 534   if (dump_enabled_p ()
 535       || (num_vectorized_loops > 0 && dump_enabled_p ()))
 536     dump_printf_loc (MSG_NOTE, vect_location,
 537                      "vectorized %u loops in function.\n",
 538                      num_vectorized_loops);
 539
 540   /*  ----------- Finalize. -----------  */
 541
 542   if (any_ifcvt_loops)
 543     for (i = 1; i < vect_loops_num; i++)
 544       {
 545         loop = get_loop (cfun, i);
 546         if (loop && loop->dont_vectorize)
 547           {
 548             gimple g = vect_loop_vectorized_call (loop);
 549             if (g)
 550               {
 551                 fold_loop_vectorized_call (g, boolean_false_node);
 552                 ret |= TODO_cleanup_cfg;
 553               }
 554           }
 555       }
 556
 557   for (i = 1; i < vect_loops_num; i++)
 558     {
 559       loop_vec_info loop_vinfo;
 560
 561       loop = get_loop (cfun, i);
 562       if (!loop)
 563         continue;
 564       loop_vinfo = (loop_vec_info) loop->aux;
 565       destroy_loop_vec_info (loop_vinfo, true);
 566       loop->aux = NULL;
 567     }
 568
 569   free_stmt_vec_info_vec ();
 570
 571   /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins.  */
 572   if (cfun->has_simduid_loops)
 573     adjust_simduid_builtins (simduid_to_vf_htab);
 574
 575   /* Shrink any "omp array simd" temporary arrays to the
 576      actual vectorization factors.  */
 577   if (simd_array_to_simduid_htab)
 578     shrink_simd_arrays (simd_array_to_simduid_htab, simduid_to_vf_htab);
 579   delete simduid_to_vf_htab;
 580   cfun->has_simduid_loops = false;
 581
 582   if (num_vectorized_loops > 0)
 583     {
 584       /* If we vectorized any loop only virtual SSA form needs to be updated.
 585          ???  Also while we try hard to update loop-closed SSA form we fail
 586          to properly do this in some corner-cases (see PR56286).  */
 587       rewrite_into_loop_closed_ssa (NULL, TODO_update_ssa_only_virtuals);
 588       return TODO_cleanup_cfg;
 589     }
 590
 591   return ret;
 592 }
 593
 594
 595 /* Entry point to the simduid cleanup pass.  */
 596
 597 namespace {
 598
 599 const pass_data pass_data_simduid_cleanup =
 600 {
 601   GIMPLE_PASS, /* type */
 602   "simduid", /* name */
 603   OPTGROUP_NONE, /* optinfo_flags */
 604   TV_NONE, /* tv_id */
 605   ( PROP_ssa | PROP_cfg ), /* properties_required */
 606   0, /* properties_provided */
 607   0, /* properties_destroyed */
 608   0, /* todo_flags_start */
 609   0, /* todo_flags_finish */
 610 };
 611
 612 class pass_simduid_cleanup : public gimple_opt_pass
 613 {
 614 public:
 615   pass_simduid_cleanup (gcc::context *ctxt)
 616     : gimple_opt_pass (pass_data_simduid_cleanup, ctxt)
 617   {}
 618
 619   /* opt_pass methods: */
 620   opt_pass * clone () { return new pass_simduid_cleanup (m_ctxt); }
 621   virtual bool gate (function *fun) { return fun->has_simduid_loops; }
 622   virtual unsigned int execute (function *);
 623
 624 }; // class pass_simduid_cleanup
 625
 626 unsigned int
 627 pass_simduid_cleanup::execute (function *fun)
 628 {
 629   hash_table<simd_array_to_simduid> *simd_array_to_simduid_htab = NULL;
 630
 631   note_simd_array_uses (&simd_array_to_simduid_htab);
 632
 633   /* Fold IFN_GOMP_SIMD_{VF,LANE,LAST_LANE} builtins.  */
 634   adjust_simduid_builtins (NULL);
 635
 636   /* Shrink any "omp array simd" temporary arrays to the
 637      actual vectorization factors.  */
 638   if (simd_array_to_simduid_htab)
 639     shrink_simd_arrays (simd_array_to_simduid_htab, NULL);
 640   fun->has_simduid_loops = false;
 641   return 0;
 642 }
 643
 644 }  // anon namespace
 645
 646 gimple_opt_pass *
 647 make_pass_simduid_cleanup (gcc::context *ctxt)
 648 {
 649   return new pass_simduid_cleanup (ctxt);
 650 }
 651
 652
 653 /*  Entry point to basic block SLP phase.  */
 654
 655 namespace {
 656
 657 const pass_data pass_data_slp_vectorize =
 658 {
 659   GIMPLE_PASS, /* type */
 660   "slp", /* name */
 661   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 662   TV_TREE_SLP_VECTORIZATION, /* tv_id */
 663   ( PROP_ssa | PROP_cfg ), /* properties_required */
 664   0, /* properties_provided */
 665   0, /* properties_destroyed */
 666   0, /* todo_flags_start */
 667   TODO_update_ssa, /* todo_flags_finish */
 668 };
 669
 670 class pass_slp_vectorize : public gimple_opt_pass
 671 {
 672 public:
 673   pass_slp_vectorize (gcc::context *ctxt)
 674     : gimple_opt_pass (pass_data_slp_vectorize, ctxt)
 675   {}
 676
 677   /* opt_pass methods: */
 678   opt_pass * clone () { return new pass_slp_vectorize (m_ctxt); }
 679   virtual bool gate (function *) { return flag_tree_slp_vectorize != 0; }
 680   virtual unsigned int execute (function *);
 681
 682 }; // class pass_slp_vectorize
 683
 684 unsigned int
 685 pass_slp_vectorize::execute (function *fun)
 686 {
 687   basic_block bb;
 688
 689   bool in_loop_pipeline = scev_initialized_p ();
 690   if (!in_loop_pipeline)
 691     {
 692       loop_optimizer_init (LOOPS_NORMAL);
 693       scev_initialize ();
 694     }
 695
 696   init_stmt_vec_info_vec ();
 697
 698   FOR_EACH_BB_FN (bb, fun)
 699     {
 700       vect_location = find_bb_location (bb);
 701
 702       if (vect_slp_analyze_bb (bb))
 703         {
 704           if (!dbg_cnt (vect_slp))
 705             break;
 706
 707           vect_slp_transform_bb (bb);
 708           if (dump_enabled_p ())
 709             dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, vect_location,
 710                              "basic block vectorized\n");
 711         }
 712     }
 713
 714   free_stmt_vec_info_vec ();
 715
 716   if (!in_loop_pipeline)
 717     {
 718       scev_finalize ();
 719       loop_optimizer_finalize ();
 720     }
 721
 722   return 0;
 723 }
 724
 725 } // anon namespace
 726
 727 gimple_opt_pass *
 728 make_pass_slp_vectorize (gcc::context *ctxt)
 729 {
 730   return new pass_slp_vectorize (ctxt);
 731 }
 732
 733
 734 /* Increase alignment of global arrays to improve vectorization potential.
 735    TODO:
 736    - Consider also structs that have an array field.
 737    - Use ipa analysis to prune arrays that can't be vectorized?
 738      This should involve global alignment analysis and in the future also
 739      array padding.  */
 740
 741 static unsigned int
 742 increase_alignment (void)
 743 {
 744   varpool_node *vnode;
 745
 746   vect_location = UNKNOWN_LOCATION;
 747
 748   /* Increase the alignment of all global arrays for vectorization.  */
 749   FOR_EACH_DEFINED_VARIABLE (vnode)
 750     {
 751       tree vectype, decl = vnode->decl;
 752       tree t;
 753       unsigned int alignment;
 754
 755       t = TREE_TYPE (decl);
 756       if (TREE_CODE (t) != ARRAY_TYPE)
 757         continue;
 758       vectype = get_vectype_for_scalar_type (strip_array_types (t));
 759       if (!vectype)
 760         continue;
 761       alignment = TYPE_ALIGN (vectype);
 762       if (DECL_ALIGN (decl) >= alignment)
 763         continue;
 764
 765       if (vect_can_force_dr_alignment_p (decl, alignment))
 766         {
 767           vnode->increase_alignment (TYPE_ALIGN (vectype));
 768           dump_printf (MSG_NOTE, "Increasing alignment of decl: ");
 769           dump_generic_expr (MSG_NOTE, TDF_SLIM, decl);
 770           dump_printf (MSG_NOTE, "\n");
 771         }
 772     }
 773   return 0;
 774 }
 775
 776
 777 namespace {
 778
 779 const pass_data pass_data_ipa_increase_alignment =
 780 {
 781   SIMPLE_IPA_PASS, /* type */
 782   "increase_alignment", /* name */
 783   OPTGROUP_LOOP | OPTGROUP_VEC, /* optinfo_flags */
 784   TV_IPA_OPT, /* tv_id */
 785   0, /* properties_required */
 786   0, /* properties_provided */
 787   0, /* properties_destroyed */
 788   0, /* todo_flags_start */
 789   0, /* todo_flags_finish */
 790 };
 791
 792 class pass_ipa_increase_alignment : public simple_ipa_opt_pass
 793 {
 794 public:
 795   pass_ipa_increase_alignment (gcc::context *ctxt)
 796     : simple_ipa_opt_pass (pass_data_ipa_increase_alignment, ctxt)
 797   {}
 798
 799   /* opt_pass methods: */
 800   virtual bool gate (function *)
 801     {
 802       return flag_section_anchors && flag_tree_loop_vectorize;
 803     }
 804
 805   virtual unsigned int execute (function *) { return increase_alignment (); }
 806
 807 }; // class pass_ipa_increase_alignment
 808
 809 } // anon namespace
 810
 811 simple_ipa_opt_pass *
 812 make_pass_ipa_increase_alignment (gcc::context *ctxt)
 813 {
 814   return new pass_ipa_increase_alignment (ctxt);
 815 }